v5.3.0

Add failing tests that document ES 6 generators bug

.babelrc

@@ -1,6 +1,6 @@
 {
-  "experimental": true,
-  "playground": true,
-  "loose": true,
-  "blacklist": ["es6.tailCall"]
+  "stage": 0,
+  "loose": ["all"],
+  "blacklist": ["es6.tailCall"],
+  "optional": ["optimisation.flow.forOf"]
 }

.gitmodules

@@ -1,12 +1,3 @@
 [submodule "vendor/traceur"]
 	path = vendor/traceur
 	url = https://github.com/google/traceur-compiler
-[submodule "vendor/regenerator"]
-	path = vendor/regenerator
-	url = https://github.com/babel/regenerator-babel
-[submodule "vendor/test262"]
-	path = vendor/test262
-	url = https://github.com/tc39/test262
-[submodule "vendor/compat-table"]
-	path = vendor/compat-table
-	url = https://github.com/kangax/compat-table

.travis.yml

@@ -1,4 +1,4 @@
-sudo: false
+#sudo: false
 language: node_js
 cache:
   directories:

CHANGELOG.md

@@ -13,6 +13,212 @@ _Note: Gaps between patch versions are faulty/broken releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 5.3.0
+
+**Speeeeeeed**
+
+![gifs lol](https://31.media.tumblr.com/568205a0e37ae15eca510fa639589a59/tumblr_n8kw8kpcSb1sg6cg8o1_500.gif)
+
+ * **Spec Compliancy**
+  * Allow trailing param commas for methods when using the `es7.trailingCommas` transformer.
+ * **Bug Fix**
+  * Fix `es6.blockScoping` transformer not properly ignoring `break` in `SwitchCase`.
+  * Fix lookahead context saving to avoid weird tokenizer state.
+  * Explode duplicate identifiers in export/import specifiers and property shorthand to create unique objects.
+  * Skip loose mode for class methods when they have decorators.
+  * When removing nodes, share their comments with their siblings.
+  * Properly hoist temp param declarations when doing TCO.
+ * **Internal**
+  * Add `--harmony_generators` flag to `$ babel-node`.
+ * **Polish**
+  * Move many `utility` transformers to `minification`.
+
+## 5.2.17
+
+ * **Bug Fix**
+  * Fix auxiliary comments not properly being attached to function declaration helpers.
+  * Add `Super` node type to `ast-types` patch.
+  * Ignore parameter bindings when attempting to inline them in the `minification.deadCodeElimination` transformer.
+  * Correct `extensions` arguments when using the Babel CLI.
+
+## 5.2.16
+
+ * **Bug Fix**
+  * Fix plugins being disabled when using the whitelist.
+  * Fix correct function scope being passed to `nameMethod.property` when inferring the function name for class methods.
+  * Fix incorrect extensions reference causing weird issues when using the Babel CLI.
+  * Fix destructuring param reference replacements not inheriting from their original param.
+ * **Spec Compliancy**
+  * Fix order that method decorators are ran in.
+
+## 5.2.15
+
+ * **Bug Fix**
+  * Fix initializer descriptor add attempt if it doesn't exist.
+
+## 5.2.14
+
+ * **Bug Fix**
+  * Fix bug with initializer decorators where the descriptors weren't being defined if there was no `initializer` property.
+ * **Internal**
+  * Expose `retainLines` option to CLI.
+  * Fix `retainLines` option not being taken into consideration when doing multiple variable declaration declarators generation.
+  * Expose minified and unminified copies of dist scripts.
+
+## 5.2.13
+
+ * **Bug Fix**
+  * Fix `ExportDeclaration`s being incorrectly removed when using the `utility.deadCodeElimination` transformer.
+  * Fix position of `utility` transformers.
+ * **New Feature**
+  * Add built-in `esquery` support.
+ * **Internal**
+  * Consolidate notion of "virtual types".
+
+## 5.2.12
+
+ * **Polish**
+  * Make UID generation based on module declarations **much** nicer.
+ * **Internal**
+  * Remove internal check for traversal path replacement of self. This is a pattern that **could** come up in the wild and it could lead to pretty nasty code and may lead to internal regressions as the test coverage isn't 100% :( Instead, just put it in the fast path.
+
+## 5.2.11
+
+ * **Internal**
+  * Rename `getModuleName` option to `getModuleId`, doh.
+
+## 5.2.10
+
+ * **Bug Fix**
+  * Fix numerous issues in `replaceWithSourceString`. Thanks [@pangratz](https://github.com/pangratz)!
+ * **New Feature**
+  * Add `getModuleName` option. Thanks [@jayphelps](https://github.com/jayphelps)!
+
+## 5.2.9
+
+ * **Bug Fix**
+  * Fix `_blockHoist` transformer incorrectly sorting nodes on shitty environments that aren't spec compliant in their key order.
+  * Fix broken `parse` API method reference to an undeclared import.
+
+## 5.2.7
+
+ * **Bug Fix**
+  * Move `utility.deadCodeElimination` transformer up to avoid race conditions.
+  * Fix shorthand property scope binding renaming.
+ * **Polish**
+  * Turn helper variable declarations into function declarations if possible.
+ * **Internal**
+  * Removed native inheritance support from classes.
+  * Added `replaceWithSourceString` path API.
+  * Split up `es3.propertyLiterals` and `es3.memberExpressionLiterals` transformers to `minfication.propertyLiterals` and `es3.memberExpressionLiterals`.
+
+## 5.2.6
+
+ * **Internal**
+  * Fix transformer aliases being accidently set as deprecated ones.
+  * Expose `Pipeline` as `TransformerPipeline` instead.
+
+## 5.2.5
+
+ * **Bug Fix**
+  * Fix `parse` API not adding all the correct pipeline transformers.
+
+## 5.2.4
+
+ * **Bug Fix**
+  * Fix race condition with the Node API being loaded awkwardly and not being able to initialise itself when used in the browser.
+ * **Internal**
+  * Expose `transform.pipeline`.
+
+## 5.2.3
+
+ * **Bug Fix**
+  * Fix plugin containers being called with an undefined import. Thanks [@timbur](https://github.com/timbur)!
+  * Allow Flow object separators to be commas. Thanks [@monsanto](https://github.com/monsanto)!
+  * Add missing `Statement` and `Declaration` node aliases to flow types.
+
+## 5.2.2
+
+ * **Internal**
+  * Allow `util.arrayify` to take arbitrary types and coerce it into an array.
+
+## 5.2.1
+
+ * **Bug Fix**
+  * Fix regression in `node/register` that caused `node_modules` to not be ignored.
+
+## 5.2.0
+
+ * **Bug Fix**
+  * Fix plugin strings splitting arbitrarily on `:` which caused full paths on Windows to fail as they include `:` after the drive letter.
+  * Call class property `initializer`s with their target instead of their descriptor.
+  * Fix `ignore` and `only` not properly working on Windows path separators. Thanks [@stagas](https://github.com/stagas)!
+  * Fix `resolveRc` running on files twice causing issues. Thanks [@lukescott](https://github.com/lukescott)!
+  * Fix shorthand properties not correctly being target for `isReferenced` checks. Thanks [@monsanto](https://github.com/monsanto)!
+ * **Polish**
+  * Allow passing an array of globs to `babel/register` `only` and `ignore` options. Thanks [@Mark-Simulacrum](https://github.com/Mark-Simulacrum)!
+  * When inferring function names that collide with upper bindings, instead of doing the wrapper, instead rename them.
+  * Consider constant-like variable declaration functions to always refer to themselves so TOC can be performed.
+  * Process globs manually when using `$ babel` as some shells such as Windows don't explode them. Thanks [@jden](https://github.com/jden)!
+  * Add alternative way to execute plugins via a closure that's called with the current Babel instance.
+ * **Internal**
+  * Remove multiple internal transformers in favor of directly doing things when we need to. Previously, declarations such as `_ref` that we needed to create in specific scopes were done at the very end via the `_declarations` transformer. Now, they're done and added to the scope **right** when they're needed. This gets rid of the crappy `_declarations` property on scope nodes and fixes the crappy regenerator bug where it was creating a new `BlockStatement` so the declarations were being lost.
+  * Rework transformer traversal optimisation. Turns out that calling a `check` function for **every single node** in the AST is ridiculously expensive. 300,000 nodes timesed by ~30 transformers meant that it took tens of seconds to perform while it's quicker to just do the unnecessary traversal. Seems obvious in hindsight.
+ * **New Feature**
+  * Add `jscript` transformer that turns named function expressions into function declarations to get around [JScript's horribly broken function expression semantics](https://kangax.github.io/nfe/#jscript-bugs). Thanks [@kondi](https://github.com/kondi)!
+  * Add `@@hasInstance` support to objects when using the `es6.spec.symbols` transformer.
+  * Add `retainLines` option that retains the line (but not the columns!) of the input code.
+
+## 5.1.13
+
+ * **Polish**
+  * Remove symbol check from `defineProperty` helper.
+
+## 5.1.12
+
+ * **Bug Fix**
+  * Fix `resolveModuleSource` not being ran on `ExportAllDeclaration`s.
+  * Fix `.babelrc` being resolved multiple times when using the require hook.
+  * Fix parse error on spread properties in assignment position.
+  * Fix `externalHelpers` option being incorrectly listed as type `string`.
+ * **Internal**
+  * Upgrade `core-js` to `0.9.0`.
+ * **Spec Compliancy**
+  * Fix object decorators not using the `initializer` pattern.
+  * Remove property initializer descriptor reflection.
+
+## 5.1.11
+
+ * **Bug Fix**
+  * Memoise and bind member expression decorators.
+  * Move JSX children cleaning to opening element visitor. Fixes elements not being cleaned in certain scenarios.
+  * Consider `SwitchStatement`s to be `Scopable`.
+  * Fix `bluebirdCoroutines` calling `interopRequireWildcard` before it's defined.
+  * Add space to `do...while` code generation.
+  * Validate `super` use before `this` on `super` exit rather than entrance.
+ * **Polish**
+  * Add Babel name to logger.
+
+## 5.1.10
+
+ * **Bug Fix**
+  * Remove `makePredicate` from acorn in favor of an `indexOf`.
+  * Remove statements to expression explosion when inserting a block statement.
+ * **Internal**
+  * Remove runtime compatibility check.
+
+## 5.1.9
+
+ * **Bug Fix**
+  * Fix class property initializers with `undefined` values not being correctly writable.
+  * Fix self inferring generators incorrectly causing a stack error.
+  * Fix default export specifiers not triggering AMD `module` argument inclusion.
+  * Fix assignments not having their module references properly remapped.
+ * **Internal**
+  * Upgrade to latest `acorn`.
+ * **Polish**
+  * Make invalid LHS pattern error messages nicer.
+
 ## 5.1.8
 
  * **Bug Fix**

CONTRIBUTING.md

@@ -1,9 +1,24 @@
+<p align="center">
+   <strong><a href="#setup">Setup</a></strong>
+   |
+   <strong><a href="#running-tests">Running tests</a></strong>
+   |
+   <strong><a href="#workflow">Workflow</a></strong>
+   |
+   <strong><a href="#dependencies">Dependencies</a></strong>
+   |
+   <strong><a href="#code-standards">Code Standards</a></strong>
+</p>
+
+----
+
 # Contributing
 
 Contributions are always welcome, no matter how large or small. Before
 contributing, please read the
 [code of conduct](https://github.com/babel/babel/blob/master/CODE_OF_CONDUCT.md).
 
+
 ## Developing
 
 #### Setup
@@ -14,14 +29,19 @@ $ cd babel
 $ make bootstrap
 ```
 
-Then you need to run:
+Then you can either run:
+
+```sh
+$ make build-core
+```
+
+to build Babel **once** or:
 
 ```sh
 $ make watch-core
 ```
 
-This will compile Babel and then sit in the background and on file modification
-recompile the necessary files.
+to have Babel build itself then incrementally build files on change.
 
 #### Running tests
 
@@ -44,6 +64,11 @@ Use mocha's `--grep` option to run a subset of tests by name:
 $ mocha test/core/transformation.js --grep es7
 ```
 
+If you don't have `mocha` installed globally, you can still use it from Babel's
+dependencies in `node_modules`, but make sure `node_modules/.bin` is added to
+your [`$PATH`](http://unix.stackexchange.com/questions/26047/how-to-correctly-add-a-path-to-path) environment variable.
+
+
 #### Workflow
 
 * Fork the repository
@@ -54,24 +79,91 @@ $ mocha test/core/transformation.js --grep es7
 * Ensure the test are passing (`make test`)
 * Create new pull request explaining your proposed change or reference an issue in your commit message
 
+
+#### Dependencies
+
++ [ast-types](http://ghub.io/ast-types) This is required to monkeypatch regenerators AST definitions. Could be improved in the future.
+
++ [chalk](http://ghub.io/chalk) This is used for terminal color highlighting for syntax errors.
+
++ [convert-source-map](http://ghub.io/convert-source-map) Turns a source map object into a comment etc.
+
++ [core-js](http://ghub.io/core-js) Used for the polyfill.
+
++ [debug](http://ghub.io/debug) Used to output debugging information when NODE_DEBUG is set to babel.
+
++ [detect-indent](http://ghub.io/detect-indent) This is used in the code generator so it can infer indentation.
+
++ [estraverse](http://ghub.io/estraverse) The only method on this is attachComments. I'd like to implement our own comment attachment algorithm eventually though.
+
++ [esutils](http://ghub.io/esutils) Various ES related utilities. Check whether something is a keyword etc.
+
++ [fs-readdir-recursive](http://ghub.io/fs-readdir-recursive) Recursively search a directory for.
+
++ [globals](http://ghub.io/globals) A list of JavaScript global variables. This is used by the scope tracking to check for colliding variables.
+
++ [is-integer](http://ghub.io/is-integer) Checks if something is an integer.
+
++ [js-tokens](http://ghub.io/js-tokens) This is used to get tokens for syntax error highlighting.
+
++ [leven](http://ghub.io/leven) A levenstein algorithm to determine how close a word is to another. This is used to offer suggestions when using the utility.undeclaredVariableCheck transformer.
+
++ [line-numbers](http://ghub.io/line-numbers) Used to produce the code frames in syntax errors.
+
++ [lodash](http://ghub.io/lodash) Used for various utilities.
+
++ [minimatch](http://ghub.io/minimatch) This is used to match glob-style ignore/only filters.
+
++ [output-file-sync](http://ghub.io/output-file-sync) Synchronously writes a file and create its ancestor directories if needed.
+
++ [path-is-absolute](http://ghub.io/path-is-absolute) Checks if a path is absolute. C:\foo and \foo are considered absolute.
+
++ [regenerator](http://ghub.io/regenerator) This is used to transform generators/async functions.
+
++ [regexpu](http://ghub.io/regexpu) Used to transform unicode regex patterns.
+
++ [repeating](http://ghub.io/repeating) Repeats a string.
+
++ [shebang-regex](http://ghub.io/shebang-regex) Literally just a regex that matches shebangs.
+
++ [slash](http://ghub.io/slash) Normalises path separators.
+
++ [source-map](http://ghub.io/source-map) Generates sourcemaps.
+
++ [source-map-support](http://ghub.io/source-map-support) Adds source map support to babel-node/babel/register.
+
++ [strip-json-comments](http://ghub.io/strip-json-comments) Remove comments from a JSON string. This is used for .babelrc files.
+
++ [to-fast-properties](http://ghub.io/to-fast-properties) A V8 trick to put an object into fast properties mode.
+
++ [trim-right](http://ghub.io/trim-right) Trims the rightside whitespace.
+
++ [user-home](http://ghub.io/user-home) Gets the users home directory. This is used to resolve the babel-node/babel/register cache.
+
+
 #### Code Standards
 
  * **General**
    * Max of five arguments for functions
    * Max depth of four nested blocks
    * 2-spaced soft tabs
+
  * **Naming**
    * CamelCase all class names
    * camelBack all variable names
+
  * **Spacing**
    * Spaces after all keywords
    * Spaces before all left curly braces
+
  * **Comments**
    * Use JSDoc-style comments for methods
    * Single-line comments for ambiguous code
+
  * **Quotes**
    * Always use double quotes
    * Only use single quotes when the string contains a double quote
+
  * **Declaration**
    * No unused variables
    * No pollution of global variables and prototypes

Makefile

@@ -3,23 +3,25 @@ BROWSERIFY_CMD = node_modules/browserify/bin/cmd.js
 ISTANBUL_CMD = node_modules/istanbul/lib/cli.js cover
 UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs
 #UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs --mangle sort
-JSHINT_CMD = node_modules/jshint/bin/jshint
 MOCHA_CMD = node_modules/mocha/bin/_mocha
 BABEL_CMD = node_modules/babel/bin/babel
 
 export NODE_ENV = test
 
-.PHONY: clean test test-cov test-clean test-travis test-simple test-all test-browser test-parser publish build bootstrap publish-core publish-runtime build-core watch-core build-core-test
+.PHONY: clean test test-cov test-clean test-travis test-simple test-all test-browser test-parser publish build bootstrap publish-core publish-runtime build-core watch-core build-core-test clean-core
 
-build-core:
+build-core: clean-core
 	node $(BABEL_CMD) src --out-dir lib --copy-files
 
-build-core-test:
+build-core-test: clean-core
 	node $(BABEL_CMD) src --out-dir lib --copy-files --auxiliary-comment "istanbul ignore next"
 
-watch-core:
+watch-core: clean-core
 	node $(BABEL_CMD) src --out-dir lib --watch --copy-files
 
+clean-core:
+	rm -rf lib
+
 build:
 	mkdir -p dist
 	make build-core
@@ -80,9 +82,15 @@ publish:
 	npm version $$version --message "v%s"
 
 	make build
-	cp dist/babel.min.js browser.js
-	cp dist/polyfill.min.js browser-polyfill.js
-	cp dist/external-helpers.min.js external-helpers.js
+
+	cp dist/babel.js browser.js
+	cp dist/babel.min.js browser.min.js
+
+	cp dist/polyfill.js browser-polyfill.js
+	cp dist/polyfill.min.js browser-polyfill.min.js
+
+	cp dist/external-helpers.js external-helpers.js
+	cp dist/external-helpers.min.js external-helpers.min.js
 
 	node tools/cache-templates
 	test -f templates.json
@@ -94,7 +102,7 @@ publish:
 	make publish-cli
 	make publish-runtime
 
-	rm -rf templates.json browser.js browser-polyfill.js external-helpers.js
+	rm -rf templates.json browser.js browser.min.js browser-polyfill.js browser-polyfill.min.js external-helpers.js external-helpers.min.js
 
 publish-runtime:
 	cd packages; \
@@ -114,5 +122,4 @@ bootstrap:
 	npm link
 	cd packages/babel-cli && npm install && npm link && npm link babel-core
 	git submodule update --init
-	cd vendor/regenerator && npm install
-	cd vendor/compat-table && npm install object-assign
+	make build

package.json

@@ -1,9 +1,10 @@
 {
   "name": "babel-core",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.1.8",
+  "version": "5.3.0",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
   "main": "lib/babel/api/node.js",
   "browser": {
@@ -27,13 +28,16 @@
     "test": "make test"
   },
   "dependencies": {
+    "acorn-jsx": "^1.0.0",
     "ast-types": "~0.7.0",
+    "bluebird": "^2.9.25",
     "chalk": "^1.0.0",
-    "convert-source-map": "^1.0.0",
-    "core-js": "^0.8.3",
+    "convert-source-map": "^1.1.0",
+    "core-js": "^0.9.0",
     "debug": "^2.1.1",
     "detect-indent": "^3.0.0",
-    "estraverse": "^3.0.0",
+    "esquery": "^0.4.0",
+    "estraverse": "^4.0.0",
     "esutils": "^2.0.0",
     "fs-readdir-recursive": "^0.1.0",
     "globals": "^6.4.0",
@@ -49,6 +53,7 @@
     "regenerator": "^0.8.20",
     "regexpu": "^1.1.2",
     "repeating": "^1.1.2",
+    "resolve": "^1.1.6",
     "shebang-regex": "^1.0.0",
     "slash": "^1.0.0",
     "source-map": "^0.4.0",
@@ -59,7 +64,7 @@
     "user-home": "^1.1.1"
   },
   "devDependencies": {
-    "babel": "4.7.13",
+    "babel": "5.1.13",
     "browserify": "^9.0.8",
     "chai": "^2.2.0",
     "eslint": "^0.18.0",

packages/babel-cli/bin/babel-node

@@ -55,6 +55,8 @@ babelArgs.forEach(function(arg){
     case "--harmony_classes":
     case "--harmony_object_literals":
     case "--harmony_templates":
+    case "--harmony_rest_parameters":
+    case "--harmony_generators":
     case "--compiled_keyed_generic_loads":
     case "--pretenuring_call_new":
     case "--allocation_site_pretenuring":

packages/babel-cli/bin/babel/dir.js

@@ -30,7 +30,7 @@ module.exports = function (commander, filenames, opts) {
   var handleFile = function (src, filename) {
     if (util.shouldIgnore(src)) return;
 
-    if (util.canCompile(filename)) {
+    if (util.canCompile(filename, commander.extensions)) {
       write(src, filename);
     } else if (commander.copyFiles) {
       outputFileSync(path.join(commander.outDir, filename), fs.readFileSync(src));

packages/babel-cli/bin/babel/file.js

@@ -27,9 +27,14 @@ module.exports = function (commander, filenames, opts) {
 
       if (result.map) {
         var consumer = new sourceMap.SourceMapConsumer(result.map);
+        var sourceFilename = filename;
 
-        map._sources.add(filename);
-        map.setSourceContent(filename, result.actual);
+        if (commander.outFile) {
+          sourceFilename = path.relative(path.dirname(commander.outFile), sourceFilename);
+        }
+
+        map._sources.add(sourceFilename);
+        map.setSourceContent(sourceFilename, result.actual);
 
         consumer.eachMapping(function (mapping) {
           map._mappings.add({
@@ -37,7 +42,7 @@ module.exports = function (commander, filenames, opts) {
             generatedColumn: mapping.generatedColumn,
             originalLine: mapping.originalLine,
             originalColumn: mapping.originalColumn,
-            source: filename
+            source: sourceFilename
           });
         });
 

packages/babel-cli/bin/babel/index.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
 
-var commander = require("commander");
-var transform = require("babel-core").transform;
-var kebabCase = require("lodash/string/kebabCase");
-var options   = require("babel-core").options;
-var util      = require("babel-core").util;
-var each      = require("lodash/collection/each");
-var keys      = require("lodash/object/keys");
-var fs        = require("fs");
+var moduleFormatters = require("babel-core/lib/babel/transformation/modules");
+var commander        = require("commander");
+var transform        = require("babel-core").transform;
+var kebabCase        = require("lodash/string/kebabCase");
+var options          = require("babel-core").options;
+var util             = require("babel-core").util;
+var each             = require("lodash/collection/each");
+var keys             = require("lodash/object/keys");
+var fs               = require("fs");
+var glob             = require("glob");
 
 each(options, function (option, key) {
   if (option.hidden) return;
@@ -35,6 +37,7 @@ each(options, function (option, key) {
   commander.option(arg, desc.join(" "));
 })
 
+commander.option("-x, --extensions [extensions]", "List of extensions to compile when a directory has been input [.es6,.js,.es,.jsx]");
 commander.option("-w, --watch", "Recompile files on changes");
 commander.option("-o, --out-file [out]", "Compile all input files into a single file");
 commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
@@ -56,8 +59,8 @@ commander.on("--help", function () {
     console.log();
   };
 
-  outKeys("Transformers", transform.transformers);
-  outKeys("Module formatters", transform.moduleFormatters);
+  outKeys("Transformers", transform.pipeline.transformers);
+  outKeys("Module formatters", moduleFormatters);
 });
 
 var pkg = require("../../package.json");
@@ -67,9 +70,17 @@ commander.parse(process.argv);
 
 //
 
+if (commander.extensions) {
+  commander.extensions = util.arrayify(commander.extensions);
+}
+
+//
+
 var errors = [];
 
-var filenames = commander.args;
+var filenames = commander.args.reduce(function (globbed, input) {
+  return globbed.concat(glob.sync(input));
+}, []);
 
 each(filenames, function (filename) {
   if (!fs.existsSync(filename)) {

packages/babel-cli/package.json

@@ -1,21 +1,22 @@
 {
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.1.7",
+  "version": "5.2.17",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
   "repository": "babel/babel",
   "preferGlobal": true,
   "dependencies": {
-    "babel-core": "^5.1.7",
+    "babel-core": "^5.2.17",
     "chokidar": "^1.0.0",
     "commander": "^2.6.0",
+    "convert-source-map": "^1.1.0",
     "fs-readdir-recursive": "^0.1.0",
-    "output-file-sync": "^1.1.0",
+    "glob": "^5.0.5",
     "lodash": "^3.2.0",
-    "convert-source-map": "^0.5.0",
-    "source-map": "^0.4.0",
-    "path-is-absolute": "^1.0.0"
+    "output-file-sync": "^1.1.0",
+    "path-is-absolute": "^1.0.0",
+    "source-map": "^0.4.0"
   },
   "bin": {
     "babel": "./bin/babel/index.js",

packages/babel-cli/register-without-polyfill.js

@@ -0,0 +1 @@
+module.exports = require("babel-core/register-without-polyfill");

packages/babel-runtime/package.json

@@ -1,10 +1,10 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "5.1.7",
+  "version": "5.2.17",
   "repository": "babel/babel",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "dependencies": {
-    "core-js": "^0.8.0"
+    "core-js": "^0.9.0"
   }
 }

packages/build-runtime.js

@@ -70,8 +70,8 @@ each(File.helpers, function (helperName) {
   writeFile("helpers/" + helperName + ".js", buildHelper(helperName));
 });
 
-writeFile("regenerator/index.js", readFile("regenerator-babel/runtime-module", true));
-writeFile("regenerator/runtime.js", selfContainify(readFile("regenerator-babel/runtime")));
+writeFile("regenerator/index.js", readFile("regenerator/runtime-module", true));
+writeFile("regenerator/runtime.js", selfContainify(readFile("regenerator/runtime")));
 
 //
 

register-without-polyfill.js

@@ -0,0 +1 @@
+module.exports = require("./lib/babel/api/register/node");

register.js

@@ -1 +1 @@
-module.exports = require("./lib/babel/api/register/node");
+module.exports = require("./lib/babel/api/register/node-polyfill");

src/acorn/index.js

@@ -0,0 +1,6 @@
+export * from "./src/index";
+import "./plugins/flow";
+
+import inject from "acorn-jsx/inject";
+import * as acorn from "./src/index";
+inject(acorn);

src/acorn/package.json

@@ -2,7 +2,7 @@
   "name": "acorn",
   "description": "ECMAScript parser",
   "homepage": "https://github.com/marijnh/acorn",
-  "main": "src/index.js",
+  "main": "index.js",
   "version": "1.0.0",
   "engines": {
     "node": ">=0.4.0"

src/acorn/plugins/flow.js

@@ -1,4 +1,4 @@
-var acorn = require("..")
+var acorn = require("../src/index")
 
 var pp = acorn.Parser.prototype
 var tt = acorn.tokTypes
@@ -153,10 +153,15 @@ pp.flow_parseTypeAlias = function (node) {
     node.typeParameters = null
   }
 
+  var oldInType = this.inType;
+  this.inType = true;
+
   this.expect(tt.eq)
 
   node.right = this.flow_parseType()
 
+  this.inType = oldInType;
+
   this.semicolon()
 
   return this.finishNode(node, "TypeAlias")
@@ -322,7 +327,7 @@ pp.flow_parseObjectType = function (allowStatic) {
 }
 
 pp.flow_objectTypeSemicolon = function () {
-  if (!this.eat(tt.semi) && this.type !== tt.braceR) {
+  if (!this.eat(tt.semi) && !this.eat(tt.comma) && this.type !== tt.braceR) {
     this.unexpected()
   }
 }

src/acorn/plugins/jsx.js

@@ -1,658 +0,0 @@
-var acorn = require("..")
-
-var tt = acorn.tokTypes;
-var tc = acorn.tokContexts;
-
-tc.j_oTag = new acorn.TokContext("<tag", false);
-tc.j_cTag = new acorn.TokContext("</tag", false);
-tc.j_expr = new acorn.TokContext("<tag>...</tag>", true, true);
-
-tt.jsxName = new acorn.TokenType("jsxName");
-tt.jsxText = new acorn.TokenType("jsxText", {beforeExpr: true});
-tt.jsxTagStart = new acorn.TokenType("jsxTagStart");
-tt.jsxTagEnd = new acorn.TokenType("jsxTagEnd");
-
-tt.jsxTagStart.updateContext = function() {
-  this.context.push(tc.j_expr); // treat as beginning of JSX expression
-  this.context.push(tc.j_oTag); // start opening tag context
-  this.exprAllowed = false;
-};
-tt.jsxTagEnd.updateContext = function(prevType) {
-  var out = this.context.pop();
-  if (out === tc.j_oTag && prevType === tt.slash || out === tc.j_cTag) {
-    this.context.pop();
-    this.exprAllowed = this.curContext() === tc.j_expr;
-  } else {
-    this.exprAllowed = true;
-  }
-};
-
-var pp = acorn.Parser.prototype;
-
-// Reads inline JSX contents token.
-
-pp.jsx_readToken = function() {
-  var out = "", chunkStart = this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length)
-      this.raise(this.start, "Unterminated JSX contents");
-    var ch = this.input.charCodeAt(this.pos);
-
-    switch (ch) {
-    case 60: // '<'
-    case 123: // '{'
-      if (this.pos === this.start) {
-        if (ch === 60 && this.exprAllowed) {
-          ++this.pos;
-          return this.finishToken(tt.jsxTagStart);
-        }
-        return this.getTokenFromCode(ch);
-      }
-      out += this.input.slice(chunkStart, this.pos);
-      return this.finishToken(tt.jsxText, out);
-
-    case 38: // '&'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.jsx_readEntity();
-      chunkStart = this.pos;
-      break;
-
-    default:
-      if (acorn.isNewLine(ch)) {
-        out += this.input.slice(chunkStart, this.pos);
-        ++this.pos;
-        if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
-          ++this.pos;
-          out += "\n";
-        } else {
-          out += String.fromCharCode(ch);
-        }
-        if (this.options.locations) {
-          ++this.curLine;
-          this.lineStart = this.pos;
-        }
-        chunkStart = this.pos;
-      } else {
-        ++this.pos;
-      }
-    }
-  }
-};
-
-pp.jsx_readString = function(quote) {
-  var out = "", chunkStart = ++this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length)
-      this.raise(this.start, "Unterminated string constant");
-    var ch = this.input.charCodeAt(this.pos);
-    if (ch === quote) break;
-    if (ch === 38) { // '&'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.jsx_readEntity();
-      chunkStart = this.pos;
-    } else {
-      ++this.pos;
-    }
-  }
-  out += this.input.slice(chunkStart, this.pos++);
-  return this.finishToken(tt.string, out);
-};
-
-var XHTMLEntities = {
-  quot: '\u0022',
-  amp: '&',
-  apos: '\u0027',
-  lt: '<',
-  gt: '>',
-  nbsp: '\u00A0',
-  iexcl: '\u00A1',
-  cent: '\u00A2',
-  pound: '\u00A3',
-  curren: '\u00A4',
-  yen: '\u00A5',
-  brvbar: '\u00A6',
-  sect: '\u00A7',
-  uml: '\u00A8',
-  copy: '\u00A9',
-  ordf: '\u00AA',
-  laquo: '\u00AB',
-  not: '\u00AC',
-  shy: '\u00AD',
-  reg: '\u00AE',
-  macr: '\u00AF',
-  deg: '\u00B0',
-  plusmn: '\u00B1',
-  sup2: '\u00B2',
-  sup3: '\u00B3',
-  acute: '\u00B4',
-  micro: '\u00B5',
-  para: '\u00B6',
-  middot: '\u00B7',
-  cedil: '\u00B8',
-  sup1: '\u00B9',
-  ordm: '\u00BA',
-  raquo: '\u00BB',
-  frac14: '\u00BC',
-  frac12: '\u00BD',
-  frac34: '\u00BE',
-  iquest: '\u00BF',
-  Agrave: '\u00C0',
-  Aacute: '\u00C1',
-  Acirc: '\u00C2',
-  Atilde: '\u00C3',
-  Auml: '\u00C4',
-  Aring: '\u00C5',
-  AElig: '\u00C6',
-  Ccedil: '\u00C7',
-  Egrave: '\u00C8',
-  Eacute: '\u00C9',
-  Ecirc: '\u00CA',
-  Euml: '\u00CB',
-  Igrave: '\u00CC',
-  Iacute: '\u00CD',
-  Icirc: '\u00CE',
-  Iuml: '\u00CF',
-  ETH: '\u00D0',
-  Ntilde: '\u00D1',
-  Ograve: '\u00D2',
-  Oacute: '\u00D3',
-  Ocirc: '\u00D4',
-  Otilde: '\u00D5',
-  Ouml: '\u00D6',
-  times: '\u00D7',
-  Oslash: '\u00D8',
-  Ugrave: '\u00D9',
-  Uacute: '\u00DA',
-  Ucirc: '\u00DB',
-  Uuml: '\u00DC',
-  Yacute: '\u00DD',
-  THORN: '\u00DE',
-  szlig: '\u00DF',
-  agrave: '\u00E0',
-  aacute: '\u00E1',
-  acirc: '\u00E2',
-  atilde: '\u00E3',
-  auml: '\u00E4',
-  aring: '\u00E5',
-  aelig: '\u00E6',
-  ccedil: '\u00E7',
-  egrave: '\u00E8',
-  eacute: '\u00E9',
-  ecirc: '\u00EA',
-  euml: '\u00EB',
-  igrave: '\u00EC',
-  iacute: '\u00ED',
-  icirc: '\u00EE',
-  iuml: '\u00EF',
-  eth: '\u00F0',
-  ntilde: '\u00F1',
-  ograve: '\u00F2',
-  oacute: '\u00F3',
-  ocirc: '\u00F4',
-  otilde: '\u00F5',
-  ouml: '\u00F6',
-  divide: '\u00F7',
-  oslash: '\u00F8',
-  ugrave: '\u00F9',
-  uacute: '\u00FA',
-  ucirc: '\u00FB',
-  uuml: '\u00FC',
-  yacute: '\u00FD',
-  thorn: '\u00FE',
-  yuml: '\u00FF',
-  OElig: '\u0152',
-  oelig: '\u0153',
-  Scaron: '\u0160',
-  scaron: '\u0161',
-  Yuml: '\u0178',
-  fnof: '\u0192',
-  circ: '\u02C6',
-  tilde: '\u02DC',
-  Alpha: '\u0391',
-  Beta: '\u0392',
-  Gamma: '\u0393',
-  Delta: '\u0394',
-  Epsilon: '\u0395',
-  Zeta: '\u0396',
-  Eta: '\u0397',
-  Theta: '\u0398',
-  Iota: '\u0399',
-  Kappa: '\u039A',
-  Lambda: '\u039B',
-  Mu: '\u039C',
-  Nu: '\u039D',
-  Xi: '\u039E',
-  Omicron: '\u039F',
-  Pi: '\u03A0',
-  Rho: '\u03A1',
-  Sigma: '\u03A3',
-  Tau: '\u03A4',
-  Upsilon: '\u03A5',
-  Phi: '\u03A6',
-  Chi: '\u03A7',
-  Psi: '\u03A8',
-  Omega: '\u03A9',
-  alpha: '\u03B1',
-  beta: '\u03B2',
-  gamma: '\u03B3',
-  delta: '\u03B4',
-  epsilon: '\u03B5',
-  zeta: '\u03B6',
-  eta: '\u03B7',
-  theta: '\u03B8',
-  iota: '\u03B9',
-  kappa: '\u03BA',
-  lambda: '\u03BB',
-  mu: '\u03BC',
-  nu: '\u03BD',
-  xi: '\u03BE',
-  omicron: '\u03BF',
-  pi: '\u03C0',
-  rho: '\u03C1',
-  sigmaf: '\u03C2',
-  sigma: '\u03C3',
-  tau: '\u03C4',
-  upsilon: '\u03C5',
-  phi: '\u03C6',
-  chi: '\u03C7',
-  psi: '\u03C8',
-  omega: '\u03C9',
-  thetasym: '\u03D1',
-  upsih: '\u03D2',
-  piv: '\u03D6',
-  ensp: '\u2002',
-  emsp: '\u2003',
-  thinsp: '\u2009',
-  zwnj: '\u200C',
-  zwj: '\u200D',
-  lrm: '\u200E',
-  rlm: '\u200F',
-  ndash: '\u2013',
-  mdash: '\u2014',
-  lsquo: '\u2018',
-  rsquo: '\u2019',
-  sbquo: '\u201A',
-  ldquo: '\u201C',
-  rdquo: '\u201D',
-  bdquo: '\u201E',
-  dagger: '\u2020',
-  Dagger: '\u2021',
-  bull: '\u2022',
-  hellip: '\u2026',
-  permil: '\u2030',
-  prime: '\u2032',
-  Prime: '\u2033',
-  lsaquo: '\u2039',
-  rsaquo: '\u203A',
-  oline: '\u203E',
-  frasl: '\u2044',
-  euro: '\u20AC',
-  image: '\u2111',
-  weierp: '\u2118',
-  real: '\u211C',
-  trade: '\u2122',
-  alefsym: '\u2135',
-  larr: '\u2190',
-  uarr: '\u2191',
-  rarr: '\u2192',
-  darr: '\u2193',
-  harr: '\u2194',
-  crarr: '\u21B5',
-  lArr: '\u21D0',
-  uArr: '\u21D1',
-  rArr: '\u21D2',
-  dArr: '\u21D3',
-  hArr: '\u21D4',
-  forall: '\u2200',
-  part: '\u2202',
-  exist: '\u2203',
-  empty: '\u2205',
-  nabla: '\u2207',
-  isin: '\u2208',
-  notin: '\u2209',
-  ni: '\u220B',
-  prod: '\u220F',
-  sum: '\u2211',
-  minus: '\u2212',
-  lowast: '\u2217',
-  radic: '\u221A',
-  prop: '\u221D',
-  infin: '\u221E',
-  ang: '\u2220',
-  and: '\u2227',
-  or: '\u2228',
-  cap: '\u2229',
-  cup: '\u222A',
-  'int': '\u222B',
-  there4: '\u2234',
-  sim: '\u223C',
-  cong: '\u2245',
-  asymp: '\u2248',
-  ne: '\u2260',
-  equiv: '\u2261',
-  le: '\u2264',
-  ge: '\u2265',
-  sub: '\u2282',
-  sup: '\u2283',
-  nsub: '\u2284',
-  sube: '\u2286',
-  supe: '\u2287',
-  oplus: '\u2295',
-  otimes: '\u2297',
-  perp: '\u22A5',
-  sdot: '\u22C5',
-  lceil: '\u2308',
-  rceil: '\u2309',
-  lfloor: '\u230A',
-  rfloor: '\u230B',
-  lang: '\u2329',
-  rang: '\u232A',
-  loz: '\u25CA',
-  spades: '\u2660',
-  clubs: '\u2663',
-  hearts: '\u2665',
-  diams: '\u2666'
-};
-
-var hexNumber = /^[\da-fA-F]+$/;
-var decimalNumber = /^\d+$/;
-
-pp.jsx_readEntity = function() {
-  var str = "", count = 0, entity;
-  var ch = this.input[this.pos];
-  if (ch !== "&")
-    this.raise(this.pos, "Entity must start with an ampersand");
-  var startPos = ++this.pos;
-  while (this.pos < this.input.length && count++ < 10) {
-    ch = this.input[this.pos++];
-    if (ch === ";") {
-      if (str[0] === "#") {
-        if (str[1] === "x") {
-          str = str.substr(2);
-          if (hexNumber.test(str))
-            entity = String.fromCharCode(parseInt(str, 16));
-        } else {
-          str = str.substr(1);
-          if (decimalNumber.test(str))
-            entity = String.fromCharCode(parseInt(str, 10));
-        }
-      } else {
-        entity = XHTMLEntities[str];
-      }
-      break;
-    }
-    str += ch;
-  }
-  if (!entity) {
-    this.pos = startPos;
-    return "&";
-  }
-  return entity;
-};
-
-
-// Read a JSX identifier (valid tag or attribute name).
-//
-// Optimized version since JSX identifiers can't contain
-// escape characters and so can be read as single slice.
-// Also assumes that first character was already checked
-// by isIdentifierStart in readToken.
-
-pp.jsx_readWord = function() {
-  var ch, start = this.pos;
-  do {
-    ch = this.input.charCodeAt(++this.pos);
-  } while (acorn.isIdentifierChar(ch) || ch === 45); // '-'
-  return this.finishToken(tt.jsxName, this.input.slice(start, this.pos));
-};
-
-// Transforms JSX element name to string.
-
-function getQualifiedJSXName(object) {
-  if (object.type === "JSXIdentifier")
-    return object.name;
-
-  if (object.type === "JSXNamespacedName")
-    return object.namespace.name + ':' + object.name.name;
-
-  if (object.type === "JSXMemberExpression")
-    return getQualifiedJSXName(object.object) + '.' +
-    getQualifiedJSXName(object.property);
-}
-
-// Parse next token as JSX identifier
-
-pp.jsx_parseIdentifier = function() {
-  var node = this.startNode();
-  if (this.type === tt.jsxName)
-    node.name = this.value;
-  else if (this.type.keyword)
-    node.name = this.type.keyword;
-  else
-    this.unexpected();
-  this.next();
-  return this.finishNode(node, "JSXIdentifier");
-};
-
-// Parse namespaced identifier.
-
-pp.jsx_parseNamespacedName = function() {
-  var start = this.markPosition();
-  var name = this.jsx_parseIdentifier();
-  if (!this.eat(tt.colon)) return name;
-  var node = this.startNodeAt(start);
-  node.namespace = name;
-  node.name = this.jsx_parseIdentifier();
-  return this.finishNode(node, "JSXNamespacedName");
-};
-
-// Parses element name in any form - namespaced, member
-// or single identifier.
-
-pp.jsx_parseElementName = function() {
-  var start = this.markPosition();
-  var node = this.jsx_parseNamespacedName();
-  while (this.eat(tt.dot)) {
-    var newNode = this.startNodeAt(start);
-    newNode.object = node;
-    newNode.property = this.jsx_parseIdentifier();
-    node = this.finishNode(newNode, "JSXMemberExpression");
-  }
-  return node;
-};
-
-// Parses any type of JSX attribute value.
-
-pp.jsx_parseAttributeValue = function() {
-  switch (this.type) {
-  case tt.braceL:
-    var node = this.jsx_parseExpressionContainer();
-    if (node.expression.type === "JSXEmptyExpression")
-      this.raise(node.start, "JSX attributes must only be assigned a non-empty expression");
-    return node;
-
-  case tt.jsxTagStart:
-  case tt.string:
-    return this.parseExprAtom();
-
-  default:
-    this.raise(this.start, "JSX value should be either an expression or a quoted JSX text");
-  }
-};
-
-// JSXEmptyExpression is unique type since it doesn't actually parse anything,
-// and so it should start at the end of last read token (left brace) and finish
-// at the beginning of the next one (right brace).
-
-pp.jsx_parseEmptyExpression = function() {
-  var tmp = this.start;
-  this.start = this.lastTokEnd;
-  this.lastTokEnd = tmp;
-
-  tmp = this.startLoc;
-  this.startLoc = this.lastTokEndLoc;
-  this.lastTokEndLoc = tmp;
-
-  return this.finishNode(this.startNode(), "JSXEmptyExpression");
-};
-
-// Parses JSX expression enclosed into curly brackets.
-
-
-pp.jsx_parseExpressionContainer = function() {
-  var node = this.startNode();
-  this.next();
-  node.expression = this.type === tt.braceR
-    ? this.jsx_parseEmptyExpression()
-    : this.parseExpression();
-  this.expect(tt.braceR);
-  return this.finishNode(node, "JSXExpressionContainer");
-};
-
-// Parses following JSX attribute name-value pair.
-
-pp.jsx_parseAttribute = function() {
-  var node = this.startNode();
-  if (this.eat(tt.braceL)) {
-    this.expect(tt.ellipsis);
-    node.argument = this.parseMaybeAssign();
-    this.expect(tt.braceR);
-    return this.finishNode(node, "JSXSpreadAttribute");
-  }
-  node.name = this.jsx_parseNamespacedName();
-  node.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;
-  return this.finishNode(node, "JSXAttribute");
-};
-
-// Parses JSX opening tag starting after '<'.
-
-pp.jsx_parseOpeningElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  node.attributes = [];
-  node.name = this.jsx_parseElementName();
-  while (this.type !== tt.slash && this.type !== tt.jsxTagEnd)
-    node.attributes.push(this.jsx_parseAttribute());
-  node.selfClosing = this.eat(tt.slash);
-  this.expect(tt.jsxTagEnd);
-  return this.finishNode(node, "JSXOpeningElement");
-};
-
-// Parses JSX closing tag starting after '</'.
-
-pp.jsx_parseClosingElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  node.name = this.jsx_parseElementName();
-  this.expect(tt.jsxTagEnd);
-  return this.finishNode(node, "JSXClosingElement");
-};
-
-// Parses entire JSX element, including it's opening tag
-// (starting after '<'), attributes, contents and closing tag.
-
-pp.jsx_parseElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  var children = [];
-  var openingElement = this.jsx_parseOpeningElementAt(start);
-  var closingElement = null;
-
-  if (!openingElement.selfClosing) {
-    contents: for (;;) {
-      switch (this.type) {
-      case tt.jsxTagStart:
-        start = this.markPosition();
-        this.next();
-        if (this.eat(tt.slash)) {
-          closingElement = this.jsx_parseClosingElementAt(start);
-          break contents;
-        }
-        children.push(this.jsx_parseElementAt(start));
-        break;
-
-      case tt.jsxText:
-        children.push(this.parseExprAtom());
-        break;
-
-      case tt.braceL:
-        children.push(this.jsx_parseExpressionContainer());
-        break;
-
-      default:
-        this.unexpected();
-      }
-    }
-    if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name))
-      this.raise(
-        closingElement.start,
-        "Expected corresponding JSX closing tag for <" + getQualifiedJSXName(openingElement.name) + ">");
-  }
-
-  node.openingElement = openingElement;
-  node.closingElement = closingElement;
-  node.children = children;
-  return this.finishNode(node, "JSXElement");
-};
-
-// Parses entire JSX element from current position.
-
-pp.jsx_parseElement = function() {
-  var start = this.markPosition();
-  this.next();
-  return this.jsx_parseElementAt(start);
-};
-
-acorn.plugins.jsx = function(instance) {
-  instance.extend("parseExprAtom", function(inner) {
-    return function(refShortHandDefaultPos) {
-      if (this.type === tt.jsxText)
-        return this.parseLiteral(this.value);
-      else if (this.type === tt.jsxTagStart)
-        return this.jsx_parseElement();
-      else
-        return inner.call(this, refShortHandDefaultPos);
-    };
-  });
-
-  instance.extend("readToken", function(inner) {
-    return function(code) {
-      var context = this.curContext();
-
-      if (context === tc.j_expr) return this.jsx_readToken();
-
-      if (context === tc.j_oTag || context === tc.j_cTag) {
-        if (acorn.isIdentifierStart(code)) return this.jsx_readWord();
-
-        if (code == 62) {
-          ++this.pos;
-          return this.finishToken(tt.jsxTagEnd);
-        }
-
-        if ((code === 34 || code === 39) && context == tc.j_oTag)
-          return this.jsx_readString(code);
-      }
-
-      if (code === 60 && this.exprAllowed) {
-        ++this.pos;
-        return this.finishToken(tt.jsxTagStart);
-      }
-      return inner.call(this, code);
-    };
-  });
-
-  instance.extend("updateContext", function(inner) {
-    return function(prevType) {
-      if (this.type == tt.braceL) {
-        var curContext = this.curContext();
-        if (curContext == tc.j_oTag) this.context.push(tc.b_expr);
-        else if (curContext == tc.j_expr) this.context.push(tc.b_tmpl);
-        else inner.call(this, prevType);
-        this.exprAllowed = true;
-      } else if (this.type === tt.slash && prevType === tt.jsxTagStart) {
-        this.context.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore
-        this.context.push(tc.j_cTag); // reconsider as closing tag context
-        this.exprAllowed = false;
-      } else {
-        return inner.call(this, prevType);
-      }
-    };
-  });
-}

src/acorn/src/expression.js

@@ -103,8 +103,16 @@ pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos, afterLeftParse) {
     node.left = this.type === tt.eq ? this.toAssignable(left) : left
     refShorthandDefaultPos.start = 0 // reset because shorthand default was used correctly
     this.checkLVal(left)
-    if (left.parenthesizedExpression && left.type === "ObjectPattern") {
-      this.raise(left.start, "You're trying to assign to a parenthesized expression, instead of `({ foo }) = {}` use `({ foo } = {})`");
+    if (left.parenthesizedExpression) {
+      let errorMsg
+      if (left.type === "ObjectPattern") {
+        errorMsg = "`({a}) = 0` use `({a} = 0)`"
+      } else if (left.type === "ArrayPattern") {
+        errorMsg = "`([a]) = 0` use `([a] = 0)`"
+      }
+      if (errorMsg) {
+        this.raise(left.start, `You're trying to assign to a parenthesized expression, eg. instead of ${errorMsg}`)
+      }
     }
     this.next()
     node.right = this.parseMaybeAssign(noIn)
@@ -466,7 +474,10 @@ pp.parseNew = function() {
   }
   let start = this.markPosition()
   node.callee = this.parseSubscripts(this.parseExprAtom(), start, true)
-  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false)
+  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(
+    tt.parenR,
+    this.options.features["es7.trailingFunctionCommas"]
+  )
   else node.arguments = empty
   return this.finishNode(node, "NewExpression")
 }
@@ -624,7 +635,7 @@ pp.parseMethod = function(isGenerator, isAsync) {
   let node = this.startNode()
   this.initFunction(node, isAsync)
   this.expect(tt.parenL)
-  node.params = this.parseBindingList(tt.parenR, false, false)
+  node.params = this.parseBindingList(tt.parenR, false, this.options.features["es7.trailingFunctionCommas"])
   if (this.options.ecmaVersion >= 6) {
     node.generator = isGenerator
   }

src/acorn/src/identifier.js

@@ -9,41 +9,9 @@
 
 function makePredicate(words) {
   words = words.split(" ")
-  let f = "", cats = []
-  out: for (let i = 0; i < words.length; ++i) {
-    for (let j = 0; j < cats.length; ++j)
-      if (cats[j][0].length == words[i].length) {
-        cats[j].push(words[i])
-        continue out
-      }
-    cats.push([words[i]])
+  return function(str) {
+    return words.indexOf(str) >= 0
   }
-  function compareTo(arr) {
-    if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";"
-    f += "switch(str){"
-    for (let i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":"
-    f += "return true}return false;"
-  }
-
-  // When there are more than three length categories, an outer
-  // switch first dispatches on the lengths, to save on comparisons.
-
-  if (cats.length > 3) {
-    cats.sort((a, b) => b.length - a.length)
-    f += "switch(str.length){"
-    for (let i = 0; i < cats.length; ++i) {
-      let cat = cats[i]
-      f += "case " + cat[0].length + ":"
-      compareTo(cat)
-    }
-    f += "}"
-
-    // Otherwise, simply generate a flat `switch` statement.
-
-  } else {
-    compareTo(words)
-  }
-  return new Function("str", f)
 }
 
 // Reserved word lists for various dialects of the language

src/acorn/src/index.js

@@ -38,9 +38,6 @@ export {isIdentifierChar, isIdentifierStart} from "./identifier"
 export {Token} from "./tokenize"
 export {isNewLine, lineBreak, lineBreakG} from "./whitespace"
 
-import "../plugins/flow";
-import "../plugins/jsx";
-
 export const version = "1.0.0"
 
 // The main exported interface (under `self.acorn` when in the

src/acorn/src/lookahead.js

@@ -14,7 +14,11 @@ var STATE_KEYS = [
   "pos",
   "end",
   "type",
-  "value"
+  "value",
+  "exprAllowed",
+  "potentialArrowAt",
+  "currLine",
+  "input"
 ];
 
 pp.getState = function () {
@@ -23,6 +27,7 @@ pp.getState = function () {
     var key = STATE_KEYS[i]
     state[key] = this[key]
   }
+  state.context = this.context.slice()
   return state
 };
 

src/acorn/src/lval.js

@@ -21,6 +21,7 @@ pp.toAssignable = function(node, isBinding) {
       node.type = "ObjectPattern"
       for (let i = 0; i < node.properties.length; i++) {
         let prop = node.properties[i]
+        if (prop.type === "SpreadProperty") continue;
         if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter")
         this.toAssignable(prop.value, isBinding)
       }

src/acorn/src/statement.js

@@ -504,7 +504,7 @@ pp.parseClass = function(node, isStatement) {
       this.parsePropertyName(method)
     }
     method.kind = "method"
-    if (!method.computed && !isGenerator) {
+    if (!method.computed && !isGenerator && !isAsync) {
       if (method.key.type === "Identifier") {
         if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
           method.kind = method.key.name

src/acorn/src/tokenize.js

@@ -283,7 +283,7 @@ pp.readToken_lt_gt = function(code) { // '<>'
   }
   if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
       this.input.charCodeAt(this.pos + 3) == 45) {
-    if (this.inModule) unexpected()
+    if (this.inModule) this.unexpected()
     // `<!--`, an XML-style comment that should be interpreted as a line comment
     this.skipLineComment(4)
     this.skipSpace()

src/acorn/src/tokentype.js

@@ -116,7 +116,7 @@ kw("do", {isLoop: true})
 kw("else", beforeExpr)
 kw("finally")
 kw("for", {isLoop: true})
-kw("function")
+kw("function", startsExpr)
 kw("if")
 kw("return", beforeExpr)
 kw("switch")

src/babel/api/browser.js

@@ -1,3 +1,4 @@
+require("./node");
 var transform = module.exports = require("../transformation");
 
 transform.options = require("../transformation/file/options");
@@ -11,7 +12,7 @@ transform.run = function (code, opts = {}) {
 };
 
 transform.load = function (url, callback, opts = {}, hold) {
-  opts.filename ||= url;
+  opts.filename = opts.filename || url;
 
   var xhr = global.ActiveXObject ? new global.ActiveXObject("Microsoft.XMLHTTP") : new global.XMLHttpRequest();
   xhr.open("GET", url, true);

src/babel/api/node.js

@@ -5,10 +5,12 @@ import * as util from "../util";
 import fs from "fs";
 
 export { util, acorn, transform };
+export { pipeline } from "../transformation";
 export { canCompile } from "../util";
 
 export { default as options } from "../transformation/file/options";
 export { default as Transformer } from "../transformation/transformer";
+export { default as TransformerPipeline } from "../transformation/transformer-pipeline";
 export { default as traverse } from "../traversal";
 export { default as buildExternalHelpers } from "../tools/build-external-helpers";
 export { version } from "../../../package";
@@ -17,7 +19,7 @@ import * as t from "../types";
 export { t as types };
 
 export function register(opts?: Object) {
-  var callback = require("./register/node");
+  var callback = require("./register/node-polyfill");
   if (opts != null) callback(opts);
   return callback;
 }
@@ -51,10 +53,11 @@ export function transformFile(filename: string, opts?: Object, callback: Functio
 
 export function transformFileSync(filename: string, opts?: Object = {}) {
   opts.filename = filename;
-  return transform(fs.readFileSync(filename), opts);
+  return transform(fs.readFileSync(filename, "utf8"), opts);
 }
 
 export function parse(code, opts = {}) {
+  opts.allowHashBang = true;
   opts.sourceType = "module";
   opts.ecmaVersion = Infinity;
   opts.plugins = {
@@ -63,7 +66,7 @@ export function parse(code, opts = {}) {
   };
   opts.features = {};
 
-  for (var key in transform.transformers) {
+  for (var key in transform.pipeline.transformers) {
     opts.features[key] = true;
   }
 

src/babel/api/register/node-polyfill.js

@@ -0,0 +1,2 @@
+import "../../polyfill";
+export { default } from "./node";

src/babel/api/register/node.js

@@ -1,4 +1,3 @@
-import "../../polyfill";
 import sourceMapSupport from "source-map-support";
 import * as registerCache from "./cache";
 import resolveRc from "../../tools/resolve-rc";
@@ -7,6 +6,7 @@ import * as babel from "../node";
 import each from "lodash/collection/each";
 import * as util from  "../../util";
 import fs from "fs";
+import slash from "slash";
 
 sourceMapSupport.install({
   handleUncaughtExceptions: false,
@@ -31,8 +31,10 @@ var cache = registerCache.get();
 //
 
 var transformOpts = {};
-var ignoreRegex   = /node_modules/;
-var onlyRegex;
+
+var ignore;
+var only;
+
 var oldHandlers   = {};
 var maps          = {};
 
@@ -76,12 +78,16 @@ var compile = function (filename) {
 };
 
 var shouldIgnore = function (filename) {
-  return (ignoreRegex && ignoreRegex.test(filename)) || (onlyRegex && !onlyRegex.test(filename));
+  if (!ignore && !only) {
+    return /node_modules/.test(filename);
+  } else {
+    return util.shouldIgnore(filename, ignore || [], only || []);
+  }
 };
 
 var istanbulMonkey = {};
 
-if (process.env.running_under_istanbul) { // jshint ignore:line
+if (process.env.running_under_istanbul) {
   // we need to monkey patch fs.readFileSync so we can hook into
   // what istanbul gets, it's extremely dirty but it's the only way
   var _readFileSync = fs.readFileSync;
@@ -111,7 +117,7 @@ var registerExtension = function (ext) {
   var old = oldHandlers[ext] || oldHandlers[".js"];
 
   var loader = normalLoader;
-  if (process.env.running_under_istanbul) loader = istanbulLoader; // jshint ignore:line
+  if (process.env.running_under_istanbul) loader = istanbulLoader;
 
   require.extensions[ext] = function (m, filename) {
     if (shouldIgnore(filename)) {
@@ -142,8 +148,8 @@ var hookExtensions = function (_exts) {
 hookExtensions(util.canCompile.EXTENSIONS);
 
 export default function (opts = {}) {
-  if (opts.only != null) onlyRegex = util.regexify(opts.only);
-  if (opts.ignore != null) ignoreRegex = util.regexify(opts.ignore);
+  if (opts.only != null) only = util.arrayify(opts.only, util.regexify);
+  if (opts.ignore != null) ignore = util.arrayify(opts.ignore, util.regexify);
 
   if (opts.extensions) hookExtensions(util.arrayify(opts.extensions));
 
@@ -156,16 +162,3 @@ export default function (opts = {}) {
 
   extend(transformOpts, opts);
 };
-
-//
-
-try {
-  var runtimePackage = require("babel-runtime/package");
-  var version = require("../../../../package").version;
-  if (runtimePackage.version !== version) {
-    throw new ReferenceError(`The verison of babel-runtime of ${runtimePackage.runtime} that you have installed does not match the babel verison of ${version}`);
-  }
-} catch (err) {
-  if (err.code !== "MODULE_NOT_FOUND") throw err;
-}
-

src/babel/generation/buffer.js

@@ -70,14 +70,14 @@ export default class Buffer {
   }
 
   newline(i, removeLast) {
-    if (this.format.compact) return;
+    if (this.format.compact || this.format.retainLines) return;
 
     if (this.format.concise) {
       this.space();
       return;
     }
 
-    removeLast ||= false;
+    removeLast = removeLast || false;
 
     if (isNumber(i)) {
       i = Math.min(2, i);

src/babel/generation/generators/base.js

@@ -13,7 +13,7 @@ export function BlockStatement(node, print) {
     this.push("{");
     this.newline();
     print.sequence(node.body, { indent: true });
-    this.removeLast("\n");
+    if (!this.format.retainLines) this.removeLast("\n");
     this.rightBrace();
   }
 }

src/babel/generation/generators/jsx.js

@@ -43,13 +43,13 @@ export function JSXElement(node, print) {
   if (open.selfClosing) return;
 
   this.indent();
-  each(node.children, (child) => {
+  for (var child of (node.children: Array)) {
     if (t.isLiteral(child)) {
-      this.push(child.value);
+      this.push(child.value, true);
     } else {
       print(child);
     }
-  });
+  }
   this.dedent();
 
   print(node.closingElement);

src/babel/generation/generators/modules.js

@@ -3,7 +3,7 @@ import * as t from "../../types";
 
 export function ImportSpecifier(node, print) {
   print(node.imported);
-  if (node.local && node.local !== node.imported) {
+  if (node.local && node.local.name !== node.imported.name) {
     this.push(" as ");
     print(node.local);
   }
@@ -19,7 +19,7 @@ export function ExportDefaultSpecifier(node, print) {
 
 export function ExportSpecifier(node, print) {
   print(node.local);
-  if (node.exported && node.local !== node.exported) {
+  if (node.exported && node.local.name !== node.exported.name) {
     this.push(" as ");
     print(node.exported);
   }

src/babel/generation/generators/statements.js

@@ -71,7 +71,7 @@ export var ForInStatement = buildForXStatement("in");
 export var ForOfStatement = buildForXStatement("of");
 
 export function DoWhileStatement(node, print) {
-  this.keyword("do");
+  this.push("do ");
   print(node.body);
   this.space();
   this.keyword("while");
@@ -182,8 +182,8 @@ export function VariableDeclaration(node, print, parent) {
   var hasInits = false;
   // don't add whitespace to loop heads
   if (!t.isFor(parent)) {
-    for (var i = 0; i < node.declarations.length; i++) {
-      if (node.declarations[i].init) {
+    for (var declar of (node.declarations: Array)) {
+      if (declar.init) {
         // has an init so let's split it up over multiple lines
         hasInits = true;
       }
@@ -191,7 +191,7 @@ export function VariableDeclaration(node, print, parent) {
   }
 
   var sep = ",";
-  if (!this.format.compact && hasInits) {
+  if (!this.format.compact && !this.format.concise && hasInits && !this.format.retainLines) {
     sep += `\n${repeating(" ", node.kind.length + 1)}`;
   } else {
     sep += " ";

src/babel/generation/generators/template-literals.js

@@ -15,15 +15,15 @@ export function TemplateLiteral(node, print) {
   var quasis = node.quasis;
   var len    = quasis.length;
 
-  each(quasis, (quasi, i) => {
-    print(quasi);
+  for (var i = 0; i < len; i++) {
+    print(quasis[i]);
 
     if (i + 1 < len) {
       this.push("${ ");
       print(node.expressions[i]);
       this.push(" }");
     }
-  });
+  }
 
   this._push("`");
 }

src/babel/generation/generators/types.js

@@ -1,4 +1,5 @@
 import each from "lodash/collection/each";
+import * as t from "../../types";
 
 export function Identifier(node) {
   this.push(node.name);
@@ -39,7 +40,14 @@ export function Property(node, print) {
       this.push("]");
     } else {
       print(node.key);
-      if (node.shorthand) return;
+
+      // shorthand!
+      if (node.shorthand &&
+        (t.isIdentifier(node.key) &&
+         t.isIdentifier(node.value) &&
+         node.key.name === node.value.name)) {
+        return;
+      }
     }
 
     this.push(":");
@@ -54,7 +62,8 @@ export function ArrayExpression(node, print) {
 
   this.push("[");
 
-  each(elems, (elem, i) => {
+  for (var i = 0; i < elems.length; i++) {
+    var elem = elems[i];
     if (!elem) {
       // If the array expression ends with a hole, that hole
       // will be ignored by the interpreter, but if it ends with
@@ -67,7 +76,7 @@ export function ArrayExpression(node, print) {
       print(elem);
       if (i < len - 1) this.push(",");
     }
-  });
+  }
 
   this.push("]");
 }

src/babel/generation/index.js

@@ -12,7 +12,7 @@ import * as t from "../types";
 
 class CodeGenerator {
   constructor(ast, opts, code) {
-    opts ||= {};
+    opts = opts || {};
 
     this.comments = ast.comments || [];
     this.tokens   = ast.tokens || [];
@@ -34,9 +34,10 @@ class CodeGenerator {
     }
 
     var format = {
+      retainLines: opts.retainLines,
       comments: opts.comments == null || opts.comments,
       compact: opts.compact,
-      quotes: CodeGenerator.findCommonStringDelimeter(code, tokens),
+      quotes: CodeGenerator.findCommonStringDelimiter(code, tokens),
       indent: {
         adjustMultilineComment: true,
         style: style,
@@ -48,14 +49,14 @@ class CodeGenerator {
       format.compact = code.length > 100000; // 100KB
 
       if (format.compact) {
-        console.error(messages.get("codeGeneratorDeopt", opts.filename, "100KB"));
+        console.error("[BABEL] " + messages.get("codeGeneratorDeopt", opts.filename, "100KB"));
       }
     }
 
     return format;
   }
 
-  static findCommonStringDelimeter(code, tokens) {
+  static findCommonStringDelimiter(code, tokens) {
     var occurences = {
       single: 0,
       double: 0
@@ -104,11 +105,13 @@ class CodeGenerator {
 
     this.print(ast);
 
-    var comments = [];
-    each(ast.comments, function (comment) {
-      if (!comment._displayed) comments.push(comment);
-    });
-    this._printComments(comments);
+    if (ast.comments) {
+      var comments = [];
+      for (var comment of (ast.comments: Array)) {
+        if (!comment._displayed) comments.push(comment);
+      }
+      this._printComments(comments);
+    }
 
     return {
       map:  this.map.get(),
@@ -146,6 +149,22 @@ class CodeGenerator {
     return print;
   }
 
+  catchUp(node, parent) {
+    // catch up to this nodes newline if we're behind
+    if (node.loc && this.format.retainLines && this.buffer.buf) {
+      var needsParens = false;
+      if (parent && this.position.line < node.loc.start.line && t.isTerminatorless(parent)) {
+        needsParens = true;
+        this._push("(");
+      }
+      while (this.position.line < node.loc.start.line) {
+        this._push("\n");
+      }
+      return needsParens;
+    }
+    return false;
+  }
+
   print(node, parent, opts = {}) {
     if (!node) return;
 
@@ -197,6 +216,8 @@ class CodeGenerator {
 
       this.printLeadingComments(node, parent);
 
+      var needsParensFromCatchup = this.catchUp(node, parent);
+
       newline(true);
 
       if (opts.before) opts.before();
@@ -208,19 +229,19 @@ class CodeGenerator {
         this.newline();
         this.dedent();
       }
-      if (needsParens) this.push(")");
+      if (needsParens || needsParensFromCatchup) this.push(")");
 
       this.map.mark(node, "end");
       if (opts.after) opts.after();
 
+      this.format.concise = oldConcise;
+
       newline(false);
 
       this.printTrailingComments(node, parent);
     } else {
       throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node && node.constructor.name)}`);
     }
-
-    this.format.concise = oldConcise;
   }
 
   printJoin(print, nodes, opts = {}) {
@@ -230,7 +251,8 @@ class CodeGenerator {
 
     if (opts.indent) this.indent();
 
-    each(nodes, (node, i) => {
+    for (var i = 0; i < nodes.length; i++) {
+      var node = nodes[i];
       print(node, {
         statement: opts.statement,
         addNewlines: opts.addNewlines,
@@ -244,7 +266,7 @@ class CodeGenerator {
           }
         }
       });
-    });
+    }
 
     if (opts.indent) this.dedent();
   }
@@ -295,9 +317,9 @@ class CodeGenerator {
       nodes.push(node.argument);
     }
 
-    each(nodes, (node) => {
+    for (var node of (nodes: Array)) {
       comments = comments.concat(this._getComments(key, node));
-    });
+    }
 
     return comments;
   }
@@ -312,22 +334,26 @@ class CodeGenerator {
     if (!this.format.comments) return;
     if (!comments || !comments.length) return;
 
-    each(comments, (comment) => {
+    for (var comment of (comments: Array)) {
       var skip = false;
 
-      // find the original comment in the ast and set it as displayed
-      each(this.ast.comments, function (origComment) {
-        if (origComment.start === comment.start) {
-          // comment has already been output
-          if (origComment._displayed) skip = true;
+      if (this.ast.comments) {
+        // find the original comment in the ast and set it as displayed
+        for (var origComment of (this.ast.comments: Array)) {
+          if (origComment.start === comment.start) {
+            // comment has already been output
+            if (origComment._displayed) skip = true;
 
-          origComment._displayed = true;
-          return false;
+            origComment._displayed = true;
+            break;
+          }
         }
-      });
+      }
 
       if (skip) return;
 
+      this.catchUp(comment);
+
       // whitespace before
       this.newline(this.whitespace.getNewlinesBefore(comment));
 
@@ -340,7 +366,6 @@ class CodeGenerator {
       }
 
       //
-
       if (comment.type === "Block" && this.format.indent.adjustMultilineComment) {
         var offset = comment.loc.start.column;
         if (offset) {
@@ -356,13 +381,18 @@ class CodeGenerator {
         val = this.getIndent() + val;
       }
 
-      //
+      // force a newline for line comments when retainLines is set in case the next printed node
+      // doesn't catch up
+      if (this.format.retainLines && comment.type === "Line") {
+        val += "\n";
+      }
 
+      //
       this._push(val);
 
       // whitespace after
       this.newline(this.whitespace.getNewlinesAfter(comment));
-    });
+    }
   }
 }
 

src/babel/generation/node/index.js

@@ -85,16 +85,7 @@ export default class Node {
       return false;
     }
 
-    if (t.isYieldExpression(parent) || t.isAwaitExpression(parent)) {
-      return true;
-    }
-
-    if (t.isContinueStatement(parent) || t.isBreakStatement(parent) ||
-        t.isReturnStatement(parent) || t.isThrowStatement(parent)) {
-      return true;
-    }
-
-    return false;
+    return t.isTerminatorless(parent);
   }
 }
 

src/babel/generation/node/parentheses.js

@@ -171,4 +171,10 @@ export function ConditionalExpression(node, parent) {
   return false;
 }
 
-export { ConditionalExpression as AssignmentExpression };
+export function AssignmentExpression(node) {
+  if (t.isObjectPattern(node.left)) {
+    return true;
+  } else {
+    return ConditionalExpression(...arguments);
+  }
+}

src/babel/generation/node/whitespace.js

@@ -16,7 +16,7 @@ function crawl(node, state = {}) {
   } else if (t.isFunction(node)) {
     state.hasFunction = true;
   } else if (t.isIdentifier(node)) {
-    state.hasHelper ||= isHelper(node.callee);
+    state.hasHelper = state.hasHelper || isHelper(node.callee);
   }
 
   return state;

src/babel/helpers/parse.js

@@ -1,65 +1,34 @@
 import normalizeAst from "./normalize-ast";
 import estraverse from "estraverse";
-import codeFrame from "./code-frame";
 import * as acorn from "../../acorn";
 
-export default function (opts, code, callback) {
-  try {
-    var comments = [];
-    var tokens   = [];
+export default function (code, opts = {}) {
+  var comments = [];
+  var tokens   = [];
 
-    var parseOpts = {
-      allowImportExportEverywhere: opts.looseModules,
-      allowReturnOutsideFunction:  opts.looseModules,
-      ecmaVersion:                 6,
-      strictMode:                  opts.strictMode,
-      sourceType:                  opts.sourceType,
-      onComment:                   comments,
-      locations:                   true,
-      features:                    opts.features || {},
-      plugins:                     opts.plugins || {},
-      onToken:                     tokens,
-      ranges:                      true
-    };
+  var parseOpts = {
+    allowImportExportEverywhere: opts.looseModules,
+    allowReturnOutsideFunction:  opts.looseModules,
+    allowHashBang:               true,
+    ecmaVersion:                 6,
+    strictMode:                  opts.strictMode,
+    sourceType:                  opts.sourceType,
+    locations:                   true,
+    onComment:                   comments,
+    features:                    opts.features || {},
+    plugins:                     opts.plugins || {},
+    onToken:                     tokens,
+    ranges:                      true
+  };
 
-    if (opts.nonStandard) {
-      parseOpts.plugins.jsx = true;
-      parseOpts.plugins.flow = true;
-    }
-
-    var ast = acorn.parse(code, parseOpts);
-
-    estraverse.attachComments(ast, comments, tokens);
-
-    ast = normalizeAst(ast, comments, tokens);
-
-    if (callback) {
-      return callback(ast);
-    } else {
-      return ast;
-    }
-  } catch (err) {
-    if (!err._babel) {
-      err._babel = true;
-
-      var message = err.message = `${opts.filename}: ${err.message}`;
-
-      var loc = err.loc;
-      if (loc) {
-        err.codeFrame = codeFrame(code, loc.line, loc.column + 1, opts);
-        message += "\n" + err.codeFrame;
-      }
-
-      if (err.stack) {
-        var newStack = err.stack.replace(err.message, message);
-        try {
-          err.stack = newStack;
-        } catch (e) {
-          // `err.stack` may be a readonly property in some environments
-        }
-      }
-    }
-
-    throw err;
+  if (opts.nonStandard) {
+    parseOpts.plugins.jsx = true;
+    parseOpts.plugins.flow = true;
   }
-};
+
+  var ast = acorn.parse(code, parseOpts);
+
+  estraverse.attachComments(ast, comments, tokens);
+  ast = normalizeAst(ast, comments, tokens);
+  return ast;
+}

src/babel/messages.js

@@ -18,11 +18,23 @@ export const MESSAGES = {
   modulesIllegalExportName: "Illegal export $1",
   unknownForHead: "Unknown node type $1 in ForStatement",
   didYouMean: "Did you mean $1?",
-  evalInStrictMode: "eval is not allowed in strict mode",
   codeGeneratorDeopt: "Note: The code generator has deoptimised the styling of $1 as it exceeds the max of $2.",
   missingTemplatesDirectory: "no templates directory - this is most likely the result of a broken `npm publish`. Please report to https://github.com/babel/babel/issues",
   unsupportedOutputType: "Unsupported output type $1",
-  illegalMethodName: "Illegal method name $1"
+  illegalMethodName: "Illegal method name $1",
+
+  traverseNeedsParent: "Must pass a scope and parentPath unless traversing a Program/File got a $1 node",
+  traverseVerifyRootFunction: "You passed `traverse()` a function when it expected a visitor object, are you sure you didn't mean `{ enter: Function }`?",
+  traverseVerifyVisitorProperty: "You passed `traverse()` a visitor object with the property $1 that has the invalid property $2",
+  traverseVerifyNodeType: "You gave us a visitor for the node type $1 but it's not a valid type",
+
+  pluginIllegalKind: "Illegal kind $1 for plugin $2",
+  pluginIllegalPosition: "Illegal position $1 for plugin $2",
+  pluginKeyCollision: "The plugin $1 collides with another of the same name",
+  pluginNotTransformer: "The plugin $1 didn't export a Transformer instance",
+  pluginUnknown: "Unknown plugin $1",
+
+  transformerNotFile: "Transformer $1 is resolving to a different Babel version to what is doing the actual transformation..."
 };
 
 export function get(key: String, ...args) {

src/babel/patch.js

@@ -33,6 +33,9 @@ def("DoExpression")
   .build("body")
   .field("body", [def("Statement")]);
 
+def("Super")
+  .bases("Expression");
+
 def("ExportDefaultDeclaration")
   .bases("Declaration")
   .build("declaration")
@@ -55,4 +58,18 @@ def("ExportNamedDeclaration")
   )])
   .field("source", or(def("ModuleSpecifier"), null));
 
+def("ExportNamespaceSpecifier")
+  .bases("Specifier")
+  .field("exported", def("Identifier"));
+
+def("ExportDefaultSpecifier")
+  .bases("Specifier")
+  .field("exported", def("Identifier"));
+
+def("ExportAllDeclaration")
+  .bases("Declaration")
+  .build("exported", "source")
+  .field("exported", def("Identifier"))
+  .field("source", def("Literal"));
+
 types.finalize();

src/babel/tools/resolve-rc.js

@@ -17,24 +17,40 @@ function exists(filename) {
 export default function (loc, opts = {}) {
   var rel = ".babelrc";
 
+  if (!opts.babelrc) {
+    opts.babelrc = [];
+  }
+
   function find(start, rel) {
     var file = path.join(start, rel);
 
+    if (opts.babelrc.indexOf(file) >= 0) {
+      return;
+    }
+
     if (exists(file)) {
       var content = fs.readFileSync(file, "utf8");
       var json;
 
       try {
-        json = jsons[content] ||= JSON.parse(stripJsonComments(content));
+        json = jsons[content] = jsons[content] || JSON.parse(stripJsonComments(content));
       } catch (err) {
         err.message = `${file}: ${err.message}`;
         throw err;
       }
 
+      opts.babelrc.push(file);
+
       if (json.breakConfig) return;
       merge(opts, json, function(a, b) {
         if (Array.isArray(a)) {
-          return a.concat(b);
+          var c = a.slice(0);
+          for (var v of b) {
+            if (a.indexOf(v) < 0) {
+              c.push(v);
+            }
+          }
+          return c;
         }
       });
     }
@@ -45,7 +61,7 @@ export default function (loc, opts = {}) {
     }
   }
 
-  if (opts.breakConfig !== true) {
+  if (opts.babelrc.indexOf(loc) < 0 && opts.breakConfig !== true) {
     find(loc, rel);
   }
 

src/babel/transformation/file/index.js

@@ -1,13 +1,17 @@
 import convertSourceMap from "convert-source-map";
 import * as optionParsers from "./option-parsers";
+import moduleFormatters from "../modules";
+import PluginManager from "./plugin-manager";
 import shebangRegex from "shebang-regex";
 import TraversalPath from "../../traversal/path";
+import Transformer from "../transformer";
 import isFunction from "lodash/lang/isFunction";
 import isAbsolute from "path-is-absolute";
 import resolveRc from "../../tools/resolve-rc";
 import sourceMap from "source-map";
 import transform from "./../index";
 import generate from "../../generation";
+import codeFrame from "../../helpers/code-frame";
 import defaults from "lodash/object/defaults";
 import includes from "lodash/collection/includes";
 import traverse from "../../traversal";
@@ -16,39 +20,29 @@ import Logger from "./logger";
 import parse from "../../helpers/parse";
 import Scope from "../../traversal/scope";
 import slash from "slash";
+import clone from "lodash/lang/clone";
 import * as util from  "../../util";
+import * as api from  "../../api/node";
 import path from "path";
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
-var checkTransformerVisitor = {
-  enter(node, parent, scope, state) {
-    checkNode(state.stack, node, scope);
-  }
-};
-
-function checkNode(stack, node, scope) {
-  each(stack, function (pass) {
-    if (pass.shouldRun || pass.ran) return;
-    pass.checkNode(node, scope);
-  });
-}
-
 export default class File {
-  constructor(opts = {}) {
-    this.dynamicImportAbsoluteDefaults = [];
-    this.dynamicImportIds              = {};
-    this.dynamicImports                = [];
+  constructor(opts = {}, pipeline) {
+    this.transformerDependencies = {};
 
-    this.usedHelpers = {};
-    this.dynamicData = {};
-    this.data        = {};
-    this.uids        = {};
+    this.dynamicImportTypes = {};
+    this.dynamicImportIds   = {};
+    this.dynamicImports     = [];
 
-    this.lastStatements = [];
-    this.log            = new Logger(this, opts.filename || "unknown");
-    this.opts           = this.normalizeOptions(opts);
-    this.ast            = {};
+    this.declarations = {};
+    this.usedHelpers  = {};
+    this.dynamicData  = {};
+    this.data         = {};
+
+    this.pipeline = pipeline;
+    this.log      = new Logger(this, opts.filename || "unknown");
+    this.opts     = this.normalizeOptions(opts);
+    this.ast      = {};
 
     this.buildTransformers();
   }
@@ -59,9 +53,9 @@ export default class File {
     "create-class",
     "create-decorated-class",
     "create-decorated-object",
+    "define-decorated-property-descriptor",
     "tagged-template-literal",
     "tagged-template-literal-loose",
-    "interop-require",
     "to-array",
     "to-consumable-array",
     "sliced-to-array",
@@ -73,6 +67,7 @@ export default class File {
     "define-property",
     "async-to-generator",
     "interop-require-wildcard",
+    "interop-require-default",
     "typeof",
     "extends",
     "get",
@@ -82,7 +77,11 @@ export default class File {
     "temporal-undefined",
     "temporal-assert-defined",
     "self-global",
-    "default-props"
+    "default-props",
+    "instanceof",
+
+    // legacy
+    "interop-require",
   ];
 
   static soloHelpers = [];
@@ -117,13 +116,15 @@ export default class File {
         throw new Error("Deprecated option " + key + ": " + option.deprecated);
       }
 
-      if (val == null) val = option.default || val;
+      if (val == null) {
+        val = clone(option.default);
+      }
 
       var optionParser = optionParsers[option.type];
-      if (optionParser) val = optionParser(key, val);
+      if (optionParser) val = optionParser(key, val, this.pipeline);
 
       if (option.alias) {
-        opts[option.alias] ||= val;
+        opts[option.alias] = opts[option.alias] || val;
       } else {
         opts[key] = val;
       }
@@ -187,7 +188,8 @@ export default class File {
     var stack = [];
 
     // build internal transformers
-    each(transform.transformers, function (transformer, key) {
+    for (var key in this.pipeline.transformers) {
+      var transformer = this.pipeline.transformers[key];
       var pass = transformers[key] = transformer.buildPass(file);
 
       if (pass.canTransform()) {
@@ -201,111 +203,71 @@ export default class File {
           transformer.manipulateOptions(file.opts, file);
         }
       }
-    });
+    }
 
     // init plugins!
     var beforePlugins = [];
     var afterPlugins = [];
+    var pluginManager = new PluginManager({
+      file: this,
+      transformers: this.transformers,
+      before: beforePlugins,
+      after: afterPlugins
+    });
     for (var i = 0; i < file.opts.plugins.length; i++) {
-      this.addPlugin(file.opts.plugins[i], beforePlugins, afterPlugins);
+      pluginManager.add(file.opts.plugins[i]);
     }
     stack = beforePlugins.concat(stack, afterPlugins);
 
-    // register
-    this.transformerStack = stack.concat(secondaryStack);
-  }
+    // build transformer stack
+    this.uncollapsedTransformerStack = stack = stack.concat(secondaryStack);
 
-  getModuleFormatter(type: string) {
-    var ModuleFormatter = isFunction(type) ? type : transform.moduleFormatters[type];
-
-    if (!ModuleFormatter) {
-      var loc = util.resolveRelative(type);
-      if (loc) ModuleFormatter = require(loc);
+    // build dependency graph
+    for (var pass of (stack: Array)) {
+      for (var dep of (pass.transformer.dependencies: Array)) {
+        this.transformerDependencies[dep] = pass.key;
+      }
     }
 
-    if (!ModuleFormatter) {
-      throw new ReferenceError(`Unknown module formatter type ${JSON.stringify(type)}`);
-    }
-
-    return new ModuleFormatter(this);
+    // collapse stack categories
+    this.transformerStack = this.collapseStack(stack);
   }
 
-  addPlugin(name, before, after) {
-    var position = "before";
-    var plugin;
+  collapseStack(_stack) {
+    var stack  = [];
+    var ignore = [];
 
-    if (name) {
-      if (typeof name === "string") {
-        // this is a plugin in the form of "foobar" or "foobar:after"
-        // where the optional colon is the delimiter for plugin position in the transformer stack
+    for (let pass of (_stack: Array)) {
+      // been merged
+      if (ignore.indexOf(pass) >= 0) continue;
 
-        [name, position = "before"] = name.split(":");
+      var group = pass.transformer.metadata.group;
 
-        var loc = util.resolveRelative(name) || util.resolveRelative(`babel-plugin-${name}`);
-        if (loc) {
-          plugin = require(loc)
-        } else {
-          throw new ReferenceError(`Unknown plugin ${JSON.stringify(name)}`);
+      // can't merge
+      if (!pass.canTransform() || !group) {
+        stack.push(pass);
+        continue;
+      }
+
+      var mergeStack = [];
+      for (let pass of (_stack: Array)) {
+        if (pass.transformer.metadata.group === group) {
+          mergeStack.push(pass);
+          ignore.push(pass);
         }
-      } else {
-        // not a string so we'll just assume that it's a direct Transformer instance, if not then
-        // the checks later on will complain
-        plugin = name;
       }
-    } else {
-      throw new TypeError(`Ilegal kind ${typeof name} for plugin name ${JSON.stringify(name)}`);
-    }
 
-    // validate position
-    if (position !== "before" && position !== "after") {
-      throw new TypeError(`Plugin ${JSON.stringify(name)} has an illegal position of ${JSON.stringify(position)}`);
-    }
-
-    // validate transformer key
-    var key = plugin.key;
-    if (this.transformers[key]) {
-      throw new ReferenceError(`The key for plugin ${JSON.stringify(name)} of ${key} collides with an existing plugin`);
-    }
-
-    // validate Transformer instance
-    if (!plugin.buildPass || plugin.constructor.name !== "Transformer") {
-      throw new TypeError(`Plugin ${JSON.stringify(name)} didn't export a default Transformer instance`);
-    }
-
-    // build!
-    var pass = this.transformers[key] = plugin.buildPass(this);
-    if (pass.canTransform()) {
-      var stack = before;
-      if (position === "after") stack = after;
-      stack.push(pass);
-    }
-  }
-
-  parseInputSourceMap(code: string) {
-    var opts = this.opts;
-
-    if (opts.inputSourceMap !== false) {
-      var inputMap = convertSourceMap.fromSource(code);
-      if (inputMap) {
-        opts.inputSourceMap = inputMap.toObject();
-        code = convertSourceMap.removeComments(code);
+      var visitors = [];
+      for (let pass of (mergeStack: Array)) {
+        visitors.push(pass.handlers);
       }
+      var visitor = traverse.visitors.merge(visitors);
+      var mergeTransformer = new Transformer(group, visitor);
+      //console.log(mergeTransformer);
+      stack.push(mergeTransformer.buildPass(this));
     }
 
-    return code;
-  }
-
-  parseShebang(code: string) {
-    var shebangMatch = shebangRegex.exec(code);
-
-    if (shebangMatch) {
-      this.shebang = shebangMatch[0];
-
-      // remove shebang
-      code = code.replace(shebangRegex, "");
-    }
-
-    return code;
+    return stack;
   }
 
   set(key: string, val): any {
@@ -334,8 +296,8 @@ export default class File {
     return source;
   }
 
-  addImport(source: string, name?: string, absoluteDefault?: boolean): Object {
-    name ||= source;
+  addImport(source: string, name?: string, type?: string): Object {
+    name = name || source;
     var id = this.dynamicImportIds[name];
 
     if (!id) {
@@ -345,7 +307,11 @@ export default class File {
       var specifiers = [t.importDefaultSpecifier(id)];
       var declar = t.importDeclaration(specifiers, t.literal(source));
       declar._blockHoist = 3;
-      if (absoluteDefault) this.dynamicImportAbsoluteDefaults.push(declar);
+
+      if (type) {
+        var modules = this.dynamicImportTypes[type] = this.dynamicImportTypes[type] || [];
+        modules.push(declar);
+      }
 
       if (this.transformers["es6.modules"].canTransform()) {
         this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
@@ -358,14 +324,10 @@ export default class File {
     return id;
   }
 
-  isConsequenceExpressionStatement(node: Object): boolean {
-    return t.isExpressionStatement(node) && this.lastStatements.indexOf(node) >= 0;
-  }
-
   attachAuxiliaryComment(node: Object): Object {
     var comment = this.opts.auxiliaryComment;
     if (comment) {
-      node.leadingComments ||= [];
+      node.leadingComments = node.leadingComments || [];
       node.leadingComments.push({
         type: "Line",
         value: " " + comment
@@ -383,8 +345,8 @@ export default class File {
 
     var program = this.ast.program;
 
-    var declar = program._declarations && program._declarations[name];
-    if (declar) return declar.id;
+    var declar = this.declarations[name];
+    if (declar) return declar;
 
     this.usedHelpers[name] = true;
 
@@ -400,13 +362,25 @@ export default class File {
     }
 
     var ref = util.template("helper-" + name);
-    ref._compact = true;
-    var uid = this.scope.generateUidIdentifier(name);
-    this.scope.push({
-      key: name,
-      id: uid,
-      init: ref
-    });
+
+    var uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
+
+    if (t.isFunctionExpression(ref) && !ref.id) {
+      ref.body._compact = true;
+      ref._generated = true;
+      ref.id = uid;
+      ref.type = "FunctionDeclaration";
+      this.attachAuxiliaryComment(ref);
+      this.path.unshiftContainer("body", ref);
+    } else {
+      ref._compact = true;
+      this.scope.push({
+        id: uid,
+        init: ref,
+        unique: true
+      });
+    }
+
     return uid;
   }
 
@@ -417,125 +391,6 @@ export default class File {
     return err;
   }
 
-  addCode(code: string) {
-    code = (code || "") + "";
-    code = this.parseInputSourceMap(code);
-    this.code = code;
-    return this.parseShebang(code);
-  }
-
-  shouldIgnore() {
-    var opts = this.opts;
-    return util.shouldIgnore(opts.filename, opts.ignore, opts.only);
-  }
-
-  parse(code: string) {
-    if (this.shouldIgnore()) {
-      return {
-        metadata: {},
-        code:     code,
-        map:      null,
-        ast:      null
-      };
-    }
-
-    code = this.addCode(code);
-
-    var opts = this.opts;
-
-    //
-
-    var parseOpts = {
-      highlightCode: opts.highlightCode,
-      nonStandard:   opts.nonStandard,
-      filename:      opts.filename,
-      plugins:       {}
-    };
-
-    var features = parseOpts.features = {};
-    for (var key in this.transformers) {
-      var transformer = this.transformers[key];
-      features[key] = transformer.canTransform();
-    }
-
-    parseOpts.looseModules = this.isLoose("es6.modules");
-    parseOpts.strictMode = features.strict;
-    parseOpts.sourceType = "module";
-
-    //
-
-    return parse(parseOpts, code, (tree) => {
-      this.transform(tree);
-      return this.generate();
-    });
-  }
-
-  setAst(ast) {
-    this.path  = TraversalPath.get(null, null, ast, ast, "program", this);
-    this.scope = this.path.scope;
-    this.ast   = ast;
-
-    this.path.traverse({
-      enter(node, parent, scope) {
-        if (this.isScope()) {
-          for (var key in scope.bindings) {
-            scope.bindings[key].setTypeAnnotation();
-          }
-        }
-      }
-    });
-  }
-
-  transform(ast) {
-    this.log.debug();
-
-    this.setAst(ast);
-
-    this.lastStatements = t.getLastStatements(ast.program);
-
-    var modFormatter = this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
-    if (modFormatter.init && this.transformers["es6.modules"].canTransform()) {
-      modFormatter.init();
-    }
-
-    this.checkNode(ast);
-
-    this.call("pre");
-
-    each(this.transformerStack, function (pass) {
-      pass.transform();
-    });
-
-    this.call("post");
-  }
-
-  call(key: string) {
-    var stack = this.transformerStack;
-    for (var i = 0; i < stack.length; i++) {
-      var transformer = stack[i].transformer;
-      var fn = transformer[key];
-      if (fn) fn(this);
-    }
-  }
-
-  checkNode(node, scope) {
-    if (Array.isArray(node)) {
-      for (var i = 0; i < node.length; i++) {
-        this.checkNode(node[i], scope);
-      }
-      return;
-    }
-
-    var stack = this.transformerStack;
-    scope ||= this.scope;
-
-    checkNode(stack, node, scope);
-
-    scope.traverse(node, checkTransformerVisitor, {
-      stack: stack
-    });
-  }
-
   mergeSourceMap(map: Object) {
     var opts = this.opts;
 
@@ -558,6 +413,174 @@ export default class File {
     return map;
   }
 
+
+  getModuleFormatter(type: string) {
+    var ModuleFormatter = isFunction(type) ? type : moduleFormatters[type];
+
+    if (!ModuleFormatter) {
+      var loc = util.resolveRelative(type);
+      if (loc) ModuleFormatter = require(loc);
+    }
+
+    if (!ModuleFormatter) {
+      throw new ReferenceError(`Unknown module formatter type ${JSON.stringify(type)}`);
+    }
+
+    return new ModuleFormatter(this);
+  }
+
+  parse(code: string) {
+    var opts = this.opts;
+
+    //
+
+    var parseOpts = {
+      highlightCode: opts.highlightCode,
+      nonStandard:   opts.nonStandard,
+      filename:      opts.filename,
+      plugins:       {}
+    };
+
+    var features = parseOpts.features = {};
+    for (var key in this.transformers) {
+      var transformer = this.transformers[key];
+      features[key] = transformer.canTransform();
+    }
+
+    parseOpts.looseModules = this.isLoose("es6.modules");
+    parseOpts.strictMode = features.strict;
+    parseOpts.sourceType = "module";
+
+    this.log.debug("Parse start");
+    var tree = parse(code, parseOpts);
+    this.log.debug("Parse stop");
+    return tree;
+  }
+
+  _addAst(ast) {
+    this.path  = TraversalPath.get(null, null, ast, ast, "program", this);
+    this.scope = this.path.scope;
+    this.ast   = ast;
+
+    this.path.traverse({
+      enter(node, parent, scope) {
+        if (this.isScope()) {
+          for (var key in scope.bindings) {
+            scope.bindings[key].setTypeAnnotation();
+          }
+        }
+      }
+    });
+  }
+
+  addAst(ast) {
+    this.log.debug("Start set AST");
+    this._addAst(ast);
+    this.log.debug("End set AST");
+
+    this.log.debug("Start module formatter init");
+    var modFormatter = this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
+    if (modFormatter.init && this.transformers["es6.modules"].canTransform()) {
+      modFormatter.init();
+    }
+    this.log.debug("End module formatter init");
+
+    this.call("pre");
+    for (var pass of (this.transformerStack: Array)) {
+      pass.transform();
+    }
+    this.call("post");
+  }
+
+  wrap(code, callback) {
+    code = code + "";
+
+    try {
+      if (this.shouldIgnore()) {
+        return {
+          metadata: {},
+          code:     code,
+          map:      null,
+          ast:      null
+        };
+      }
+
+      callback();
+
+      return this.generate();
+    } catch (err) {
+      if (err._babel) {
+        throw err;
+      } else {
+        err._babel = true;
+      }
+
+      var message = err.message = `${this.opts.filename}: ${err.message}`;
+
+      var loc = err.loc;
+      if (loc) {
+        err.codeFrame = codeFrame(code, loc.line, loc.column + 1, this.opts);
+        message += "\n" + err.codeFrame;
+      }
+
+      if (err.stack) {
+        var newStack = err.stack.replace(err.message, message);
+        try {
+          err.stack = newStack;
+        } catch (e) {
+          // `err.stack` may be a readonly property in some environments
+        }
+      }
+
+      throw err;
+    }
+  }
+
+  addCode(code: string, parseCode?) {
+    code = (code || "") + "";
+    code = this.parseInputSourceMap(code);
+    this.code = code;
+
+    if (parseCode) {
+      this.parseShebang();
+      this.addAst(this.parse(this.code));
+    }
+  }
+
+  shouldIgnore() {
+    var opts = this.opts;
+    return util.shouldIgnore(opts.filename, opts.ignore, opts.only);
+  }
+
+  call(key: string) {
+    for (var pass of (this.uncollapsedTransformerStack: Array)) {
+      var fn = pass.transformer[key];
+      if (fn) fn(this);
+    }
+  }
+
+  parseInputSourceMap(code: string) {
+    var opts = this.opts;
+
+    if (opts.inputSourceMap !== false) {
+      var inputMap = convertSourceMap.fromSource(code);
+      if (inputMap) {
+        opts.inputSourceMap = inputMap.toObject();
+        code = convertSourceMap.removeComments(code);
+      }
+    }
+
+    return code;
+  }
+
+  parseShebang() {
+    var shebangMatch = shebangRegex.exec(this.code);
+    if (shebangMatch) {
+      this.shebang = shebangMatch[0];
+      this.code = this.code.replace(shebangRegex, "");
+    }
+  }
+
   generate(): {
     usedHelpers?: Array<string>;
     code: string;
@@ -581,10 +604,14 @@ export default class File {
     if (opts.ast) result.ast = ast;
     if (!opts.code) return result;
 
+    this.log.debug("Generation start");
+
     var _result = generate(ast, opts, this.code);
     result.code = _result.code;
     result.map  = _result.map;
 
+    this.log.debug("Generation end");
+
     if (this.shebang) {
       // add back shebang
       result.code = `${this.shebang}\n${result.code}`;

src/babel/transformation/file/logger.js

@@ -1,4 +1,7 @@
-import * as util from  "../../util";
+import buildDebug from "debug/node";
+
+var verboseDebug = buildDebug("babel:verbose");
+var generalDebug = buildDebug("babel");
 
 export default class Logger {
   constructor(file: File, filename: string) {
@@ -7,7 +10,7 @@ export default class Logger {
   }
 
   _buildMessage(msg: string): string {
-    var parts = this.filename;
+    var parts = `[BABEL] ${this.filename}`;
     if (msg) parts += `: ${msg}`;
     return parts;
   }
@@ -18,15 +21,19 @@ export default class Logger {
 
   deprecate(msg) {
     if (!this.file.opts.suppressDeprecationMessages) {
-      console.error(msg);
+      console.error(this._buildMessage(msg));
     }
   }
 
+  verbose(msg: string) {
+    if (verboseDebug.enabled) verboseDebug(this._buildMessage(msg));
+  }
+
   debug(msg: string) {
-    util.debug(this._buildMessage(msg));
+    if (generalDebug.enabled) generalDebug(this._buildMessage(msg));
   }
 
   deopt(node: Object, msg: string) {
-    util.debug(this._buildMessage(msg));
+    this.debug(msg);
   }
 }

src/babel/transformation/file/option-parsers.js

@@ -1,14 +1,13 @@
-import transform from "./../index";
 import * as util from  "../../util";
 
-export function transformerList(key, val) {
+export function transformerList(key, val, pipeline) {
   val = util.arrayify(val);
 
   if (val.indexOf("all") >= 0 || val.indexOf(true) >= 0) {
-    val = Object.keys(transform.transformers);
+    val = Object.keys(pipeline.transformers);
   }
 
-  return transform._ensureTransformerNames(key, val);
+  return pipeline._ensureTransformerNames(key, val);
 }
 
 export function number(key, val) {

src/babel/transformation/file/options.json

@@ -15,11 +15,26 @@
     "hidden": true
   },
 
+  "extra": {
+    "hidden": true,
+    "default": {}
+  },
+
   "moduleId": {
     "description": "specify a custom name for module ids",
     "type": "string"
   },
 
+  "getModuleId": {
+    "hidden": true
+  },
+
+  "retainLines": {
+    "type": "boolean",
+    "default": false,
+    "description": "retain line numbers - will result in really ugly code"
+  },
+
   "nonStandard": {
     "type": "boolean",
     "default": true,
@@ -152,7 +167,7 @@
   },
 
   "externalHelpers": {
-    "type": "string",
+    "type": "boolean",
     "default": false,
     "shorthand": "r",
     "description": "uses a reference to `babelHelpers` instead of placing helpers at the top of your code."
@@ -201,6 +216,10 @@
     "default": false,
     "hidden": true,
     "description": "stop trying to load .babelrc files"
-  }
+  },
 
+  "babelrc": {
+    "hidden": true,
+    "description": "do not load the same .babelrc file twice"
+  }
 }

src/babel/transformation/file/plugin-manager.js

@@ -0,0 +1,108 @@
+import * as node from  "../../api/node";
+import * as messages from "../../messages";
+import * as util from  "../../util";
+
+export default class PluginManager {
+  static memoisedPlugins = [];
+
+  static memoisePluginContainer(fn) {
+    for (var i = 0; i < PluginManager.memoisedPlugins.length; i++) {
+      var plugin = PluginManager.memoisedPlugins[i];
+      if (plugin.container === fn) return plugin.transformer;
+    }
+
+    var transformer = fn(node);
+    PluginManager.memoisedPlugins.push({
+      container: fn,
+      transformer: transformer
+    });
+    return transformer;
+  }
+
+  static positions = ["before", "after"];
+
+  constructor({ file, transformers, before, after } = { transformers: {}, before: [], after: [] }) {
+    this.transformers = transformers;
+    this.file         = file;
+    this.before       = before;
+    this.after        = after;
+  }
+
+  subnormaliseString(name, position) {
+    // this is a plugin in the form of "foobar" or "foobar:after"
+    // where the optional colon is the delimiter for plugin position in the transformer stack
+
+    var match = name.match(/^(.*?):(after|before)$/);
+    if (match) [, name, position] = match;
+
+    var loc = util.resolveRelative(name) || util.resolveRelative(`babel-plugin-${name}`);
+    if (loc) {
+      return {
+        position: position,
+        plugin:   require(loc)
+      };
+    } else {
+      throw new ReferenceError(messages.get("pluginUnknown", name));
+    }
+  }
+
+  validate(name, plugin) {
+    // validate transformer key
+    var key = plugin.key;
+    if (this.transformers[key]) {
+      throw new ReferenceError(messages.get("pluginKeyCollision", key));
+    }
+
+    // validate Transformer instance
+    if (!plugin.buildPass || plugin.constructor.name !== "Transformer") {
+      throw new TypeError(messages.get("pluginNotTransformer", name));
+    }
+
+    // register as a plugin
+    plugin.metadata.plugin = true;
+  }
+
+  add(name) {
+    var position;
+    var plugin;
+
+    if (name) {
+      if (typeof name === "object" && name.transformer) {
+        ({ transformer: plugin, position } = name);
+      } else if (typeof name !== "string") {
+        // not a string so we'll just assume that it's a direct Transformer instance, if not then
+        // the checks later on will complain
+        plugin = name;
+      }
+
+      if (typeof name === "string") {
+        ({ plugin, position } = this.subnormaliseString(name, position));
+      }
+    } else {
+      throw new TypeError(messages.get("pluginIllegalKind", typeof name, name));
+    }
+
+    // default position
+    position = position || "before";
+
+    // validate position
+    if (PluginManager.positions.indexOf(position) < 0) {
+      throw new TypeError(messages.get("pluginIllegalPosition", position, name));
+    }
+
+    // allow plugin containers to be specified so they don't have to manually require
+    if (typeof plugin === "function") {
+      plugin = PluginManager.memoisePluginContainer(plugin);
+    }
+
+    //
+    this.validate(name, plugin);
+
+    // build!
+    var pass = this.transformers[plugin.key] = plugin.buildPass(this.file);
+    if (pass.canTransform()) {
+      var stack = position === "before" ? this.before : this.after;
+      stack.push(pass);
+    }
+  }
+}

src/babel/transformation/helpers/build-binary-assignment-operator-transformer.js

@@ -1,7 +1,9 @@
 import explode from "./explode-assignable-expression";
 import * as t from "../../types";
 
-export default function (exports, opts) {
+export default function (opts) {
+  var exports = {};
+
   var isAssignment = function (node) {
     return node.operator === opts.operator + "=";
   };
@@ -12,7 +14,7 @@ export default function (exports, opts) {
 
   exports.ExpressionStatement = function (node, parent, scope, file) {
     // hit the `AssignmentExpression` one below
-    if (file.isConsequenceExpressionStatement(node)) return;
+    if (this.isCompletionRecord()) return;
 
     var expr = node.expression;
     if (!isAssignment(expr)) return;
@@ -40,4 +42,6 @@ export default function (exports, opts) {
     if (node.operator !== opts.operator) return;
     return opts.build(node.left, node.right);
   };
+
+  return exports;
 };

src/babel/transformation/helpers/build-conditional-assignment-operator-transformer.js

@@ -8,7 +8,7 @@ export default function (exports, opts) {
 
   exports.ExpressionStatement = function (node, parent, scope, file) {
     // hit the `AssignmentExpression` one below
-    if (file.isConsequenceExpressionStatement(node)) return;
+    if (this.isCompletionRecord()) return;
 
     var expr = node.expression;
     if (!opts.is(expr, file)) return;

src/babel/transformation/helpers/build-react-transformer.js

@@ -10,14 +10,8 @@ import * as react from "./react";
 import * as t from "../../types";
 
 export default function (exports, opts) {
-  exports.check = function (node) {
-    if (t.isJSX(node)) return true;
-    if (react.isCreateClass(node)) return true;
-    return false;
-  };
-
   exports.JSXIdentifier = function (node, parent) {
-    if (node.name === "this" && t.isReferenced(node, parent)) {
+    if (node.name === "this" && this.isReferenced()) {
       return t.thisExpression();
     } else if (esutils.keyword.isIdentifierNameES6(node.name)) {
       node.type = "Identifier";
@@ -57,6 +51,8 @@ export default function (exports, opts) {
 
   exports.JSXOpeningElement = {
     exit(node, parent, scope, file) {
+      parent.children = react.buildChildren(parent);
+
       var tagExpr = node.name;
       var args = [];
 
@@ -144,10 +140,6 @@ export default function (exports, opts) {
   };
 
   exports.JSXElement = {
-    enter(node) {
-      node.children = react.buildChildren(node);
-    },
-
     exit(node) {
       var callExpr = node.openingElement;
 

src/babel/transformation/helpers/define-map.js

@@ -15,7 +15,7 @@ export function push(mutatorMap, node, kind, file) {
 
   //
 
-  map._inherits ||= [];
+  map._inherits = map._inherits || [];
   map._inherits.push(node);
 
   map._key = node.key;
@@ -25,8 +25,8 @@ export function push(mutatorMap, node, kind, file) {
   }
 
   if (node.decorators) {
-    var decorators = map.decorators ||= t.arrayExpression([]);
-    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression));
+    var decorators = map.decorators = map.decorators || t.arrayExpression([]);
+    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression).reverse());
   }
 
   if (map.value || map.initializer) {

src/babel/transformation/helpers/memoise-decorators.js

@@ -0,0 +1,37 @@
+import * as t from "../../types";
+
+export default function (decorators, scope) {
+  for (var i = 0; i < decorators.length; i++) {
+    var decorator = decorators[i];
+    var expression = decorator.expression;
+    if (!t.isMemberExpression(expression)) continue;
+
+    var temp = scope.generateMemoisedReference(expression.object);
+    var ref;
+
+    var nodes = [];
+
+    if (temp) {
+      ref = temp;
+      nodes.push(t.assignmentExpression("=", temp, expression.object));
+    } else {
+      ref = expression.object;
+    }
+
+    nodes.push(t.callExpression(
+      t.memberExpression(
+        t.memberExpression(ref, expression.property, expression.computed),
+        t.identifier("bind")
+      ),
+      [ref]
+    ));
+
+    if (nodes.length === 1) {
+      decorator.expression = nodes[0];
+    } else {
+      decorator.expression = t.sequenceExpression(nodes);
+    }
+  }
+
+  return decorators;
+}

src/babel/transformation/helpers/name-method.js

@@ -20,27 +20,32 @@ var visitor = {
 
 var wrap = function (state, method, id, scope) {
   if (state.selfReference) {
-    var templateName = "property-method-assignment-wrapper";
-    if (method.generator) templateName += "-generator";
-    var template = util.template(templateName, {
-      FUNCTION: method,
-      FUNCTION_ID: id,
-      FUNCTION_KEY: scope.generateUidIdentifier(id.name)
-    });
-    template.callee._skipModulesRemap = true;
+    if (scope.hasBinding(id.name)) {
+      // we can just munge the local binding
+      scope.rename(id.name);
+    } else {
+      // need to add a wrapper since we can't change the references
+      var templateName = "property-method-assignment-wrapper";
+      if (method.generator) templateName += "-generator";
+      var template = util.template(templateName, {
+        FUNCTION: method,
+        FUNCTION_ID: id,
+        FUNCTION_KEY: scope.generateUidIdentifier(id.name)
+      });
+      template.callee._skipModulesRemap = true;
 
-    // shim in dummy params to retain function arity, if you try to read the
-    // source then you'll get the original since it's proxied so it's all good
-    var params = template.callee.body.body[0].params;
-    for (var i = 0, len = getFunctionArity(method); i < len; i++) {
-      params.push(scope.generateUidIdentifier("x"));
+      // shim in dummy params to retain function arity, if you try to read the
+      // source then you'll get the original since it's proxied so it's all good
+      var params = template.callee.body.body[0].params;
+      for (var i = 0, len = getFunctionArity(method); i < len; i++) {
+        params.push(scope.generateUidIdentifier("x"));
+      }
+
+      return template;
     }
-
-    return template;
-  } else {
-    method.id = id;
-    return method;
   }
+
+  method.id = id;
 };
 
 var visit = function (node, name, scope) {
@@ -82,7 +87,7 @@ var visit = function (node, name, scope) {
       // so we can safely just set the id and move along as it shadows the
       // bound function id
     }
-  } else {
+  } else if (state.outerDeclar || scope.hasGlobal(name)) {
     scope.traverse(node, visitor, state);
   }
 
@@ -96,7 +101,7 @@ export function custom(node, id, scope) {
 
 export function property(node, file, scope) {
   var key = t.toComputedKey(node, node.key);
-  if (!t.isLiteral(key)) return node; // we can't set a function id with this
+  if (!t.isLiteral(key)) return; // we can't set a function id with this
 
   var name = t.toIdentifier(key.value);
   if (name === "eval" || name === "arguments") name = "_" + name;
@@ -104,12 +109,12 @@ export function property(node, file, scope) {
 
   var method = node.value;
   var state  = visit(method, name, scope);
-  node.value = wrap(state, method, id, scope);
+  node.value = wrap(state, method, id, scope) || method;
 }
 
 export function bare(node, parent, scope) {
   // has an `id` so we don't need to infer one
-  if (node.id) return node;
+  if (node.id) return;
 
   var id;
   if (t.isProperty(parent) && parent.kind === "init" && (!parent.computed || t.isLiteral(parent.key))) {
@@ -118,8 +123,17 @@ export function bare(node, parent, scope) {
   } else if (t.isVariableDeclarator(parent)) {
     // var foo = function () {};
     id = parent.id;
+
+    if (t.isIdentifier(id)) {
+      var bindingInfo = scope.parent.getBinding(id.name);
+      if (bindingInfo && bindingInfo.constant && scope.getBinding(id.name) === bindingInfo) {
+        // always going to reference this method
+        node.id = id;
+        return;
+      }
+    }
   } else {
-    return node;
+    return;
   }
 
   var name;

src/babel/transformation/helpers/react.js

@@ -34,9 +34,8 @@ function cleanJSXElementLiteralChild(child, args) {
   var lines = child.value.split(/\r\n|\n|\r/);
 
   var lastNonEmptyLine = 0;
-  var i;
 
-  for (i = 0; i < lines.length; i++) {
+  for (let i = 0; i < lines.length; i++) {
     if (lines[i].match(/[^ \t]/)) {
       lastNonEmptyLine = i;
     }
@@ -44,7 +43,7 @@ function cleanJSXElementLiteralChild(child, args) {
 
   var str = "";
 
-  for (i = 0; i < lines.length; i++) {
+  for (let i = 0; i < lines.length; i++) {
     var line = lines[i];
 
     var isFirstLine = i === 0;

src/babel/transformation/helpers/remap-async-to-generator.js

@@ -19,8 +19,8 @@ var awaitVisitor = {
 var referenceVisitor = {
   enter(node, parent, scope, state) {
     var name = state.id.name;
-    if (t.isReferencedIdentifier(node, parent, { name: name }) && scope.bindingIdentifierEquals(name, state.id)) {
-      return state.ref ||= scope.generateUidIdentifier(name);
+    if (this.isReferencedIdentifier({ name: name }) && scope.bindingIdentifierEquals(name, state.id)) {
+      return state.ref = state.ref || scope.generateUidIdentifier(name);
     }
   }
 };

src/babel/transformation/helpers/replace-supers.js

@@ -218,7 +218,7 @@ export default class ReplaceSupers {
       return this.setSuperProperty(node.left.property, node.right, node.left.computed, getThisReference());
     } else {
       // super.age += 2; -> var _ref = super.age; super.age = _ref + 2;
-      ref ||= path.scope.generateUidIdentifier("ref");
+      ref = ref || path.scope.generateUidIdentifier("ref");
       return [
         t.variableDeclaration("var", [
           t.variableDeclarator(ref, node.left)

src/babel/transformation/index.js

@@ -1,68 +1,41 @@
-import normalizeAst from "../helpers/normalize-ast";
-import Transformer from "./transformer";
-import object from "../helpers/object";
-import File from "./file";
-import each from "lodash/collection/each";
+import Pipeline from "./transformer-pipeline";
 
-export default function transform(code: string, opts?: Object) {
-  var file = new File(opts);
-  return file.parse(code);
+var pipeline = new Pipeline;
+
+//
+
+import transformers from "./transformers";
+
+for (var key in transformers) {
+  var transformer = transformers[key];
+  var metadata = transformer.metadata = transformer.metadata || {};
+  metadata.group = metadata.group || "builtin-basic";
 }
 
-transform.fromAst = function (ast, code, opts) {
-  ast = normalizeAst(ast);
+pipeline.addTransformers(transformers);
 
-  var file = new File(opts);
-  file.addCode(code);
-  file.transform(ast);
-  return file.generate();
-};
+//
 
-transform._ensureTransformerNames = function (type: string, rawKeys: Array<string>) {
-  var keys = [];
+import deprecated from "./transformers/deprecated";
+pipeline.addDeprecated(deprecated);
 
-  for (var i = 0; i < rawKeys.length; i++) {
-    var key = rawKeys[i];
+//
 
-    var deprecatedKey = transform.deprecatedTransformerMap[key];
-    var aliasKey = transform.aliasTransformerMap[key];
-    if (aliasKey) {
-      keys.push(aliasKey);
-    } else if (deprecatedKey) {
-      // deprecated key, remap it to the new one
-      console.error(`The transformer ${key} has been renamed to ${deprecatedKey}`);
-      rawKeys.push(deprecatedKey);
-    } else if (transform.transformers[key]) {
-      // valid key
-      keys.push(key);
-    } else if (transform.namespaces[key]) {
-      // namespace, append all transformers within this namespace
-      keys = keys.concat(transform.namespaces[key]);
-    } else {
-      // invalid key
-      throw new ReferenceError(`Unknown transformer ${key} specified in ${type}`);
-    }
-  }
+import aliases from "./transformers/aliases";
+pipeline.addAliases(aliases);
 
-  return keys;
-};
+//
 
-transform.transformerNamespaces = object();
-transform.transformers          = object();
-transform.namespaces            = object();
+import * as filters from "./transformers/filters";
+pipeline.addFilter(filters.internal);
+pipeline.addFilter(filters.blacklist);
+pipeline.addFilter(filters.whitelist);
+pipeline.addFilter(filters.stage);
+pipeline.addFilter(filters.optional);
 
-transform.deprecatedTransformerMap = require("./transformers/deprecated");
-transform.aliasTransformerMap = require("./transformers/aliases");
-transform.moduleFormatters = require("./modules");
+//
 
-import rawTransformers from "./transformers";
-
-each(rawTransformers, function (transformer, key) {
-  var namespace = key.split(".")[0];
-
-  transform.namespaces[namespace] ||= [];
-  transform.namespaces[namespace].push(key);
-  transform.transformerNamespaces[key] = namespace;
-
-  transform.transformers[key] = new Transformer(key, transformer);
-});
+var transform = pipeline.transform.bind(pipeline);
+transform.fromAst = pipeline.transformFromAst.bind(pipeline);
+transform.pipeline = pipeline;
+export default transform;

src/babel/transformation/modules/_default.js

@@ -7,56 +7,61 @@ import * as t from "../../types";
 
 var remapVisitor = {
   enter(node, parent, scope, formatter) {
+    if (node._skipModulesRemap) {
+      return this.skip();
+    }
+  },
+
+  ReferencedIdentifier(node, parent, scope, formatter) {
     var remap = formatter.internalRemap[node.name];
-    if (this.isReferencedIdentifier() && remap) {
+
+    if (remap && node !== remap) {
       if (!scope.hasBinding(node.name) || scope.bindingIdentifierEquals(node.name, formatter.localImports[node.name])) {
         return remap;
       }
     }
+  },
 
-    if (t.isUpdateExpression(node)) {
-      var exported = formatter.getExport(node.argument, scope);
-
-      if (exported) {
-        this.skip();
-
-        // expand to long file assignment expression
-        var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
-
-        // remap this assignment expression
-        var remapped = formatter.remapExportAssignment(assign, exported);
-
-        // we don't need to change the result
-        if (t.isExpressionStatement(parent) || node.prefix) {
-          return remapped;
+  AssignmentExpression: {
+    exit(node, parent, scope, formatter) {
+      if (!node._ignoreModulesRemap) {
+        var exported = formatter.getExport(node.left, scope);
+        if (exported) {
+          return formatter.remapExportAssignment(node, exported);
         }
-
-        var nodes = [];
-        nodes.push(remapped);
-
-        var operator;
-        if (node.operator === "--") {
-          operator = "+";
-        } else { // "++"
-          operator = "-";
-        }
-        nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
-
-        return t.sequenceExpression(nodes);
       }
     }
+  },
 
-    if (node._skipModulesRemap) {
-      return this.skip();
+  UpdateExpression(node, parent, scope, formatter) {
+    var exported = formatter.getExport(node.argument, scope);
+    if (!exported) return;
+
+    this.skip();
+
+    // expand to long file assignment expression
+    var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
+
+    // remap this assignment expression
+    var remapped = formatter.remapExportAssignment(assign, exported);
+
+    // we don't need to change the result
+    if (t.isExpressionStatement(parent) || node.prefix) {
+      return remapped;
     }
 
-    if (t.isAssignmentExpression(node) && !node._ignoreModulesRemap) {
-      var exported = formatter.getExport(node.left, scope);
-      if (exported) {
-        this.skip();
-        return formatter.remapExportAssignment(node, exported);
-      }
+    var nodes = [];
+    nodes.push(remapped);
+
+    var operator;
+    if (node.operator === "--") {
+      operator = "+";
+    } else { // "++"
+      operator = "-";
     }
+    nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
+
+    return t.sequenceExpression(nodes);
   }
 };
 
@@ -69,7 +74,7 @@ var importsVisitor = {
   }
 };
 
-var exportsVisitor = traverse.explode({
+var exportsVisitor = {
   ExportDeclaration: {
     enter(node, parent, scope, formatter) {
       formatter.hasLocalExports = true;
@@ -101,7 +106,7 @@ var exportsVisitor = traverse.explode({
       }
     }
   }
-});
+};
 
 export default class DefaultFormatter {
   constructor(file) {
@@ -123,6 +128,11 @@ export default class DefaultFormatter {
     this.getLocalImports();
   }
 
+  isModuleType(node, type) {
+    var modules = this.file.dynamicImportTypes[type];
+    return modules && modules.indexOf(node) >= 0;
+  }
+
   transform() {
     this.remapAssignments();
   }
@@ -160,7 +170,7 @@ export default class DefaultFormatter {
   }
 
   _addExport(name, exported) {
-    var info = this.localExports[name] ||= {
+    var info = this.localExports[name] = this.localExports[name] || {
       binding: this.scope.getBindingIdentifier(name),
       exported: []
     };
@@ -178,7 +188,10 @@ export default class DefaultFormatter {
 
   getModuleName() {
     var opts = this.file.opts;
-    if (opts.moduleId) return opts.moduleId;
+    // moduleId is n/a if a `getModuleId()` is provided
+    if (opts.moduleId && !opts.getModuleId) {
+      return opts.moduleId;
+    }
 
     var filenameRelative = opts.filenameRelative;
     var moduleName = "";
@@ -207,7 +220,12 @@ export default class DefaultFormatter {
     // normalize path separators
     moduleName = moduleName.replace(/\\/g, "/");
 
-    return moduleName;
+    if (opts.getModuleId) {
+      // If return is falsy, assume they want us to use our generated default name
+      return opts.getModuleId(moduleName) || moduleName;
+    } else {
+      return moduleName;
+    }
   }
 
   _pushStatement(ref, nodes) {

src/babel/transformation/modules/amd.js

@@ -23,7 +23,7 @@ export default class AMDFormatter extends DefaultFormatter {
    */
 
   transform(program) {
-    DefaultFormatter.prototype.transform.apply(this, arguments);
+    CommonFormatter.prototype.transform.apply(this, arguments);
 
     var body = program.body;
 
@@ -80,7 +80,9 @@ export default class AMDFormatter extends DefaultFormatter {
       this.defaultIds[key] = specifier.local;
     }
 
-    if (includes(this.file.dynamicImportAbsoluteDefaults, node)) {
+    if (this.isModuleType(node, "absolute")) {
+      // absolute module reference
+    } else if (this.isModuleType(node, "absoluteDefault")) {
       // prevent unnecessary renaming of dynamic imports
       this.ids[node.source.value] = ref;
       ref = t.memberExpression(ref, t.identifier("default"));
@@ -105,12 +107,17 @@ export default class AMDFormatter extends DefaultFormatter {
 
   exportSpecifier(specifier, node, nodes) {
     if (this.doDefaultExportInterop(specifier)) {
-      nodes.push(util.template("exports-default-assign", {
-        VALUE: specifier.local
-      }, true));
-    } else {
-      CommonFormatter.prototype.exportSpecifier.apply(this, arguments);
+      this.passModuleArg = true;
+
+      if (specifier.exported !== specifier.local && !node.source) {
+        nodes.push(util.template("exports-default-assign", {
+          VALUE: specifier.local
+        }, true));
+        return;
+      }
     }
+
+    CommonFormatter.prototype.exportSpecifier.apply(this, arguments);
   }
 
   exportDeclaration(node, nodes) {

src/babel/transformation/modules/common.js

@@ -20,7 +20,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
       if (this.file.isLoose("es6.modules")) templateName += "-loose";
       var declar = util.template(templateName, true);
       declar._blockHoist = 3;
-      file.ast.program.body.unshift(declar);
+      file.path.unshiftContainer("body", [declar]);
     }
   }
 
@@ -45,7 +45,9 @@ export default class CommonJSFormatter extends DefaultFormatter {
 
     // import foo from "foo";
     if (t.isSpecifierDefault(specifier)) {
-      if (includes(this.file.dynamicImportAbsoluteDefaults, node)) {
+      if (this.isModuleType(node, "absolute")) {
+        // absolute module reference
+      } else if (this.isModuleType(node, "absoluteDefault")) {
         this.internalRemap[variableName.name] = ref;
       } else if (this.noInteropRequireImport) {
         this.internalRemap[variableName.name] = t.memberExpression(ref, t.identifier("default"));
@@ -53,7 +55,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
         var uid = this.scope.generateUidBasedOnNode(node, "import");
 
         nodes.push(t.variableDeclaration("var", [
-          t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-wildcard"), [ref]))
+          t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-default"), [ref]))
         ]));
 
         this.internalRemap[variableName.name] = t.memberExpression(uid, t.identifier("default"));
@@ -104,13 +106,16 @@ export default class CommonJSFormatter extends DefaultFormatter {
     var call = t.callExpression(t.identifier("require"), [node.source]);
     var uid;
 
-    if (includes(this.file.dynamicImportAbsoluteDefaults, node)) {
+    if (this.isModuleType(node, "absolute")) {
+      // absolute module reference
+    } else if (this.isModuleType(node, "absoluteDefault")) {
       call = t.memberExpression(call, t.identifier("default"));
-      uid = node.specifiers[0].local;
     } else {
       uid = this.scope.generateUidBasedOnNode(node, "import");
     }
 
+    uid = uid || node.specifiers[0].local;
+
     var declar = t.variableDeclaration("var", [
       t.variableDeclarator(uid, call)
     ]);

src/babel/transformation/modules/system.js

@@ -1,5 +1,6 @@
 import DefaultFormatter from "./_default";
 import AMDFormatter from "./amd";
+import object from  "../../helpers/object";
 import * as util from  "../../util";
 import last from "lodash/array/last";
 import each from "lodash/collection/each";
@@ -60,12 +61,12 @@ var runnerSettersVisitor = {
   enter(node, parent, scope, state) {
     if (node._importSource === state.source) {
       if (t.isVariableDeclaration(node)) {
-        each(node.declarations, function (declar) {
+        for (var declar of (node.declarations: Array)) {
           state.hoistDeclarators.push(t.variableDeclarator(declar.id));
           state.nodes.push(t.expressionStatement(
             t.assignmentExpression("=", declar.id, declar.init)
           ));
-        });
+        }
       } else {
         state.nodes.push(node);
       }
@@ -77,11 +78,11 @@ var runnerSettersVisitor = {
 
 export default class SystemFormatter extends AMDFormatter {
   constructor(file) {
+    super(file);
+
     this.exportIdentifier = file.scope.generateUidIdentifier("export");
     this.noInteropRequireExport = true;
     this.noInteropRequireImport = true;
-
-    DefaultFormatter.apply(this, arguments);
   }
 
   _addImportSource(node, exportNode) {
@@ -143,7 +144,7 @@ export default class SystemFormatter extends AMDFormatter {
       ]));
     }
 
-    this.internalRemap = {};
+    this.internalRemap = object();
 
     this._addImportSource(last(nodes), node);
   }

src/babel/transformation/templates/call-instance-decorator.js

@@ -1 +0,0 @@
-this.KEY = INITIALIZERS.KEY.call(this);

src/babel/transformation/templates/call-static-decorator.js

@@ -1 +0,0 @@
-CONSTRUCTOR.KEY = INITIALIZERS.KEY.call(CONSTRUCTOR);

src/babel/transformation/templates/helper-create-decorated-class.js

@@ -23,7 +23,11 @@
             throw new TypeError("The decorator for method " + descriptor.key + " is of the invalid type " + typeof decorator);
           }
         }
-        if (initializers) initializers[key] = descriptor.initializer;
+
+        if (descriptor.initializer !== undefined) {
+          initializers[key] = descriptor;
+          continue;
+        }
       }
 
       Object.defineProperty(target, key, descriptor);

src/babel/transformation/templates/helper-create-decorated-object.js

@@ -13,7 +13,7 @@
 
     descriptor.enumerable = true;
     descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
+    descriptor.writable = true;
 
     if (decorators) {
       for (var f = 0; f < decorators.length; f++) {
@@ -26,6 +26,10 @@
       }
     }
 
+    if (descriptor.initializer) {
+      descriptor.value = descriptor.initializer.call(target);
+    }
+
     Object.defineProperty(target, key, descriptor);
   }
 

src/babel/transformation/templates/helper-define-decorated-property-descriptor.js

@@ -0,0 +1,13 @@
+(function (target, key, descriptors) {
+  var _descriptor = descriptors[key];
+  if (!_descriptor) return;
+
+  // clone it
+  var descriptor = {};
+  for (var _key in _descriptor) descriptor[_key] = _descriptor[_key];
+
+  // initialize it
+  descriptor.value = descriptor.initializer.call(target);
+
+  Object.defineProperty(target, key, descriptor);
+})

src/babel/transformation/templates/helper-define-property.js

@@ -1,7 +1,7 @@
 (function (obj, key, value) {
   return Object.defineProperty(obj, key, {
     value: value,
-    enumerable: key == null || typeof Symbol == "undefined" || key.constructor !== Symbol,
+    enumerable: true,
     configurable: true,
     writable: true
   });

src/babel/transformation/templates/helper-instanceof.js

@@ -0,0 +1,7 @@
+(function (left, right) {
+  if (right != null && right[Symbol.hasInstance]) {
+    return right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
+});

src/babel/transformation/templates/helper-interop-require-default.js

@@ -0,0 +1,3 @@
+(function (obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+})

src/babel/transformation/templates/helper-interop-require-wildcard.js

@@ -1,3 +1,14 @@
 (function (obj) {
-  return obj && obj.__esModule ? obj : { default: obj };
+  if (obj && obj.__esModule) {
+    return obj;
+  } else {
+    var newObj = {};
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
+      }
+    }
+    newObj.default = obj;
+    return newObj;
+  }
 })

src/babel/transformation/templates/ludicrous-in.js

@@ -1 +0,0 @@
-Object(RIGHT)[LEFT] !== undefined;

src/babel/transformation/templates/property-method-assignment-wrapper-generator.js

@@ -1,6 +1,6 @@
 (function (FUNCTION_KEY) {
   function* FUNCTION_ID() {
-    return yield* FUNCTION_ID.apply(this, arguments);
+    return yield* FUNCTION_KEY.apply(this, arguments);
   }
 
   FUNCTION_ID.toString = function () {

src/babel/transformation/transformer-pass.js

@@ -9,57 +9,26 @@ import traverse from "../traversal";
 export default class TransformerPass {
   constructor(file: File, transformer: Transformer) {
     this.transformer = transformer;
-    this.shouldRun   = !transformer.check;
     this.handlers    = transformer.handlers;
     this.file        = file;
     this.ran         = false;
+    this.key         = transformer.key;
   }
 
   canTransform(): boolean {
-    var transformer = this.transformer;
-
-    var opts = this.file.opts;
-    var key  = transformer.key;
-
-    // internal
-    if (key[0] === "_") return true;
-
-    // blacklist
-    var blacklist = opts.blacklist;
-    if (blacklist.length && includes(blacklist, key)) return false;
-
-    // whitelist
-    var whitelist = opts.whitelist;
-    if (whitelist) return includes(whitelist, key);
-
-    // stage
-    var stage = transformer.metadata.stage;
-    if (stage != null && stage >= opts.stage) return true;
-
-    // optional
-    if (transformer.metadata.optional && !includes(opts.optional, key)) return false;
-
-    return true;
-  }
-
-  checkNode(node: Object): boolean {
-    var check = this.transformer.check;
-    if (check) {
-      return this.shouldRun = check(node);
-    } else {
-      return true;
-    }
+    return this.file.transformerDependencies[this.key] ||
+           this.file.pipeline.canTransform(this.transformer, this.file.opts);
   }
 
   transform() {
-    if (!this.shouldRun) return;
-
     var file = this.file;
 
-    file.log.debug(`Running transformer ${this.transformer.key}`);
+    file.log.debug(`Start transformer ${this.key}`);
 
     traverse(file.ast, this.handlers, file.scope, file);
 
+    file.log.debug(`Finish transformer ${this.key}`);
+
     this.ran = true;
   }
 }

src/babel/transformation/transformer-pipeline.js

@@ -0,0 +1,105 @@
+import Transformer from "./transformer";
+import normalizeAst from "../helpers/normalize-ast";
+import assign from "lodash/object/assign";
+import object from "../helpers/object";
+import File from "./file";
+
+export default class TransformerPipeline {
+  constructor() {
+    this.transformers = object();
+    this.namespaces   = object();
+    this.deprecated   = object();
+    this.aliases      = object();
+    this.filters      = [];
+  }
+
+  addTransformers(transformers) {
+    for (var key in transformers) {
+      this.addTransformer(key, transformers[key]);
+    }
+    return this;
+  }
+
+  addTransformer(key, transformer) {
+    if (this.transformers[key]) throw new Error(); // todo: error
+
+    var namespace = key.split(".")[0];
+    this.namespaces[namespace] = this.namespaces[namespace] || [];
+    this.namespaces[namespace].push(key);
+    this.namespaces[key] = namespace;
+
+    this.transformers[key] = new Transformer(key, transformer);
+  }
+
+  addAliases(names) {
+    assign(this.aliases, names);
+    return this;
+  }
+
+  addDeprecated(names) {
+    assign(this.deprecated, names);
+    return this;
+  }
+
+  addFilter(filter: Function) {
+    this.filters.push(filter);
+    return this;
+  }
+
+  canTransform(transformer, fileOpts) {
+    if (transformer.metadata.plugin) return true;
+
+    for (var filter of (this.filters: Array)) {
+      var result = filter(transformer, fileOpts);
+      if (result != null) return result;
+    }
+
+    return true;
+  }
+
+  transform(code: string, opts?: Object) {
+    var file = new File(opts, this);
+    return file.wrap(code, function () {
+      file.addCode(code, true);
+    });
+  }
+
+  transformFromAst(ast, code, opts) {
+    ast = normalizeAst(ast);
+
+    var file = new File(opts, this);
+    return file.wrap(code, function () {
+      file.addCode(code);
+      file.addAst(ast);
+    });
+  }
+
+  _ensureTransformerNames(type: string, rawKeys: Array<string>) {
+    var keys = [];
+
+    for (var i = 0; i < rawKeys.length; i++) {
+      var key = rawKeys[i];
+
+      var deprecatedKey = this.deprecated[key];
+      var aliasKey = this.aliases[key];
+      if (aliasKey) {
+        keys.push(aliasKey);
+      } else if (deprecatedKey) {
+        // deprecated key, remap it to the new one
+        console.error(`[BABEL] The transformer ${key} has been renamed to ${deprecatedKey}`);
+        rawKeys.push(deprecatedKey);
+      } else if (this.transformers[key]) {
+        // valid key
+        keys.push(key);
+      } else if (this.namespaces[key]) {
+        // namespace, append all transformers within this namespace
+        keys = keys.concat(this.namespaces[key]);
+      } else {
+        // invalid key
+        throw new ReferenceError(`Unknown transformer ${key} specified in ${type}`);
+      }
+    }
+
+    return keys;
+  }
+}

src/babel/transformation/transformer.js

@@ -1,4 +1,5 @@
 import TransformerPass from "./transformer-pass";
+import * as messages from "../messages";
 import isFunction from "lodash/lang/isFunction";
 import traverse from "../traversal";
 import isObject from "lodash/lang/isObject";
@@ -14,7 +15,7 @@ import each from "lodash/collection/each";
  */
 
 export default class Transformer {
-  constructor(transformerKey: key, transformer: Object, opts: Object) {
+  constructor(transformerKey: string, transformer: Object) {
     transformer = assign({}, transformer);
 
     var take = function (key) {
@@ -25,17 +26,20 @@ export default class Transformer {
 
     this.manipulateOptions = take("manipulateOptions");
     this.metadata          = take("metadata") || {};
+    this.dependencies      = this.metadata.dependencies || [];
     this.parser            = take("parser");
-    this.check             = take("check");
     this.post              = take("post");
     this.pre               = take("pre");
 
+    //
+
     if (this.metadata.stage != null) {
       this.metadata.optional = true;
     }
 
+    //
+
     this.handlers = this.normalize(transformer);
-    this.opts     ||= {};
     this.key      = transformerKey;
   }
 
@@ -71,7 +75,7 @@ export default class Transformer {
   buildPass(file: File): TransformerPass {
     // validate Transformer instance
     if (!(file instanceof File)) {
-      throw new TypeError(`Transformer ${this.key} is resolving to a different Babel version to what is doing the actual transformation...`);
+      throw new TypeError(messages.get("transformerNotFile", this.key));
     }
 
     return new TransformerPass(file, this);

src/babel/transformation/transformers/deprecated.json

@@ -5,7 +5,8 @@
   "es6.symbols": "es6.spec.symbols",
   "es6.blockScopingTDZ": "es6.spec.blockScoping",
 
-  "minification.deadCodeElimination": "utility.deadCodeElimination",
-  "minification.removeConsoleCalls": "utility.removeConsole",
-  "minification.removeDebugger": "utility.removeDebugger"
+  "utility.inlineExpressions": "minification.inlineExpressions",
+  "utility.deadCodeElimination": "minification.deadCodeElimination",
+  "utility.removeConsoleCalls": "minification.removeConsole",
+  "utility.removeDebugger": "minification.removeDebugger"
 }

src/babel/transformation/transformers/es3/member-expression-literals.js

@@ -1,14 +1,16 @@
 import * as t from "../../../types";
 
-export function MemberExpression(node) {
-  var prop = node.property;
-  if (node.computed && t.isLiteral(prop) && t.isValidIdentifier(prop.value)) {
-    // foo["bar"] => foo.bar
-    node.property = t.identifier(prop.value);
-    node.computed = false;
-  } else if (!node.computed && t.isIdentifier(prop) && !t.isValidIdentifier(prop.name)) {
-    // foo.default -> foo["default"]
-    node.property = t.literal(prop.name);
-    node.computed = true;
+export var metadata = {
+  group: "builtin-trailing"
+};
+
+export var MemberExpression = {
+  exit(node) {
+    var prop = node.property;
+    if (!node.computed && t.isIdentifier(prop) && !t.isValidIdentifier(prop.name)) {
+      // foo.default -> foo["default"]
+      node.property = t.literal(prop.name);
+      node.computed = true;
+    }
   }
-}
+};

src/babel/transformation/transformers/es3/property-literals.js

@@ -1,13 +1,15 @@
 import * as t from "../../../types";
 
-export function Property(node) {
-  var key = node.key;
-  if (t.isLiteral(key) && t.isValidIdentifier(key.value)) {
-    // "foo": "bar" -> foo: "bar"
-    node.key = t.identifier(key.value);
-    node.computed = false;
-  } else if (!node.computed && t.isIdentifier(key) && !t.isValidIdentifier(key.name)) {
-    // default: "bar" -> "default": "bar"
-    node.key = t.literal(key.name);
+export var metadata = {
+  group: "builtin-trailing"
+};
+
+export var Property = {
+  exit(node) {
+    var key = node.key;
+    if (!node.computed && t.isIdentifier(key) && !t.isValidIdentifier(key.name)) {
+      // default: "bar" -> "default": "bar"
+      node.key = t.literal(key.name);
+    }
   }
-}
+};

src/babel/transformation/transformers/es5/properties.mutators.js

@@ -1,10 +1,6 @@
 import * as defineMap from "../../helpers/define-map";
 import * as t from "../../../types";
 
-export function check(node) {
-  return t.isProperty(node) && (node.kind === "get" || node.kind === "set");
-}
-
 export function ObjectExpression(node, parent, scope, file) {
   var mutatorMap = {};
   var hasAny = false;

src/babel/transformation/transformers/es6/arrow-functions.js

@@ -1,13 +1,9 @@
 import * as t from "../../../types";
 
-export var check = t.isArrowFunctionExpression;
-
 export function ArrowFunctionExpression(node) {
   t.ensureBlock(node);
 
   node.expression = false;
   node.type = "FunctionExpression";
   node.shadow = true;
-
-  return node;
 }

src/babel/transformation/transformers/es6/block-scoping.js

@@ -14,7 +14,7 @@ function isLet(node, parent) {
   if (isLetInitable(node, parent)) {
     for (var i = 0; i < node.declarations.length; i++) {
       var declar = node.declarations[i];
-      declar.init ||= t.identifier("undefined");
+      declar.init = declar.init || t.identifier("undefined");
     }
   }
 
@@ -32,14 +32,14 @@ function isVar(node, parent) {
 }
 
 function standardizeLets(declars) {
-  for (var i = 0; i < declars.length; i++) {
-    delete declars[i]._let;
+  for (var declar of (declars: Array)) {
+    delete declar._let;
   }
 }
 
-export function check(node) {
-  return t.isVariableDeclaration(node) && (node.kind === "let" || node.kind === "const");
-}
+export var metadata = {
+  group: "builtin-advanced"
+};
 
 export function VariableDeclaration(node, parent, scope, file) {
   if (!isLet(node, parent)) return;
@@ -109,19 +109,14 @@ function traverseReplace(node, parent, scope, remaps) {
 }
 
 var letReferenceBlockVisitor = {
-  enter(node, parent, scope, state) {
-    if (this.isFunction()) {
-      this.traverse(letReferenceFunctionVisitor, state);
-      return this.skip();
-    }
+  Function(node, parent, scope, state) {
+    this.traverse(letReferenceFunctionVisitor, state);
+    return this.skip();
   }
 };
 
 var letReferenceFunctionVisitor = {
-  enter(node, parent, scope, state) {
-    // not a direct reference
-    if (!this.isReferencedIdentifier()) return;
-
+  ReferencedIdentifier(node, parent, scope, state) {
     var ref = state.letReferences[node.name];
 
     // not a part of our scope
@@ -139,7 +134,12 @@ var hoistVarDeclarationsVisitor = {
   enter(node, parent, scope, self) {
     if (this.isForStatement()) {
       if (isVar(node.init, node)) {
-        node.init = t.sequenceExpression(self.pushDeclar(node.init));
+        var nodes = self.pushDeclar(node.init);
+        if (nodes.length === 1) {
+          node.init = nodes[0];
+        } else {
+          node.init = t.sequenceExpression(nodes);
+        }
       }
     } else if (this.isFor()) {
       if (isVar(node.left, node)) {
@@ -154,10 +154,8 @@ var hoistVarDeclarationsVisitor = {
 };
 
 var loopLabelVisitor = {
-  enter(node, parent, scope, state) {
-    if (this.isLabeledStatement()) {
-      state.innerLabels.push(node.label.name);
-    }
+  LabeledStatement(node, parent, scope, state) {
+    state.innerLabels.push(node.label.name);
   }
 };
 
@@ -182,19 +180,28 @@ var loopNodeTo = function (node) {
 };
 
 var loopVisitor = {
+  Loop(node, parent, scope, state) {
+    var oldIgnoreLabeless = state.ignoreLabeless;
+    state.ignoreLabeless = true;
+    this.traverse(loopVisitor, state);
+    state.ignoreLabeless = oldIgnoreLabeless;
+    this.skip();
+  },
+
+  Function() {
+    this.skip();
+  },
+
+  SwitchCase(node, parent, scope, state) {
+    var oldInSwitchCase = state.inSwitchCase;
+    state.inSwitchCase = true;
+    this.traverse(loopVisitor, state);
+    state.inSwitchCase = oldInSwitchCase;
+    this.skip();
+  },
+
   enter(node, parent, scope, state) {
     var replace;
-
-    if (this.isLoop()) {
-      state.ignoreLabeless = true;
-      this.traverse(loopVisitor, state);
-      state.ignoreLabeless = false;
-    }
-
-    if (this.isFunction() || this.isLoop()) {
-      return this.skip();
-    }
-
     var loopText = loopNodeTo(node);
 
     if (loopText) {
@@ -210,6 +217,9 @@ var loopVisitor = {
         // they don't refer to the actual loop we're scopifying
         if (state.ignoreLabeless) return;
 
+        //
+        if (state.inSwitchCase) return;
+
         // break statements mean something different in this context
         if (t.isBreakStatement(node) && t.isSwitchCase(parent)) return;
       }
@@ -228,6 +238,7 @@ var loopVisitor = {
 
     if (replace) {
       replace = t.returnStatement(replace);
+      this.skip();
       return t.inherits(replace, node);
     }
   }
@@ -462,18 +473,17 @@ class BlockScoping {
     var block = this.block;
 
     var declarators = block._letDeclarators || [];
-    var declar;
 
     //
-    for (var i = 0; i < declarators.length; i++) {
-      declar = declarators[i];
+    for (let i = 0; i < declarators.length; i++) {
+      let declar = declarators[i];
       extend(this.outsideLetReferences, t.getBindingIdentifiers(declar));
     }
 
     //
     if (block.body) {
-      for (i = 0; i < block.body.length; i++) {
-        declar = block.body[i];
+      for (let i = 0; i < block.body.length; i++) {
+        let declar = block.body[i];
         if (isLet(declar, block)) {
           declarators = declarators.concat(declar.declarations);
         }
@@ -481,8 +491,8 @@ class BlockScoping {
     }
 
     //
-    for (i = 0; i < declarators.length; i++) {
-      declar = declarators[i];
+    for (let i = 0; i < declarators.length; i++) {
+      let declar = declarators[i];
       var keys = t.getBindingIdentifiers(declar);
       extend(this.letReferences, keys);
       this.hasLetReferences = true;
@@ -519,6 +529,7 @@ class BlockScoping {
     var state = {
       hasBreakContinue: false,
       ignoreLabeless:   false,
+      inSwitchCase:     false,
       innerLabels:      [],
       hasReturn:        false,
       isLoop:           !!this.loop,
@@ -606,7 +617,7 @@ class BlockScoping {
         for (var i = 0; i < cases.length; i++) {
           var caseConsequent = cases[i].consequent[0];
           if (t.isBreakStatement(caseConsequent) && !caseConsequent.label) {
-            caseConsequent.label = this.loopLabel ||= this.file.scope.generateUidIdentifier("loop");
+            caseConsequent.label = this.loopLabel = this.loopLabel || this.file.scope.generateUidIdentifier("loop");
           }
         }
 

src/babel/transformation/transformers/es6/classes.js

@@ -1,3 +1,4 @@
+import memoiseDecorators from "../../helpers/memoise-decorators";
 import ReplaceSupers from "../../helpers/replace-supers";
 import * as nameMethod from "../../helpers/name-method";
 import * as defineMap from "../../helpers/define-map";
@@ -10,8 +11,6 @@ import * as t from "../../../types";
 
 const PROPERTY_COLLISION_METHOD_NAME = "__initializeProperties";
 
-export var check = t.isClass;
-
 export function ClassDeclaration(node, parent, scope, file) {
   return t.variableDeclaration("let", [
     t.variableDeclarator(node.id, t.toExpression(node))
@@ -36,7 +35,23 @@ var collectPropertyReferencesVisitor = {
   }
 };
 
-var verifyConstructorVisitor = traverse.explode({
+var constructorVisitor = {
+  ThisExpression: {
+    enter(node, parent, scope, ref) {
+      return ref;
+    }
+  },
+
+  Function: {
+    enter(node) {
+      if (!node.shadow) {
+        this.skip();
+      }
+    }
+  }
+};
+
+var verifyConstructorVisitor = {
   MethodDefinition: {
     enter() {
       this.skip();
@@ -50,7 +65,7 @@ var verifyConstructorVisitor = traverse.explode({
   },
 
   CallExpression: {
-    enter(node, parent, scope, state) {
+    exit(node, parent, scope, state) {
       if (this.get("callee").isSuper()) {
         state.hasBareSuper = true;
         state.bareSuper = this;
@@ -79,13 +94,9 @@ var verifyConstructorVisitor = traverse.explode({
       if (state.hasSuper && !state.hasBareSuper) {
         throw this.errorWithNode("'this' is not allowed before super()");
       }
-
-      if (state.isNativeSuper) {
-        return state.nativeSuperRef;
-      }
     }
   }
-});
+};
 
 class ClassTransformer {
 
@@ -137,15 +148,6 @@ class ClassTransformer {
 
     //
 
-    var superClass = this.node.superClass;
-    this.isNativeSuper = superClass && t.isIdentifier(superClass) && t.NATIVE_TYPE_NAMES.indexOf(superClass.name) >= 0;
-
-    if (this.isNativeSuper) {
-      this.nativeSuperRef = this.scope.generateUidIdentifier("this");
-    }
-
-    //
-
     var body = this.body;
 
     //
@@ -217,18 +219,12 @@ class ClassTransformer {
       }
     }
 
-    if (this.isNativeSuper) {
-      // we've determined this is inheriting from a native class so return the constructed
-      // instance
-      constructorBody.body.push(t.returnStatement(this.nativeSuperRef));
-    }
-
     if (this.className) {
       // named class with only a constructor
       if (body.length === 1) return t.toExpression(body[0]);
     } else {
       // infer class name if this is a nameless class expression
-      constructor = nameMethod.bare(constructor, this.parent, this.scope);
+      constructor = nameMethod.bare(constructor, this.parent, this.scope) || constructor;
 
       body.unshift(t.variableDeclaration("var", [
         t.variableDeclarator(classRef, constructor)
@@ -292,6 +288,10 @@ class ClassTransformer {
       var node = classBody[i];
       var path = classBodyPaths[i];
 
+      if (node.decorators) {
+        memoiseDecorators(node.decorators, this.scope);
+      }
+
       if (t.isMethodDefinition(node)) {
         var isConstructor = node.kind === "constructor";
         if (isConstructor) this.verifyConstructor(path);
@@ -312,7 +312,7 @@ class ClassTransformer {
         if (isConstructor) {
           this.pushConstructor(node, path);
         } else {
-          this.pushMethod(node);
+          this.pushMethod(node, path);
         }
       } else if (t.isClassProperty(node)) {
         this.pushProperty(node);
@@ -323,10 +323,8 @@ class ClassTransformer {
     if (!this.hasConstructor && this.hasSuper) {
       var helperName = "class-super-constructor-call";
       if (this.isLoose) helperName += "-loose";
-      if (this.isNativeSuper) helperName = "class-super-native-constructor-call";
       constructorBody.body.push(util.template(helperName, {
-        NATIVE_REF: this.nativeSuperRef,
-        CLASS_NAME: className,
+        CLASS_NAME: this.classRef,
         SUPER_NAME: this.superName
       }, true));
     }
@@ -412,7 +410,7 @@ class ClassTransformer {
       this.pushMethod(t.methodDefinition(
         t.identifier(PROPERTY_COLLISION_METHOD_NAME),
         t.functionExpression(null, [], t.blockStatement(body))
-      ), true);
+      ), null, true);
 
       if (this.hasSuper) {
         this.bareSuper.insertAfter(call);
@@ -454,12 +452,10 @@ class ClassTransformer {
 
    verifyConstructor(path: TraversalPath) {
     var state = {
-      nativeSuperRef: this.nativeSuperRef,
-      isNativeSuper:  this.isNativeSuper,
-      hasBareSuper:   false,
-      bareSuper:      null,
-      hasSuper:       this.hasSuper,
-      file:           this.file
+      hasBareSuper: false,
+      bareSuper:    null,
+      hasSuper:     this.hasSuper,
+      file:         this.file
     };
 
     path.get("value").traverse(verifyConstructorVisitor, state);
@@ -469,36 +465,21 @@ class ClassTransformer {
     if (!state.hasBareSuper && this.hasSuper) {
       throw path.errorWithNode("Derived constructor must call super()");
     }
-
-    if (this.isNativeSuper && this.bareSuper) {
-      this.bareSuper.replaceWithMultiple([
-        t.variableDeclaration("var", [
-          t.variableDeclarator(this.nativeSuperRef, t.newExpression(this.superName, this.bareSuper.node.arguments))
-        ]),
-
-        t.expressionStatement(t.assignmentExpression(
-          "=",
-          t.memberExpression(this.nativeSuperRef, t.identifier("__proto__")),
-          t.memberExpression(this.classRef, t.identifier("prototype"))
-        )),
-        t.expressionStatement(this.nativeSuperRef)
-      ]);
-    }
-   }
+  }
 
   /**
    * Push a method to its respective mutatorMap.
    */
 
-  pushMethod(node: { type: "MethodDefinition" }, allowedIllegal?) {
+  pushMethod(node: { type: "MethodDefinition" }, path?: TraversalPath, allowedIllegal?) {
     if (!allowedIllegal && t.isLiteral(t.toComputedKey(node), { value: PROPERTY_COLLISION_METHOD_NAME })) {
       throw this.file.errorWithNode(node, messages.get("illegalMethodName", PROPERTY_COLLISION_METHOD_NAME));
     }
 
     if (node.kind === "method") {
-      nameMethod.property(node, this.file, this.scope);
+      nameMethod.property(node, this.file, path ? path.get("value").scope : this.scope);
 
-      if (this.isLoose) {
+      if (this.isLoose && !node.decorators) {
         // use assignments instead of define properties for loose classes
 
         var classRef = this.classRef;
@@ -529,34 +510,47 @@ class ClassTransformer {
 
     if (node.decorators) {
       var body = [];
-      if (node.value) body.push(t.returnStatement(node.value));
-      node.value = t.functionExpression(null, [], t.blockStatement(body));
+      if (node.value) {
+        body.push(t.returnStatement(node.value));
+        node.value = t.functionExpression(null, [], t.blockStatement(body));
+      } else {
+        node.value = t.literal(null);
+      }
       this.pushToMap(node, true, "initializer");
 
+      var initializers;
+      var body;
+      var target;
       if (node.static) {
-        this.staticPropBody.push(util.template("call-static-decorator", {
-          INITIALIZERS: this.staticInitializersId ||= this.scope.generateUidIdentifier("staticInitializers"),
-          CONSTRUCTOR:  this.classRef,
-          KEY:          node.key,
-        }, true));
+        initializers = this.staticInitializersId = this.staticInitializersId || this.scope.generateUidIdentifier("staticInitializers");
+        body = this.staticPropBody;
+        target = this.classRef;
       } else {
-        this.instancePropBody.push(util.template("call-instance-decorator", {
-          INITIALIZERS: this.instanceInitializersId ||= this.scope.generateUidIdentifier("instanceInitializers"),
-          KEY:          node.key
-        }, true));
+        initializers = this.instanceInitializersId = this.instanceInitializersId || this.scope.generateUidIdentifier("instanceInitializers");
+        body = this.instancePropBody;
+        target = t.thisExpression();
       }
+
+      body.push(t.expressionStatement(
+        t.callExpression(this.file.addHelper("define-decorated-property-descriptor"), [
+          target,
+          t.literal(node.key.name),
+          initializers
+        ])
+      ));
     } else {
-      if (!node.static && node.value) {
+      if (!node.value && !node.decorators) return;
+
+      if (node.static) {
+        // can just be added to the static map
+        this.pushToMap(node, true);
+      } else if (node.value) {
         // add this to the instancePropBody which will be added after the super call in a derived constructor
         // or at the start of a constructor for a non-derived constructor
         this.instancePropBody.push(t.expressionStatement(
           t.assignmentExpression("=", t.memberExpression(t.thisExpression(), node.key), node.value)
         ));
-        node.value = t.identifier("undefined");
       }
-
-      // can just be added to the static map
-      this.pushToMap(node, true);
     }
   }
 

src/babel/transformation/transformers/es6/constants.js

@@ -1,48 +1,31 @@
 import * as messages from "../../../messages";
 import * as t from "../../../types";
 
-export function check(node) {
-  return t.isVariableDeclaration(node, { kind: "const" }) || t.isImportDeclaration(node);
-}
+export function AssignmentExpression(node, parent, scope, file) {
+  var ids = this.getBindingIdentifiers();
 
-var visitor = {
-  enter(node, parent, scope, state) {
-    if (this.isAssignmentExpression() || this.isUpdateExpression()) {
-      var ids = this.getBindingIdentifiers();
+  for (var name in ids) {
+    var id = ids[name];
 
-      for (var name in ids) {
-        var id = ids[name];
+    var binding = scope.getBinding(name);
 
-        var constant = state.constants[name];
+    // no binding exists
+    if (!binding) continue;
 
-        // no constant exists
-        if (!constant) continue;
+    // not a constant
+    if (binding.kind !== "const" && binding.kind !== "module") continue;
 
-        var constantIdentifier = constant.identifier;
+    // check if the assignment id matches the constant declaration id
+    // if it does then it was the id used to initially declare the
+    // constant so we can just ignore it
+    if (binding.identifier === id) continue;
 
-        // check if the assignment id matches the constant declaration id
-        // if it does then it was the id used to initially declare the
-        // constant so we can just ignore it
-        if (id === constantIdentifier) continue;
-
-        // check if there's been a local binding that shadows this constant
-        if (!scope.bindingIdentifierEquals(name, constantIdentifier)) continue;
-
-        throw state.file.errorWithNode(id, messages.get("readOnly", name));
-      }
-    } else if (this.isScope()) {
-      this.skip();
-    }
+    throw file.errorWithNode(id, messages.get("readOnly", name));
   }
-};
-
-export function Scopable(node, parent, scope, file) {
-  this.traverse(visitor, {
-    constants: scope.getAllBindingsOfKind("const", "module"),
-    file:      file
-  });
 }
 
+export { AssignmentExpression as UpdateExpression };
+
 export function VariableDeclaration(node) {
   if (node.kind === "const") node.kind = "let";
 }

src/babel/transformation/transformers/es6/destructuring.js

@@ -1,7 +1,9 @@
 import * as messages from "../../../messages";
 import * as t from "../../../types";
 
-export var check = t.isPattern;
+export var metadata = {
+  group: "builtin-advanced"
+};
 
 export function ForOfStatement(node, parent, scope, file) {
   var left = node.left;
@@ -53,7 +55,7 @@ export function ForOfStatement(node, parent, scope, file) {
 
 export { ForOfStatement as ForInStatement };
 
-exports.Function = function (node, parent, scope, file) {
+export function Func(node, parent, scope, file) {
   var nodes = [];
 
   var hasDestructuring = false;
@@ -63,6 +65,7 @@ exports.Function = function (node, parent, scope, file) {
 
     hasDestructuring = true;
     var ref = scope.generateUidIdentifier("ref");
+    t.inherits(ref, pattern);
 
     var destructuring = new DestructuringTransformer({
       blockHoist: node.params.length - i,
@@ -78,12 +81,11 @@ exports.Function = function (node, parent, scope, file) {
 
   if (!hasDestructuring) return;
 
-  file.checkNode(nodes);
   t.ensureBlock(node);
 
   var block = node.body;
   block.body = nodes.concat(block.body);
-};
+}
 
 export function CatchClause(node, parent, scope, file) {
   var pattern = node.param;
@@ -103,15 +105,13 @@ export function CatchClause(node, parent, scope, file) {
   destructuring.init(pattern, ref);
 
   node.body.body = nodes.concat(node.body.body);
-
-  return node;
 }
 
 export function ExpressionStatement(node, parent, scope, file) {
   var expr = node.expression;
   if (expr.type !== "AssignmentExpression") return;
   if (!t.isPattern(expr.left)) return;
-  if (file.isConsequenceExpressionStatement(node)) return;
+  if (this.isCompletionRecord()) return;
 
   var destructuring = new DestructuringTransformer({
     operator: expr.operator,
@@ -200,7 +200,7 @@ export function VariableDeclaration(node, parent, scope, file) {
 
     for (i = 0; i < nodes.length; i++) {
       node = nodes[i];
-      declar ||= t.variableDeclaration(node.kind, []);
+      declar = declar || t.variableDeclaration(node.kind, []);
 
       if (!t.isVariableDeclaration(node) && declar.kind !== node.kind) {
         throw file.errorWithNode(node, messages.get("invalidParentForThisNode"));

src/babel/transformation/transformers/es6/for-of.js

@@ -2,8 +2,6 @@ import * as messages from "../../../messages";
 import * as util from  "../../../util";
 import * as t from "../../../types";
 
-export var check = t.isForOfStatement;
-
 export function ForOfStatement(node, parent, scope, file) {
   if (this.get("right").isArrayExpression()) {
     return _ForOfStatementArray.call(this, node, scope, file);

src/babel/transformation/transformers/es6/modules.js

@@ -1,7 +1,5 @@
 import * as t from "../../../types";
 
-export { check } from "../internal/modules";
-
 function keepBlockHoist(node, nodes) {
   if (node._blockHoist) {
     for (let i = 0; i < nodes.length; i++) {
@@ -10,6 +8,10 @@ function keepBlockHoist(node, nodes) {
   }
 }
 
+export var metadata = {
+  group: "builtin-modules"
+};
+
 export function ImportDeclaration(node, parent, scope, file) {
   // flow type
   if (node.isType) return;

src/babel/transformation/transformers/es6/object-super.js

@@ -1,38 +1,25 @@
 import ReplaceSupers from "../../helpers/replace-supers";
 import * as t from "../../../types";
 
-export var check = t.isSuper;
-
 function Property(path, node, scope, getObjectRef, file) {
-  if (!node.method) return;
-
-  var value = node.value;
-  var thisExpr = scope.generateUidIdentifier("this");
+  if (!node.method && node.kind === "init") return;
+  if (!t.isFunction(node.value)) return;
 
   var replaceSupers = new ReplaceSupers({
-    topLevelThisReference: thisExpr,
-    getObjectRef:          getObjectRef,
-    methodNode:            node,
-    methodPath:            path,
-    isStatic:              true,
-    scope:                 scope,
-    file:                  file
+    getObjectRef: getObjectRef,
+    methodNode:   node,
+    methodPath:   path,
+    isStatic:     true,
+    scope:        scope,
+    file:         file
   });
 
   replaceSupers.replace();
-
-  if (replaceSupers.hasSuper) {
-    value.body.body.unshift(
-      t.variableDeclaration("var", [
-        t.variableDeclarator(thisExpr, t.thisExpression())
-      ])
-    );
-  }
 }
 
 export function ObjectExpression(node, parent, scope, file) {
   var objectRef;
-  var getObjectRef = () => objectRef ||= scope.generateUidIdentifier("obj");
+  var getObjectRef = () => objectRef = objectRef || scope.generateUidIdentifier("obj");
 
   var propPaths = this.get("properties");
   for (var i = 0; i < node.properties.length; i++) {

src/babel/transformation/transformers/es6/parameters.default.js

@@ -1,11 +1,8 @@
 import callDelegate from "../../helpers/call-delegate";
 import * as util from  "../../../util";
+import traverse from  "../../../traversal";
 import * as t from "../../../types";
 
-export function check(node) {
-  return t.isFunction(node) && hasDefaults(node);
-}
-
 var hasDefaults = function (node) {
   for (var i = 0; i < node.params.length; i++) {
     if (!t.isIdentifier(node.params[i])) return true;
@@ -14,17 +11,18 @@ var hasDefaults = function (node) {
 };
 
 var iifeVisitor = {
-  enter(node, parent, scope, state) {
-    if (!this.isReferencedIdentifier()) return;
-    if (!state.scope.hasOwnBinding(node.name)) return;
-    if (state.scope.bindingIdentifierEquals(node.name, node)) return;
+  ReferencedIdentifier(node, parent, scope, state) {
+    if (node.name !== "eval") {
+      if (!state.scope.hasOwnBinding(node.name)) return;
+      if (state.scope.bindingIdentifierEquals(node.name, node)) return;
+    }
 
     state.iife = true;
     this.stop();
   }
 };
 
-exports.Function = function (node, parent, scope, file) {
+export function Func(node, parent, scope, file) {
   if (!hasDefaults(node)) return;
 
   t.ensureBlock(node);
@@ -45,7 +43,6 @@ exports.Function = function (node, parent, scope, file) {
       ARGUMENT_KEY:  t.literal(i),
       ARGUMENTS:     argsIdentifier
     }, true);
-    file.checkNode(defNode);
     defNode._blockHoist = node.params.length - i;
     body.push(defNode);
   };
@@ -97,4 +94,4 @@ exports.Function = function (node, parent, scope, file) {
   } else {
     node.body.body = body.concat(node.body.body);
   }
-};
+}

src/babel/transformation/transformers/es6/parameters.rest.js

@@ -2,8 +2,6 @@ import isNumber from "lodash/lang/isNumber";
 import * as util from  "../../../util";
 import * as t from "../../../types";
 
-export var check = t.isRestElement;
-
 var memberExpressionOptimisationVisitor = {
   enter(node, parent, scope, state) {
     // check if this scope has a local binding that will shadow the rest parameter
@@ -55,7 +53,7 @@ var hasRest = function (node) {
   return t.isRestElement(node.params[node.params.length - 1]);
 };
 
-exports.Function = function (node, parent, scope, file) {
+export function Func(node, parent, scope, file) {
   if (!hasRest(node)) return;
 
   var rest = node.params.pop().argument;
@@ -74,7 +72,6 @@ exports.Function = function (node, parent, scope, file) {
       var accessExpr = t.memberExpression(rest, t.literal(index), true);
       return t.variableDeclarator(elem, accessExpr);
     }));
-    file.checkNode(declar);
     node.body.body.unshift(declar);
   }
 
@@ -138,4 +135,4 @@ exports.Function = function (node, parent, scope, file) {
   });
   loop._blockHoist = node.params.length + 1;
   node.body.body.unshift(loop);
-};
+}

src/babel/transformation/transformers/es6/properties.computed.js

@@ -16,27 +16,13 @@ function loose(node, body, objId) {
 
 function spec(node, body, objId, initProps, file) {
   var props = node.properties;
-  var prop, key;
-
-  // normalize key
-
-  for (var i = 0; i < props.length; i++) {
-    prop = props[i];
-    if (prop.kind !== "init") continue;
-
-    key = prop.key;
-
-    if (!prop.computed && t.isIdentifier(key)) {
-      prop.key = t.literal(key.name);
-    }
-  }
 
   // add all non-computed properties and `__proto__` properties to the initializer
 
   var broken = false;
 
-  for (i = 0; i < props.length; i++) {
-    prop = props[i];
+  for (let i = 0; i < props.length; i++) {
+    let prop = props[i];
 
     if (prop.computed) {
       broken = true;
@@ -51,24 +37,17 @@ function spec(node, body, objId, initProps, file) {
   // add a simple assignment for all Symbol member expressions due to symbol polyfill limitations
   // otherwise use Object.defineProperty
 
-  for (i = 0; i < props.length; i++) {
-    prop = props[i];
+  for (let i = 0; i < props.length; i++) {
+    let prop = props[i];
     if (!prop) continue;
 
-    key = prop.key;
-    var bodyNode;
-
-    if (prop.computed && t.isMemberExpression(key) && t.isIdentifier(key.object, { name: "Symbol" })) {
-      // { [Symbol.iterator]: "foo" }
-      bodyNode = t.assignmentExpression(
-        "=",
-        t.memberExpression(objId, key, true),
-        prop.value
-      );
-    } else {
-      bodyNode = t.callExpression(file.addHelper("define-property"), [objId, key, prop.value]);
+    let key = prop.key;
+    if (t.isIdentifier(key) && !prop.computed) {
+      key = t.literal(key.name);
     }
 
+    var bodyNode = t.callExpression(file.addHelper("define-property"), [objId, key, prop.value]);
+
     body.push(t.expressionStatement(bodyNode));
   }
 
@@ -84,42 +63,40 @@ function spec(node, body, objId, initProps, file) {
   }
 }
 
-export function check(node) {
-  return t.isProperty(node) && node.computed;
-}
+export var ObjectExpression = {
+  exit(node, parent, scope, file) {
+    var hasComputed = false;
 
-export function ObjectExpression(node, parent, scope, file) {
-  var hasComputed = false;
+    for (var prop of (node.properties: Array)) {
+      hasComputed = t.isProperty(prop, { computed: true, kind: "init" });
+      if (hasComputed) break;
+    }
 
-  for (var i = 0; i < node.properties.length; i++) {
-    hasComputed = t.isProperty(node.properties[i], { computed: true, kind: "init" });
-    if (hasComputed) break;
+    if (!hasComputed) return;
+
+    var initProps = [];
+    var objId = scope.generateUidBasedOnNode(parent);
+
+    //
+
+    var body = [];
+
+    //
+
+    var callback = spec;
+    if (file.isLoose("es6.properties.computed")) callback = loose;
+
+    var result = callback(node, body, objId, initProps, file);
+    if (result) return result;
+
+    //
+
+    body.unshift(t.variableDeclaration("var", [
+      t.variableDeclarator(objId, t.objectExpression(initProps))
+    ]));
+
+    body.push(t.expressionStatement(objId));
+
+    return body;
   }
-
-  if (!hasComputed) return;
-
-  var initProps = [];
-  var objId = scope.generateUidBasedOnNode(parent);
-
-  //
-
-  var body = [];
-
-  //
-
-  var callback = spec;
-  if (file.isLoose("es6.properties.computed")) callback = loose;
-
-  var result = callback(node, body, objId, initProps, file);
-  if (result) return result;
-
-  //
-
-  body.unshift(t.variableDeclaration("var", [
-    t.variableDeclarator(objId, t.objectExpression(initProps))
-  ]));
-
-  body.push(t.expressionStatement(objId));
-
-  return body;
-}
+};

src/babel/transformation/transformers/es6/properties.shorthand.js

@@ -1,9 +1,3 @@
-import * as t from "../../../types";
-
-export function check(node) {
-  return t.isProperty(node) && (node.method || node.shorthand);
-}
-
 export function Property(node) {
   if (node.method) {
     node.method = false;
@@ -11,6 +5,5 @@ export function Property(node) {
 
   if (node.shorthand) {
     node.shorthand = false;
-    node.key = t.removeComments(t.clone(node.key));
   }
 }

src/babel/transformation/transformers/es6/regex.sticky.js

@@ -1,10 +1,6 @@
 import * as regex from "../../helpers/regex";
 import * as t from "../../../types";
 
-export function check(node) {
-  return regex.is(node, "y");
-}
-
 export function Literal(node) {
   if (!regex.is(node, "y")) return;
   return t.newExpression(t.identifier("RegExp"), [

src/babel/transformation/transformers/es6/regex.unicode.js

@@ -1,10 +1,6 @@
 import rewritePattern from "regexpu/rewrite-pattern";
 import * as regex from "../../helpers/regex";
 
-export function check(node) {
-  return regex.is(node, "u");
-}
-
 export function Literal(node) {
   if (!regex.is(node, "u")) return;
   node.regex.pattern = rewritePattern(node.regex.pattern, node.regex.flags);

src/babel/transformation/transformers/es6/spec.block-scoping.js

@@ -1,8 +1,8 @@
+import traverse from "../../../traversal";
 import * as t from "../../../types";
 
 var visitor = {
-  enter(node, parent, scope, state) {
-    if (!this.isReferencedIdentifier()) return;
+  ReferencedIdentifier(node, parent, scope, state) {
     if (t.isFor(parent) && parent.left === node) return;
 
     var declared = state.letRefs[node.name];
@@ -28,17 +28,20 @@ var visitor = {
 };
 
 export var metadata = {
-  optional: true
+  optional: true,
+  group: "builtin-advanced"
 };
 
-export function BlockStatement(node, parent, scope, file) {
-  var letRefs = node._letReferences;
-  if (!letRefs) return;
+export var BlockStatement = {
+  exit(node, parent, scope, file) {
+    var letRefs = node._letReferences;
+    if (!letRefs) return;
 
-  this.traverse(visitor, {
-    letRefs: letRefs,
-    file:    file
-  });
-}
+    this.traverse(visitor, {
+      letRefs: letRefs,
+      file:    file
+    });
+  }
+};
 
 export { BlockStatement as Program, BlockStatement as Loop };