v5.5.2

This reverts commit f3acedbf08.

.eslintrc

@@ -3,18 +3,21 @@
   "rules": {
     "strict": 0,
     "no-underscore-dangle": 0,
-    "no-unused-vars": 0,
     "curly": 0,
     "no-multi-spaces": 0,
     "key-spacing": 0,
     "no-return-assign": 0,
     "consistent-return": 0,
     "no-shadow": 0,
-    "no-comma-dangle": 0,
+    "comma-dangle": 0,
     "no-use-before-define": 0,
     "no-empty": 0,
     "new-parens": 0,
-    "no-cond-assign": 0
+    "no-cond-assign": 0,
+    "no-fallthrough": 0,
+    "new-cap": 0,
+    "no-loop-func": 0,
+    "no-unreachable": 0
   },
   "env": {
     "node": true

.gitignore

@@ -8,10 +8,10 @@ test/core/tmp
 /browser.js
 /browser-polyfill.js
 /runtime.js
-coverage
-dist
-.package.json
-packages/babel-runtime/core-js
-packages/babel-runtime/helpers/*.js
-packages/babel-runtime/regenerator/*.js
-lib
+/coverage
+/dist
+/.package.json
+/packages/babel-runtime/core-js
+/packages/babel-runtime/helpers/*.js
+/packages/babel-runtime/regenerator/*.js
+/lib

.gitmodules

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

CHANGELOG.md

@@ -13,6 +13,243 @@ _Note: Gaps between patch versions are faulty/broken releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 5.5.2
+
+ * **Bug Fix**
+  * Fix `NodePath#isPure` on `Property` nodes.
+  * Use cwd instead of entry file directory when working out relative directory for `babel/register`.
+ * **Internal**
+  * Add scary warning for those few who choose to use the WIP experimental transformers.
+
+## 5.5.1
+
+ * **Bug Fix**
+  * Remove `ClassProperty` nodes always in the `Flow` transformer. This is fine now since class properties aren't supported in any engine that supports classes but the `es7.classProperties` transformer will need to be updated in the future to desugar to ES6 classes instead of relying on the `es6.classes` transformer from being ran.
+
+## 5.5.0
+
+ * **Bug Fix**
+  * Allow pushing declarations to `SwitchStatement`s.
+  * Fix `minification.removeDebugger` to remove `DebuggerStatement`s rather than `ExpressionStatement`s with an identifier of `debugger`.
+  * Check LHS in `ForInStatement` and `ForOfStatement` for constant violations.
+  * Register function `id` as a reference when naming methods to avoid collisions.
+  * Support key literals when checking for the existence of `displayName` property when attempting to add it for `React.createClass`.
+  * Remove `ExportDefaultSpecifier` check from `t.isDefaultSpecifier`.
+  * Don't consider `JSXIdentifier` HTML tag identifiers to be references.
+ * **Polish**
+  * Update `minification.deadCodeElimination` transformer to remove all statements after completion statements.
+  * Update `minification.deadCodeElimination` transformer to not inline single used bindings that exist in different scopes.
+  * When performing Istanbul interop in `babel/register`, add the auxiliary comment `"istanbul ignore text"` to get more accurate coverage.
+  * Add `--nolazy` argument to `babel-node`.
+  * Add support for `cluster` forking.
+  * Perform scope tracking in a single pass instead of multiple.
+  * Smarten up type inferrence and resolution to support the whole array of language constructs.
+  * Optimise module metadata retrieval into a single pass.
+  * Ignore trailing commas when inferring newlines.
+  * Rename `minification.inlineExpressions` transformer to `minification.constantFolding`.
+  * Check path relative to entry file when checking to see if we're inside `node_modules` when using `babel/register`.
+  * Upgrade `regenerator`.
+
+## 5.4.7
+
+ * **Bug Fix**
+  * Don't consider `JSXAttribute` `names` to be valid `ReferencedIdentifier`s.
+
+## 5.4.6
+
+ * **Bug Fix**
+  * Fix `spec.functionName` transformer incorrectly attempting to rename a binding that doesn't exist as it's a global.
+ * **Internal**
+  * Deprecate custom module formatters.
+
+## 5.4.5
+
+ * **Bug Fix**
+  * Add `JSXIdentifier` as a valid `ReferencedIdentifier` visitor virtual type.
+  * Ignore `CallExpression` `_prettyCall` when the `retainLines` option is enabled.
+  * Inherit comments to new declaration node when exploding module declarations.
+  * Fix `es6.tailCall` transformer failing on calls that exceed the max parameters of the function.
+
+## 5.4.4
+
+ * **Bug Fix**
+  * Fix bug where replacing variable declarations in the head of a `for` loop would turn them into `ExpressionStatement`s.
+  * Fix renaming of assignment expressions that were non-identifiers ie. patterns.
+  * Force space before `class` `id` to avoid breaking named classes when using `compact` mode.
+  * Add assignment pattern explosion to avoid initial duplicate nodes.
+  * Ignore this and arguments when performing TCO on shadowed functions.
+ * **Polish**
+  * Rename `sourceMapName` option to `sourceMapTarget`. Thanks [@getify](https://github.com/getify)!
+  * Better detection of completion records, ignore those in `Function`s.
+  * Clarified descriptions of the options that are enabled by default.
+  * Resolve `\`babel-plugin-${name}\`` plugin names **before** just checking the `name`. Thanks [@jquense](https://github.com/jquense)!
+  * Update AMD module formatter to add import default remapping.
+
+## 5.4.3
+
+ * **Bug Fix**
+  * Fix `module` being incorrectly rewritten when used as in an export declaration.
+  * When performing single-reference inlining, ensure that the single reference isn't a child of the binding itself.
+  * Fix a bug in `minification.deadCodeElimination` where a new binding instance was being created for local class bindings instead of just inheriting the parent one.
+  * Fix bug with paren printing in `compact` and `retainLines` mode where a left paren was already printed before catching up.
+ * **Internal**
+  * Handle contexts for paths much better. This will ensure that the path node location info is in sync.
+
+## 5.4.2
+
+ * **Polish**
+  * `ignore` and `only` patterns are now **very** liberal. The pattern can now exist anywhere in the path.
+
+## 5.4.1
+
+ * **Bug Fix**
+  * Add missing `slash` dependency. Thanks [@browncolyn](https://github.com/browncolyn)!
+ * **Polish**
+  * Clean up `shouldIgnore` algorithm to work how you'd expect rather than being a hacky piece of shit. It now crawls the entire path, checking each section of it against the input ignore/only patterns. This means that the pattern `foo` will ignore the paths `foo/bar.js`, `bar/foo` etc.
+
+## 5.4.0
+
+ * **New Feature**
+  * Added [function bind syntax](https://github.com/zenparsing/es-function-bind) behind stage 0. Thanks [@RReverser](https://github.com/rreverser)!
+  * Added `env` option. Especially handy when using the `.babelrc`.
+ * **Bug Fix**
+  * Fix files not properly being ignored when `babel.transform` ignores them when using `$ babel`.
+  * Fix scope tracking registering loop head bindings to their `VariableDeclaration` instead of `VariableDeclarator`.
+ * **Polish**
+  * Normalise path separators for souce map paths when using `$ babel`.
+  * Rework `PathHoister` to ignore global references and to not deopt on reassignments to referenced bindings, instead it tries to hoist to the highest scope.
+  * Added missing exponential operator inlining. Thanks [@nkt](https://github.com/nkt)!
+  * Optimise `regenerator` transformer. Thanks [@benjamn](https://github.com/benjamn)!
+
+## 5.3.3
+
+ * **Bug Fix**
+  * Fix `minification.deadCodeElimination` transformer incorrectly trying to inline import declarations.
+  * Fix `minification.inlineExpression` transformer getting into an infinite loop.
+
+## 5.3.2
+
+ * **Bug Fix**
+  * Fix patterns not being considered when hoisting variables in the `es6.blockScoping` transformer.
+
+## 5.3.1
+
+ * **Bug Fix**
+  * Fix unique export specifiers not being cloned when exploding class and function exports,
+ * **Polish**
+  * Turn import remaps to sequence expressions to remove their context and improve performance.
+
+## 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`.
+  * Internal AST traversals have been minimised **drastically**. Transformers have been grouped together which means entire tree traversals are much fewer. Visiting nodes is now also skipped if the traversal context can detect that the handler is a noop. This sames precious cycles as it avoids constructing traversal paths and creating a new traversal context. See issues [#1472](https://github.com/babel/babel/issues/1472) and [#1486](https://github.com/babel/babel/issues/1486) for related discussion.
+ * **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**

CONTRIBUTING.md

@@ -1,3 +1,7 @@
+# NOTE: BEFORE OPENING AN ISSUE PLEASE SEE THE [README](https://github.com/babel/babel#readme).
+
+----
+
 <p align="center">
    <strong><a href="#setup">Setup</a></strong>
    |
@@ -21,6 +25,9 @@ contributing, please read the
 
 ## Developing
 
+>Note: Babel moves fast. Only the latest release is guaranteed to build correctly.
+>Older releases are not officially supported. If you attempt to build them, do that at your own risk.
+
 #### Setup
 
 ```sh
@@ -79,7 +86,6 @@ your [`$PATH`](http://unix.stackexchange.com/questions/26047/how-to-correctly-ad
 * 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.

Makefile

@@ -3,7 +3,6 @@ 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
 
@@ -23,6 +22,9 @@ watch-core: clean-core
 clean-core:
 	rm -rf lib
 
+lint:
+	eslint src/babel
+
 build:
 	mkdir -p dist
 	make build-core
@@ -62,7 +64,7 @@ test-cov:
 test-parser:
 	node test/acorn/run.js
 
-test-travis: bootstrap build test
+test-travis: bootstrap lint build test
 
 test-browser:
 	mkdir -p dist
@@ -74,7 +76,7 @@ test-browser:
 
 	test -n "`which open`" && open test/browser.html
 
-publish:
+publish: lint
 	git pull --rebase
 
 	make test
@@ -83,9 +85,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
@@ -97,7 +105,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; \
@@ -117,5 +125,4 @@ bootstrap:
 	npm link
 	cd packages/babel-cli && npm install && npm link && npm link babel-core
 	git submodule update --init
-	cd vendor/compat-table && npm install object-assign
 	make build

README.md

@@ -12,6 +12,10 @@
   For questions and support please visit the <a href="https://gitter.im/babel/babel">gitter room</a> or <a href="http://stackoverflow.com/questions/tagged/babeljs">StackOverflow</a>. The Babel issue tracker is <strong>exclusively</strong> for bug reports and feature requests.
 </p>
 
+<p align="center">
+  Issues without instructions to reproduce <strong>will be immediately closed<strong>.
+</p>
+
 <p align="center">
   For documentation and website issues please visit the <a href="https://github.com/babel/babel.github.io">babel.github.io</a> repo.
 </p>

package.json

@@ -1,9 +1,10 @@
 {
   "name": "babel-core",
-  "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.2.4",
+  "description": "A compiler for writing next generation JavaScript",
+  "version": "5.5.2",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
   "main": "lib/babel/api/node.js",
   "browser": {
@@ -27,6 +28,7 @@
     "test": "make test"
   },
   "dependencies": {
+    "acorn-jsx": "^1.0.0",
     "ast-types": "~0.7.0",
     "bluebird": "^2.9.25",
     "chalk": "^1.0.0",
@@ -34,10 +36,12 @@
     "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",
+    "home-or-tmp": "^1.0.0",
     "is-integer": "^1.0.4",
     "js-tokens": "1.0.0",
     "leven": "^1.0.1",
@@ -47,7 +51,7 @@
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
     "private": "^0.1.6",
-    "regenerator": "^0.8.20",
+    "regenerator": "^0.8.28",
     "regexpu": "^1.1.2",
     "repeating": "^1.1.2",
     "resolve": "^1.1.6",
@@ -57,15 +61,14 @@
     "source-map-support": "^0.2.10",
     "strip-json-comments": "^1.0.2",
     "to-fast-properties": "^1.0.0",
-    "trim-right": "^1.0.0",
-    "user-home": "^1.1.1"
+    "trim-right": "^1.0.0"
   },
   "devDependencies": {
-    "babel": "5.1.13",
+    "babel": "5.3.1",
     "browserify": "^9.0.8",
     "chai": "^2.2.0",
-    "eslint": "^0.18.0",
-    "babel-eslint": "^2.0.0",
+    "eslint": "^0.21.2",
+    "babel-eslint": "^3.1.9",
     "esvalid": "^1.1.0",
     "istanbul": "^0.3.5",
     "matcha": "^0.6.0",

packages/babel-cli/bin/_babel-node

@@ -107,6 +107,7 @@ if (program.eval || program.print) {
 
     // add back on node and concat the sliced args
     process.argv = ["node"].concat(args);
+    process.execArgv.unshift(__filename);
 
     Module.runMain();
   } else {

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":
@@ -410,6 +412,7 @@ babelArgs.forEach(function(arg){
     case "--prof_auto":
     case "--prof_lazy":
     case "--sliding_state_window":
+    case "--nolazy":
       args.unshift(arg);
       break;
 

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

@@ -1,5 +1,6 @@
 var outputFileSync = require("output-file-sync");
 var chokidar       = require("chokidar");
+var slash          = require("slash");
 var path           = require("path");
 var util           = require("./util");
 var fs             = require("fs");
@@ -13,8 +14,10 @@ module.exports = function (commander, filenames, opts) {
     var dest = path.join(commander.outDir, relative);
 
     var data = util.compile(src, {
-      sourceFileName: path.relative(dest + "/..", src)
+      sourceFileName: slash(path.relative(dest + "/..", src)),
+      sourceMapTarget: path.basename(relative)
     });
+    if (data.ignored) return;
 
     if (commander.sourceMaps && commander.sourceMaps !== "inline") {
       var mapLoc = dest + ".map";
@@ -30,7 +33,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

@@ -1,6 +1,7 @@
 var convertSourceMap = require("convert-source-map");
 var sourceMap        = require("source-map");
 var chokidar         = require("chokidar");
+var slash            = require("slash");
 var path             = require("path");
 var util             = require("./util");
 var fs               = require("fs");
@@ -15,7 +16,8 @@ module.exports = function (commander, filenames, opts) {
 
   var buildResult = function () {
     var map = new sourceMap.SourceMapGenerator({
-      file: commander.outFile || "stdout"
+      file: path.basename(commander.outFile) || "stdout",
+      sourceRoot: opts.sourceRoot
     });
 
     var code = "";
@@ -28,8 +30,14 @@ module.exports = function (commander, filenames, opts) {
       if (result.map) {
         var consumer = new sourceMap.SourceMapConsumer(result.map);
 
-        map._sources.add(filename);
-        map.setSourceContent(filename, result.actual);
+        var sourceFilename = filename;
+        if (commander.outFile) {
+          sourceFilename = path.relative(path.dirname(commander.outFile), sourceFilename);
+        }
+        sourceFilename = slash(sourceFilename);
+
+        map._sources.add(sourceFilename);
+        map.setSourceContent(sourceFilename, result.actual);
 
         consumer.eachMapping(function (mapping) {
           map._mappings.add({
@@ -37,7 +45,7 @@ module.exports = function (commander, filenames, opts) {
             generatedColumn: mapping.generatedColumn,
             originalLine: mapping.originalLine,
             originalColumn: mapping.originalColumn,
-            source: filename
+            source: sourceFilename
           });
         });
 
@@ -109,7 +117,9 @@ module.exports = function (commander, filenames, opts) {
     _.each(_filenames, function (filename) {
       if (util.shouldIgnore(filename)) return;
 
-      results.push(util.compile(filename));
+      var data = util.compile(filename);
+      if (data.ignored) return;
+      results.push(data);
     });
 
     output();

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

@@ -1,14 +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 glob      = require("glob");
+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;
@@ -36,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");
@@ -57,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");
@@ -68,10 +70,18 @@ commander.parse(process.argv);
 
 //
 
+if (commander.extensions) {
+  commander.extensions = util.arrayify(commander.extensions);
+}
+
+//
+
 var errors = [];
 
 var filenames = commander.args.reduce(function (globbed, input) {
-  return globbed.concat(glob.sync(input));
+  var files = glob.sync(input);
+  if (!files.length) files = [input];
+  return globbed.concat(files);
 }, []);
 
 each(filenames, function (filename) {

packages/babel-cli/package.json

@@ -1,13 +1,14 @@
 {
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.2.3",
+  "version": "5.5.1",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
   "preferGlobal": true,
   "dependencies": {
-    "babel-core": "^5.2.3",
+    "babel-core": "^5.5.1",
     "chokidar": "^1.0.0",
     "commander": "^2.6.0",
     "convert-source-map": "^1.1.0",
@@ -16,7 +17,8 @@
     "lodash": "^3.2.0",
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
-    "source-map": "^0.4.0"
+    "source-map": "^0.4.0",
+    "slash": "^1.0.0"
   },
   "bin": {
     "babel": "./bin/babel/index.js",

packages/babel-runtime/package.json

@@ -1,7 +1,8 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "5.2.3",
+  "version": "5.5.1",
+  "license": "MIT",
   "repository": "babel/babel",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "dependencies": {

sebmck-bjs.nfo

@@ -0,0 +1,48 @@
+
+                          ======                             ==========M=
+                     =============        ==    ======O=   ======= MM  ==
+                   M==+===      ==M      ===  ====     ==  ===        ==
+                  =D  ===      ===      ====MM ==M    ==M ==M        ===
+                     ===M    ====M     ====    =D   ===M ===   ===   ==
+                     ==7   ====M     ==M ==   ========  =========M  ==M
+                    ===========     ======M  ===MMM === ==M         ==
+                   =======MM==========MM==  ==M     ==M===         ==
+                   ==M       === M==   ==M  ==    === ===          =D        =
+                  ==M      ===+  ==    ==  ==  ==$M   =========== ============M
+                 ===     ====M  ==    ==M ===M==     ====?MMMM       M M
+                 ==   =====   ==M     == ==MM         M
+                ==M===M=M     =M     =MM  M           M
+               ==MM=M                ==
+              MMM                   =M
+               M
+
+                              > ú B ú A ú B ú E ú L ú <
+    ÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÑÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͸
+    ³ SOFTWARE .. : JavaScript Compiler  ³ COMPANY ... : N/A                     ³
+    ³ SUPPLIER .. : N/A                  ³ CRACKER ... : Sebastian McKenzie      ³
+    ³ RATING .... : depends..            ³ PACKAGER .. : Sebastian McKenzie      ³
+    ³ ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ ³
+    ³ GRAFIX .... : -                    ³ SOUND ..... : -                       ³
+    ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+     Babel is a JavaScript compiler and transformation platform for writing NeXt
+     GeNeRaTiOn JavaScript.
+
+     ÆÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍ͵
+     ³                                :: Greets ::                              ³
+     ³                                                                          ³
+     ³  sebmck, thejameskyle, RReverser, zloirock, monsanto, gaearon, zertosh,  ³
+     ³  stefanpenner, eventualbuddha, AluisioASG, Apoxx, Couto, dominicbarnes,  ³
+     ³    es128, gordonkristan, hkjels, jmeas, josh, loganfsmyth, nightire,     ³
+     ³           Rich-Harris, shinnn, shuhei, sindresorhus, tricknotes          ³
+     ³                                                                          ³
+     ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+                  -*- JavaScripts for all , All for JavaScripts ! -*-
+
+    ÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͸
+    ³  If you want to Contact us, call 555-720-4228, Use the Handle "BABEL"  w/  ³
+    ³  password : VISITOR and leave a mail to Sebastian or James.                ³
+    ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+                               -=- We LoVe fun Too! -=-

src/acorn/index.js

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

src/acorn/plugins/flow.js

@@ -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")
@@ -410,6 +415,9 @@ pp.flow_identToTypeAnnotation = function (start, node, id) {
     case "boolean":
       return this.finishNode(node, "BooleanTypeAnnotation")
 
+    case "mixed":
+      return this.finishNode(node, "MixedTypeAnnotation")
+
     case "number":
       return this.finishNode(node, "NumberTypeAnnotation")
 

src/acorn/plugins/jsx.js

@@ -1,658 +0,0 @@
-var acorn = require("../src/index")
-
-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

@@ -214,7 +214,12 @@ pp.parseExprSubscripts = function(refShorthandDefaultPos) {
 }
 
 pp.parseSubscripts = function(base, start, noCalls) {
-  if (this.eat(tt.dot)) {
+  if (!noCalls && this.eat(tt.doubleColon)) {
+    let node = this.startNodeAt(start)
+    node.object = base
+    node.callee = this.parseNoCallExpr()
+    return this.parseSubscripts(this.finishNode(node, "BindExpression"), start, noCalls)
+  } else if (this.eat(tt.dot)) {
     let node = this.startNodeAt(start)
     node.object = base
     node.property = this.parseIdent(true)
@@ -240,6 +245,13 @@ pp.parseSubscripts = function(base, start, noCalls) {
   } return base
 }
 
+// Parse a no-call expression (like argument of `new` or `::` operators).
+
+pp.parseNoCallExpr = function() {
+  let start = this.markPosition()
+  return this.parseSubscripts(this.parseExprAtom(), start, true)
+}
+
 // Parse an atomic expression — either a single token that is an
 // expression, an expression started by a keyword like `function` or
 // `new`, or an expression wrapped in punctuation like `()`, `[]`,
@@ -262,7 +274,13 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
     if (this.options.features["es7.doExpressions"]) {
       let node = this.startNode()
       this.next()
+      var oldInFunction = this.inFunction
+      var oldLabels = this.labels
+      this.labels = []
+      this.inFunction = false
       node.body = this.parseBlock()
+      this.inFunction = oldInFunction
+      this.labels = oldLabels
       return this.finishNode(node, "DoExpression")
     }
 
@@ -363,6 +381,15 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
   case tt.backQuote:
     return this.parseTemplate()
 
+  case tt.doubleColon:
+    node = this.startNode()
+    this.next()
+    node.object = null
+    let callee = node.callee = this.parseNoCallExpr()
+    if (callee.type !== "MemberExpression")
+      this.raise(callee.start, "Binding should be performed on object property.")
+    return this.finishNode(node, "BindExpression")
+
   default:
     this.unexpected()
   }
@@ -472,9 +499,11 @@ pp.parseNew = function() {
       this.raise(node.property.start, "The only valid meta property for new is new.target")
     return this.finishNode(node, "MetaProperty")
   }
-  let start = this.markPosition()
-  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true)
-  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false)
+  node.callee = this.parseNoCallExpr()
+  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")
 }
@@ -484,7 +513,7 @@ pp.parseNew = function() {
 pp.parseTemplateElement = function() {
   let elem = this.startNode()
   elem.value = {
-    raw: this.input.slice(this.start, this.end),
+    raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, '\n'),
     cooked: this.value
   }
   this.next()
@@ -632,7 +661,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/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/statement.js

@@ -168,12 +168,6 @@ pp.parseDoStatement = function(node) {
   this.labels.push(loopLabel)
   node.body = this.parseStatement(false)
   this.labels.pop()
-  if (this.options.features["es7.doExpressions"] && this.type !== tt._while) {
-    let container = this.startNodeAt(start)
-    container.expression = this.finishNode(node, "DoExpression")
-    this.semicolon()
-    return this.finishNode(container, "ExpressionStatement")
-  }
   this.expect(tt._while)
   node.test = this.parseParenExpression()
   if (this.options.ecmaVersion >= 6)
@@ -504,7 +498,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
@@ -574,7 +568,7 @@ pp.parseExport = function(node) {
       this.parseExportFrom(node)
       return this.finishNode(node, "ExportAllDeclaration")
     }
-  } else if (this.isExportDefaultSpecifier()) {
+  } else if (this.options.features["es7.exportExtensions"] && this.isExportDefaultSpecifier()) {
     let specifier = this.startNode()
     specifier.exported = this.parseIdent(true)
     node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]

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()
@@ -320,7 +320,13 @@ pp.getTokenFromCode = function(code) {
   case 93: ++this.pos; return this.finishToken(tt.bracketR)
   case 123: ++this.pos; return this.finishToken(tt.braceL)
   case 125: ++this.pos; return this.finishToken(tt.braceR)
-  case 58: ++this.pos; return this.finishToken(tt.colon)
+
+  case 58:
+    if (this.options.features["es7.functionBind"] && this.input.charCodeAt(this.pos + 1) === 58)
+      return this.finishOp(tt.doubleColon, 2)
+    ++this.pos
+    return this.finishToken(tt.colon)
+
   case 63: ++this.pos; return this.finishToken(tt.question)
   case 64: ++this.pos; return this.finishToken(tt.at)
 
@@ -571,11 +577,15 @@ pp.readTmplToken = function() {
     } else if (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)
+      switch (ch) {
+        case 13:
+          if (this.input.charCodeAt(this.pos) === 10) ++this.pos;
+        case 10:
+          out += "\n";
+          break;
+        default:
+          out += String.fromCharCode(ch);
+          break;
       }
       if (this.options.locations) {
         ++this.curLine

src/acorn/src/tokentype.js

@@ -54,6 +54,7 @@ export const types = {
   comma: new TokenType(",", beforeExpr),
   semi: new TokenType(";", beforeExpr),
   colon: new TokenType(":", beforeExpr),
+  doubleColon: new TokenType("::", beforeExpr),
   dot: new TokenType("."),
   question: new TokenType("?", beforeExpr),
   arrow: new TokenType("=>", beforeExpr),

src/babel/api/browser.js

@@ -1,3 +1,5 @@
+/* eslint no-new-func: 0 */
+
 require("./node");
 var transform = module.exports = require("../transformation");
 

src/babel/api/node.js

@@ -10,7 +10,7 @@ export { canCompile } from "../util";
 
 export { default as options } from "../transformation/file/options";
 export { default as Transformer } from "../transformation/transformer";
-export { default as Pipeline } from "../transformation/transformer-pipeline";
+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";
@@ -53,19 +53,20 @@ 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 = {
-    flow: true,
-    jsx:  true
+    jsx:  true,
+    flow: true
   };
   opts.features = {};
 
-  for (var key in transform.transformers) {
+  for (var key in transform.pipeline.transformers) {
     opts.features[key] = true;
   }
 

src/babel/api/register/browser.js

@@ -1,5 +1,5 @@
 // required to safely use babel/register within a browserify codebase
 
-export default function () {};
+export default function () {}
 
 import "../../polyfill";

src/babel/api/register/cache.js

@@ -1,9 +1,8 @@
 import path from "path";
-import os from "os";
 import fs from "fs";
-import userHome from "user-home";
+import homeOrTmp from "home-or-tmp";
 
-const FILENAME = process.env.BABEL_CACHE_PATH || path.join(userHome || os.tmpdir(), ".babel.json");
+const FILENAME = process.env.BABEL_CACHE_PATH || path.join(homeOrTmp, ".babel.json");
 var data = {};
 
 export function save() {

src/babel/api/register/node.js

@@ -6,7 +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";
+import path from "path";
 
 sourceMapSupport.install({
   handleUncaughtExceptions: false,
@@ -38,14 +38,20 @@ var only;
 var oldHandlers   = {};
 var maps          = {};
 
+var cwd = process.cwd();
+
+var getRelativePath = function (filename){
+  return path.relative(cwd, filename);
+};
+
 var mtime = function (filename) {
   return +fs.statSync(filename).mtime;
 };
 
-var compile = function (filename) {
+var compile = function (filename, opts = {}) {
   var result;
 
-  var opts = extend({}, transformOpts);
+  opts = extend(opts, transformOpts);
 
   // this will be done when the file is transformed anyway but we need all
   // the options so we can generate the cache key
@@ -53,6 +59,9 @@ var compile = function (filename) {
 
   var cacheKey = `${filename}:${JSON.stringify(opts)}:${babel.version}`;
 
+  var env = process.env.BABEL_ENV || process.env.NODE_ENV;
+  if (env) cacheKey += `:${env}`;
+
   if (cache) {
     var cached = cache[cacheKey];
     if (cached && cached.mtime === mtime(filename)) {
@@ -79,7 +88,7 @@ var compile = function (filename) {
 
 var shouldIgnore = function (filename) {
   if (!ignore && !only) {
-    return /node_modules/.test(filename);
+    return getRelativePath(filename).split(path.sep).indexOf("node_modules") >= 0;
   } else {
     return util.shouldIgnore(filename, ignore || [], only || []);
   }
@@ -87,7 +96,7 @@ var shouldIgnore = function (filename) {
 
 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;
@@ -95,7 +104,9 @@ if (process.env.running_under_istanbul) { // jshint ignore:line
   fs.readFileSync = function (filename) {
     if (istanbulMonkey[filename]) {
       delete istanbulMonkey[filename];
-      var code = compile(filename);
+      var code = compile(filename, {
+        attachAuxiliaryComment: "istanbul ignore next"
+      });
       istanbulMonkey[filename] = true;
       return code;
     } else {
@@ -117,7 +128,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)) {
@@ -161,4 +172,4 @@ export default function (opts = {}) {
   delete opts.only;
 
   extend(transformOpts, opts);
-};
+}

src/babel/generation/buffer.js

@@ -117,8 +117,9 @@ export default class Buffer {
 
   _removeSpacesAfterLastNewline() {
     var lastNewlineIndex = this.buf.lastIndexOf("\n");
-    if (lastNewlineIndex === -1)
+    if (lastNewlineIndex === -1) {
       return;
+    }
 
     var index = this.buf.length - 1;
     while (index > lastNewlineIndex) {

src/babel/generation/generators/base.js

@@ -1,5 +1,5 @@
 export function File(node, print) {
-  print(node.program);
+  print.plain(node.program);
 }
 
 export function Program(node, print) {

src/babel/generation/generators/classes.js

@@ -3,16 +3,16 @@ export function ClassDeclaration(node, print) {
   this.push("class");
 
   if (node.id) {
-    this.space();
-    print(node.id);
+    this.push(" ");
+    print.plain(node.id);
   }
 
-  print(node.typeParameters);
+  print.plain(node.typeParameters);
 
   if (node.superClass) {
     this.push(" extends ");
-    print(node.superClass);
-    print(node.superTypeParameters);
+    print.plain(node.superClass);
+    print.plain(node.superTypeParameters);
   }
 
   if (node.implements) {
@@ -21,7 +21,7 @@ export function ClassDeclaration(node, print) {
   }
 
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
 export { ClassDeclaration as ClassExpression };
@@ -46,13 +46,13 @@ export function ClassProperty(node, print) {
   print.list(node.decorators);
 
   if (node.static) this.push("static ");
-  print(node.key);
-  print(node.typeAnnotation);
+  print.plain(node.key);
+  print.plain(node.typeAnnotation);
   if (node.value) {
     this.space();
     this.push("=");
     this.space();
-    print(node.value);
+    print.plain(node.value);
   }
   this.semicolon();
 }

src/babel/generation/generators/comprehensions.js

@@ -1,9 +1,9 @@
 export function ComprehensionBlock(node, print) {
   this.keyword("for");
   this.push("(");
-  print(node.left);
+  print.plain(node.left);
   this.push(" of ");
-  print(node.right);
+  print.plain(node.right);
   this.push(")");
 }
 
@@ -16,12 +16,12 @@ export function ComprehensionExpression(node, print) {
   if (node.filter) {
     this.keyword("if");
     this.push("(");
-    print(node.filter);
+    print.plain(node.filter);
     this.push(")");
     this.space();
   }
 
-  print(node.body);
+  print.plain(node.body);
 
   this.push(node.generator ? ")" : "]");
 }

src/babel/generation/generators/expressions.js

@@ -16,40 +16,40 @@ export function UnaryExpression(node, print) {
 
   this.push(node.operator);
   if (hasSpace) this.push(" ");
-  print(node.argument);
+  print.plain(node.argument);
 }
 
 export function DoExpression(node, print) {
   this.push("do");
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
 export function UpdateExpression(node, print) {
   if (node.prefix) {
     this.push(node.operator);
-    print(node.argument);
+    print.plain(node.argument);
   } else {
-    print(node.argument);
+    print.plain(node.argument);
     this.push(node.operator);
   }
 }
 
 export function ConditionalExpression(node, print) {
-  print(node.test);
+  print.plain(node.test);
   this.space();
   this.push("?");
   this.space();
-  print(node.consequent);
+  print.plain(node.consequent);
   this.space();
   this.push(":");
   this.space();
-  print(node.alternate);
+  print.plain(node.alternate);
 }
 
 export function NewExpression(node, print) {
   this.push("new ");
-  print(node.callee);
+  print.plain(node.callee);
   this.push("(");
   print.list(node.arguments);
   this.push(")");
@@ -69,17 +69,19 @@ export function Super() {
 
 export function Decorator(node, print) {
   this.push("@");
-  print(node.expression);
+  print.plain(node.expression);
 }
 
 export function CallExpression(node, print) {
-  print(node.callee);
+  print.plain(node.callee);
 
   this.push("(");
 
   var separator = ",";
 
-  if (node._prettyCall) {
+  var isPrettyCall = node._prettyCall && !this.format.retainLines;
+
+  if (isPrettyCall) {
     separator += "\n";
     this.newline();
     this.indent();
@@ -89,7 +91,7 @@ export function CallExpression(node, print) {
 
   print.list(node.arguments, { separator: separator });
 
-  if (node._prettyCall) {
+  if (isPrettyCall) {
     this.newline();
     this.dedent();
   }
@@ -106,8 +108,8 @@ var buildYieldAwait = function (keyword) {
     }
 
     if (node.argument) {
-      this.space();
-      print(node.argument);
+      this.push(" ");
+      print.plain(node.argument);
     }
   };
 };
@@ -120,17 +122,23 @@ export function EmptyStatement() {
 }
 
 export function ExpressionStatement(node, print) {
-  print(node.expression);
+  print.plain(node.expression);
   this.semicolon();
 }
 
 export function AssignmentExpression(node, print) {
   // todo: add cases where the spaces can be dropped when in compact mode
-  print(node.left);
+  print.plain(node.left);
   this.push(" ");
   this.push(node.operator);
   this.push(" ");
-  print(node.right);
+  print.plain(node.right);
+}
+
+export function BindExpression(node, print) {
+  print.plain(node.object);
+  this.push("::");
+  print.plain(node.callee);
 }
 
 export {
@@ -143,7 +151,7 @@ var SCIENTIFIC_NOTATION = /e/i;
 
 export function MemberExpression(node, print) {
   var obj = node.object;
-  print(obj);
+  print.plain(obj);
 
   if (!node.computed && t.isMemberExpression(node.property)) {
     throw new TypeError("Got a MemberExpression for MemberExpression property");
@@ -156,7 +164,7 @@ export function MemberExpression(node, print) {
 
   if (computed) {
     this.push("[");
-    print(node.property);
+    print.plain(node.property);
     this.push("]");
   } else {
     // 5..toFixed(2);
@@ -165,12 +173,12 @@ export function MemberExpression(node, print) {
     }
 
     this.push(".");
-    print(node.property);
+    print.plain(node.property);
   }
 }
 
 export function MetaProperty(node, print) {
-  print(node.meta);
+  print.plain(node.meta);
   this.push(".");
-  print(node.property);
+  print.plain(node.property);
 }

src/babel/generation/generators/flow.js

@@ -5,7 +5,7 @@ export function AnyTypeAnnotation() {
 }
 
 export function ArrayTypeAnnotation(node, print) {
-  print(node.elementType);
+  print.plain(node.elementType);
   this.push("[");
   this.push("]");
 }
@@ -21,27 +21,27 @@ export function DeclareClass(node, print) {
 
 export function DeclareFunction(node, print) {
   this.push("declare function ");
-  print(node.id);
-  print(node.id.typeAnnotation.typeAnnotation);
+  print.plain(node.id);
+  print.plain(node.id.typeAnnotation.typeAnnotation);
   this.semicolon();
 }
 
 export function DeclareModule(node, print) {
   this.push("declare module ");
-  print(node.id);
+  print.plain(node.id);
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
 export function DeclareVariable(node, print) {
   this.push("declare var ");
-  print(node.id);
-  print(node.id.typeAnnotation);
+  print.plain(node.id);
+  print.plain(node.id.typeAnnotation);
   this.semicolon();
 }
 
 export function FunctionTypeAnnotation(node, print, parent) {
-  print(node.typeParameters);
+  print.plain(node.typeParameters);
   this.push("(");
   print.list(node.params);
 
@@ -51,7 +51,7 @@ export function FunctionTypeAnnotation(node, print, parent) {
       this.space();
     }
     this.push("...");
-    print(node.rest);
+    print.plain(node.rest);
   }
 
   this.push(")");
@@ -65,33 +65,33 @@ export function FunctionTypeAnnotation(node, print, parent) {
   }
 
   this.space();
-  print(node.returnType);
+  print.plain(node.returnType);
 }
 
 export function FunctionTypeParam(node, print) {
-  print(node.name);
+  print.plain(node.name);
   if (node.optional) this.push("?");
   this.push(":");
   this.space();
-  print(node.typeAnnotation);
+  print.plain(node.typeAnnotation);
 }
 
 export function InterfaceExtends(node, print) {
-  print(node.id);
-  print(node.typeParameters);
+  print.plain(node.id);
+  print.plain(node.typeParameters);
 }
 
 export { InterfaceExtends as ClassImplements, InterfaceExtends as GenericTypeAnnotation };
 
 export function _interfaceish(node, print) {
-  print(node.id);
-  print(node.typeParameters);
+  print.plain(node.id);
+  print.plain(node.typeParameters);
   if (node.extends.length) {
     this.push(" extends ");
     print.join(node.extends, { separator: ", " });
   }
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
 export function InterfaceDeclaration(node, print) {
@@ -103,9 +103,13 @@ export function IntersectionTypeAnnotation(node, print) {
   print.join(node.types, { separator: " & " });
 }
 
+export function MixedTypeAnnotation() {
+  this.push("mixed");
+}
+
 export function NullableTypeAnnotation(node, print) {
   this.push("?");
-  print(node.typeAnnotation);
+  print.plain(node.typeAnnotation);
 }
 
 export function NumberTypeAnnotation() {
@@ -128,17 +132,17 @@ export function TupleTypeAnnotation(node, print) {
 
 export function TypeofTypeAnnotation(node, print) {
   this.push("typeof ");
-  print(node.argument);
+  print.plain(node.argument);
 }
 
 export function TypeAlias(node, print) {
   this.push("type ");
-  print(node.id);
-  print(node.typeParameters);
+  print.plain(node.id);
+  print.plain(node.typeParameters);
   this.space();
   this.push("=");
   this.space();
-  print(node.right);
+  print.plain(node.right);
   this.semicolon();
 }
 
@@ -146,7 +150,7 @@ export function TypeAnnotation(node, print) {
   this.push(":");
   this.space();
   if (node.optional) this.push("?");
-  print(node.typeAnnotation);
+  print.plain(node.typeAnnotation);
 }
 
 export function TypeParameterInstantiation(node, print) {
@@ -183,37 +187,37 @@ export function ObjectTypeAnnotation(node, print) {
 
 export function ObjectTypeCallProperty(node, print) {
   if (node.static) this.push("static ");
-  print(node.value);
+  print.plain(node.value);
 }
 
 export function ObjectTypeIndexer(node, print) {
   if (node.static) this.push("static ");
   this.push("[");
-  print(node.id);
+  print.plain(node.id);
   this.push(":");
   this.space();
-  print(node.key);
+  print.plain(node.key);
   this.push("]");
   this.push(":");
   this.space();
-  print(node.value);
+  print.plain(node.value);
 }
 
 export function ObjectTypeProperty(node, print) {
   if (node.static) this.push("static ");
-  print(node.key);
+  print.plain(node.key);
   if (node.optional) this.push("?");
   if (!t.isFunctionTypeAnnotation(node.value)) {
     this.push(":");
     this.space();
   }
-  print(node.value);
+  print.plain(node.value);
 }
 
 export function QualifiedTypeIdentifier(node, print) {
-  print(node.qualification);
+  print.plain(node.qualification);
   this.push(".");
-  print(node.id);
+  print.plain(node.id);
 }
 
 export function UnionTypeAnnotation(node, print) {
@@ -222,8 +226,8 @@ export function UnionTypeAnnotation(node, print) {
 
 export function TypeCastExpression(node, print) {
   this.push("(");
-  print(node.expression);
-  print(node.typeAnnotation);
+  print.plain(node.expression);
+  print.plain(node.typeAnnotation);
   this.push(")");
 }
 

src/babel/generation/generators/jsx.js

@@ -1,11 +1,10 @@
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
 export function JSXAttribute(node, print) {
-  print(node.name);
+  print.plain(node.name);
   if (node.value) {
     this.push("=");
-    print(node.value);
+    print.plain(node.value);
   }
 }
 
@@ -14,50 +13,50 @@ export function JSXIdentifier(node) {
 }
 
 export function JSXNamespacedName(node, print) {
-  print(node.namespace);
+  print.plain(node.namespace);
   this.push(":");
-  print(node.name);
+  print.plain(node.name);
 }
 
 export function JSXMemberExpression(node, print) {
-  print(node.object);
+  print.plain(node.object);
   this.push(".");
-  print(node.property);
+  print.plain(node.property);
 }
 
 export function JSXSpreadAttribute(node, print) {
   this.push("{...");
-  print(node.argument);
+  print.plain(node.argument);
   this.push("}");
 }
 
 export function JSXExpressionContainer(node, print) {
   this.push("{");
-  print(node.expression);
+  print.plain(node.expression);
   this.push("}");
 }
 
 export function JSXElement(node, print) {
   var open = node.openingElement;
-  print(open);
+  print.plain(open);
   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, true);
     } else {
-      print(child);
+      print.plain(child);
     }
-  });
+  }
   this.dedent();
 
-  print(node.closingElement);
+  print.plain(node.closingElement);
 }
 
 export function JSXOpeningElement(node, print) {
   this.push("<");
-  print(node.name);
+  print.plain(node.name);
   if (node.attributes.length > 0) {
     this.push(" ");
     print.join(node.attributes, { separator: " " });
@@ -67,7 +66,7 @@ export function JSXOpeningElement(node, print) {
 
 export function JSXClosingElement(node, print) {
   this.push("</");
-  print(node.name);
+  print.plain(node.name);
   this.push(">");
 }
 

src/babel/generation/generators/methods.js

@@ -1,18 +1,18 @@
 import * as t from "../../types";
 
 export function _params(node, print) {
-  print(node.typeParameters);
+  print.plain(node.typeParameters);
   this.push("(");
   print.list(node.params, {
     iterator: (node) =>{
       if (node.optional) this.push("?");
-      print(node.typeAnnotation);
+      print.plain(node.typeAnnotation);
     }
   });
   this.push(")");
 
   if (node.returnType) {
-    print(node.returnType);
+    print.plain(node.returnType);
   }
 }
 
@@ -35,15 +35,15 @@ export function _method(node, print) {
 
   if (node.computed) {
     this.push("[");
-    print(key);
+    print.plain(key);
     this.push("]");
   } else {
-    print(key);
+    print.plain(key);
   }
 
   this._params(value, print);
   this.push(" ");
-  print(value.body);
+  print.plain(value.body);
 }
 
 export function FunctionExpression(node, print) {
@@ -53,14 +53,14 @@ export function FunctionExpression(node, print) {
 
   if (node.id) {
     this.push(" ");
-    print(node.id);
+    print.plain(node.id);
   } else {
     this.space();
   }
 
   this._params(node, print);
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
 export { FunctionExpression as FunctionDeclaration };
@@ -69,7 +69,7 @@ export function ArrowFunctionExpression(node, print) {
   if (node.async) this.push("async ");
 
   if (node.params.length === 1 && t.isIdentifier(node.params[0])) {
-    print(node.params[0]);
+    print.plain(node.params[0]);
   } else {
     this._params(node, print);
   }
@@ -82,7 +82,7 @@ export function ArrowFunctionExpression(node, print) {
     this.push("(");
   }
 
-  print(node.body);
+  print.plain(node.body);
 
   if (bodyNeedsParens) {
     this.push(")");

src/babel/generation/generators/modules.js

@@ -1,43 +1,42 @@
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
 export function ImportSpecifier(node, print) {
-  print(node.imported);
-  if (node.local && node.local !== node.imported) {
+  print.plain(node.imported);
+  if (node.local && node.local.name !== node.imported.name) {
     this.push(" as ");
-    print(node.local);
+    print.plain(node.local);
   }
 }
 
 export function ImportDefaultSpecifier(node, print) {
-  print(node.local);
+  print.plain(node.local);
 }
 
 export function ExportDefaultSpecifier(node, print) {
-  print(node.exported);
+  print.plain(node.exported);
 }
 
 export function ExportSpecifier(node, print) {
-  print(node.local);
-  if (node.exported && node.local !== node.exported) {
+  print.plain(node.local);
+  if (node.exported && node.local.name !== node.exported.name) {
     this.push(" as ");
-    print(node.exported);
+    print.plain(node.exported);
   }
 }
 
 export function ExportNamespaceSpecifier(node, print) {
   this.push("* as ");
-  print(node.exported);
+  print.plain(node.exported);
 }
 
 export function ExportAllDeclaration(node, print) {
   this.push("export *");
   if (node.exported) {
     this.push(" as ");
-    print(node.exported);
+    print.plain(node.exported);
   }
   this.push(" from ");
-  print(node.source);
+  print.plain(node.source);
   this.semicolon();
 }
 
@@ -56,14 +55,14 @@ function ExportDeclaration(node, print) {
 
   if (node.declaration) {
     var declar = node.declaration;
-    print(declar);
+    print.plain(declar);
     if (t.isStatement(declar) || t.isFunction(declar) || t.isClass(declar)) return;
   } else {
     var first = specifiers[0];
     var hasSpecial = false;
     if (t.isExportDefaultSpecifier(first) || t.isExportNamespaceSpecifier(first)) {
       hasSpecial = true;
-      print(specifiers.shift());
+      print.plain(specifiers.shift());
       if (specifiers.length) {
         this.push(", ");
       }
@@ -81,7 +80,7 @@ function ExportDeclaration(node, print) {
 
     if (node.source) {
       this.push(" from ");
-      print(node.source);
+      print.plain(node.source);
     }
   }
 
@@ -99,7 +98,7 @@ export function ImportDeclaration(node, print) {
   if (specfiers && specfiers.length) {
     var first = node.specifiers[0];
     if (t.isImportDefaultSpecifier(first) || t.isImportNamespaceSpecifier(first)) {
-      print(node.specifiers.shift());
+      print.plain(node.specifiers.shift());
       if (node.specifiers.length) {
         this.push(", ");
       }
@@ -107,20 +106,20 @@ export function ImportDeclaration(node, print) {
 
     if (node.specifiers.length) {
       this.push("{");
-      this.space()
+      this.space();
       print.join(node.specifiers, { separator: ", " });
-      this.space()
+      this.space();
       this.push("}");
     }
 
     this.push(" from ");
   }
 
-  print(node.source);
+  print.plain(node.source);
   this.semicolon();
 }
 
 export function ImportNamespaceSpecifier(node, print) {
   this.push("* as ");
-  print(node.local);
+  print.plain(node.local);
 }

src/babel/generation/generators/statements.js

@@ -4,7 +4,7 @@ import * as t from "../../types";
 export function WithStatement(node, print) {
   this.keyword("with");
   this.push("(");
-  print(node.object);
+  print.plain(node.object);
   this.push(")");
   print.block(node.body);
 }
@@ -12,7 +12,7 @@ export function WithStatement(node, print) {
 export function IfStatement(node, print) {
   this.keyword("if");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(")");
   this.space();
 
@@ -29,18 +29,18 @@ export function ForStatement(node, print) {
   this.keyword("for");
   this.push("(");
 
-  print(node.init);
+  print.plain(node.init);
   this.push(";");
 
   if (node.test) {
     this.push(" ");
-    print(node.test);
+    print.plain(node.test);
   }
   this.push(";");
 
   if (node.update) {
     this.push(" ");
-    print(node.update);
+    print.plain(node.update);
   }
 
   this.push(")");
@@ -50,7 +50,7 @@ export function ForStatement(node, print) {
 export function WhileStatement(node, print) {
   this.keyword("while");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(")");
   print.block(node.body);
 }
@@ -59,9 +59,9 @@ var buildForXStatement = function (op) {
   return function (node, print) {
     this.keyword("for");
     this.push("(");
-    print(node.left);
+    print.plain(node.left);
     this.push(` ${op} `);
-    print(node.right);
+    print.plain(node.right);
     this.push(")");
     print.block(node.body);
   };
@@ -72,11 +72,11 @@ export var ForOfStatement = buildForXStatement("of");
 
 export function DoWhileStatement(node, print) {
   this.push("do ");
-  print(node.body);
+  print.plain(node.body);
   this.space();
   this.keyword("while");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(");");
 }
 
@@ -87,7 +87,7 @@ var buildLabelStatement = function (prefix, key) {
     var label = node[key || "label"];
     if (label) {
       this.push(" ");
-      print(label);
+      print.plain(label);
     }
 
     this.semicolon();
@@ -99,50 +99,50 @@ export var ReturnStatement   = buildLabelStatement("return", "argument");
 export var BreakStatement    = buildLabelStatement("break");
 
 export function LabeledStatement(node, print) {
-  print(node.label);
+  print.plain(node.label);
   this.push(": ");
-  print(node.body);
+  print.plain(node.body);
 }
 
 export function TryStatement(node, print) {
   this.keyword("try");
-  print(node.block);
+  print.plain(node.block);
   this.space();
 
   // Esprima bug puts the catch clause in a `handlers` array.
   // see https://code.google.com/p/esprima/issues/detail?id=433
   // We run into this from regenerator generated ast.
   if (node.handlers) {
-    print(node.handlers[0]);
+    print.plain(node.handlers[0]);
   } else {
-    print(node.handler);
+    print.plain(node.handler);
   }
 
   if (node.finalizer) {
     this.space();
     this.push("finally ");
-    print(node.finalizer);
+    print.plain(node.finalizer);
   }
 }
 
 export function CatchClause(node, print) {
   this.keyword("catch");
   this.push("(");
-  print(node.param);
+  print.plain(node.param);
   this.push(") ");
-  print(node.body);
+  print.plain(node.body);
 }
 
 export function ThrowStatement(node, print) {
   this.push("throw ");
-  print(node.argument);
+  print.plain(node.argument);
   this.semicolon();
 }
 
 export function SwitchStatement(node, print) {
   this.keyword("switch");
   this.push("(");
-  print(node.discriminant);
+  print.plain(node.discriminant);
   this.push(")");
   this.space();
   this.push("{");
@@ -160,7 +160,7 @@ export function SwitchStatement(node, print) {
 export function SwitchCase(node, print) {
   if (node.test) {
     this.push("case ");
-    print(node.test);
+    print.plain(node.test);
     this.push(":");
   } else {
     this.push("default:");
@@ -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 += " ";
@@ -207,12 +207,12 @@ export function VariableDeclaration(node, print, parent) {
 }
 
 export function VariableDeclarator(node, print) {
-  print(node.id);
-  print(node.id.typeAnnotation);
+  print.plain(node.id);
+  print.plain(node.id.typeAnnotation);
   if (node.init) {
     this.space();
     this.push("=");
     this.space();
-    print(node.init);
+    print.plain(node.init);
   }
 }

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

@@ -1,8 +1,6 @@
-import each from "lodash/collection/each";
-
 export function TaggedTemplateExpression(node, print) {
-  print(node.tag);
-  print(node.quasi);
+  print.plain(node.tag);
+  print.plain(node.quasi);
 }
 
 export function TemplateElement(node) {
@@ -15,15 +13,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.plain(quasis[i]);
 
     if (i + 1 < len) {
       this.push("${ ");
-      print(node.expressions[i]);
+      print.plain(node.expressions[i]);
       this.push(" }");
     }
-  });
+  }
 
   this._push("`");
 }

src/babel/generation/generators/types.js

@@ -1,4 +1,6 @@
-import each from "lodash/collection/each";
+/* eslint quotes: 0 */
+
+import * as t from "../../types";
 
 export function Identifier(node) {
   this.push(node.name);
@@ -6,7 +8,7 @@ export function Identifier(node) {
 
 export function RestElement(node, print) {
   this.push("...");
-  print(node.argument);
+  print.plain(node.argument);
 }
 
 export { RestElement as SpreadElement, RestElement as SpreadProperty };
@@ -35,16 +37,29 @@ export function Property(node, print) {
   } else {
     if (node.computed) {
       this.push("[");
-      print(node.key);
+      print.plain(node.key);
       this.push("]");
     } else {
-      print(node.key);
-      if (node.shorthand) return;
+      // print `({ foo: foo = 5 } = {})` as `({ foo = 5 } = {});`
+      if (t.isAssignmentPattern(node.value) && t.isIdentifier(node.key) && node.key.name === node.value.left.name) {
+        print.plain(node.value);
+        return;
+      }
+
+      print.plain(node.key);
+
+      // shorthand!
+      if (node.shorthand &&
+        (t.isIdentifier(node.key) &&
+         t.isIdentifier(node.value) &&
+         node.key.name === node.value.name)) {
+        return;
+      }
     }
 
     this.push(":");
     this.space();
-    print(node.value);
+    print.plain(node.value);
   }
 }
 
@@ -54,7 +69,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
@@ -64,10 +80,10 @@ export function ArrayExpression(node, print) {
       this.push(",");
     } else {
       if (i > 0) this.push(" ");
-      print(elem);
+      print.plain(elem);
       if (i < len - 1) this.push(",");
     }
-  });
+  }
 
   this.push("]");
 }

src/babel/generation/index.js

@@ -1,5 +1,6 @@
 import detectIndent from "detect-indent";
 import Whitespace from "./whitespace";
+import NodePrinter from "./node/printer";
 import repeating from "repeating";
 import SourceMap from "./source-map";
 import Position from "./position";
@@ -20,7 +21,7 @@ class CodeGenerator {
     this.opts     = opts;
     this.ast      = ast;
 
-    this.whitespace = new Whitespace(this.tokens, this.comments, this.format);
+    this.whitespace = new Whitespace(this.tokens);
     this.position   = new Position;
     this.map        = new SourceMap(this.position, opts, code);
     this.buffer     = new Buffer(this.position, this.format);
@@ -67,7 +68,6 @@ class CodeGenerator {
     for (var i = 0; i < tokens.length; i++) {
       var token = tokens[i];
       if (token.type.label !== "string") continue;
-      if (checked >= 3) continue;
 
       var raw = code.slice(token.start, token.end);
       if (raw[0] === "'") {
@@ -77,6 +77,7 @@ class CodeGenerator {
       }
 
       checked++;
+      if (checked >= 3) break;
     }
 
     if (occurences.single > occurences.double) {
@@ -105,11 +106,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(),
@@ -118,40 +121,15 @@ class CodeGenerator {
   }
 
   buildPrint(parent) {
-    var print = (node, opts) => {
-      return this.print(node, parent, opts);
-    };
-
-    print.sequence = (nodes, opts = {}) => {
-      opts.statement = true;
-      return this.printJoin(print, nodes, opts);
-    };
-
-    print.join = (nodes, opts) => {
-      return this.printJoin(print, nodes, opts);
-    };
-
-    print.list = function (items, opts = {}) {
-      if (opts.separator == null) opts.separator = ", ";
-      print.join(items, opts);
-    };
-
-    print.block = (node) => {
-      return this.printBlock(print, node);
-    };
-
-    print.indentOnComments = (node) => {
-      return this.printAndIndentOnComments(print, node);
-    };
-
-    return print;
+    return new NodePrinter(this, parent);
   }
 
-  catchUp(node, parent) {
+  catchUp(node, parent, leftParenPrinted) {
     // 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)) {
+      if (!leftParenPrinted && parent &&
+          this.position.line < node.loc.start.line && t.isTerminatorless(parent)) {
         needsParens = true;
         this._push("(");
       }
@@ -163,6 +141,36 @@ class CodeGenerator {
     return false;
   }
 
+  _printNewline(leading, node, parent, opts) {
+    if (!opts.statement && !n.isUserWhitespacable(node, parent)) {
+      return;
+    }
+
+    var lines = 0;
+
+    if (node.start != null && !node._ignoreUserWhitespace) {
+      // user node
+      if (leading) {
+        lines = this.whitespace.getNewlinesBefore(node);
+      } else {
+        lines = this.whitespace.getNewlinesAfter(node);
+      }
+    } else {
+      // generated node
+      if (!leading) lines++; // always include at least a single line after
+      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
+
+      var needs = n.needsWhitespaceAfter;
+      if (leading) needs = n.needsWhitespaceBefore;
+      if (needs(node, parent)) lines++;
+
+      // generated nodes can't add starting file whitespace
+      if (!this.buffer.buf) lines = 0;
+    }
+
+    this.newline(lines);
+  }
+
   print(node, parent, opts = {}) {
     if (!node) return;
 
@@ -175,36 +183,6 @@ class CodeGenerator {
       this.format.concise = true;
     }
 
-    var newline = (leading) => {
-      if (!opts.statement && !n.isUserWhitespacable(node, parent)) {
-        return;
-      }
-
-      var lines = 0;
-
-      if (node.start != null && !node._ignoreUserWhitespace) {
-        // user node
-        if (leading) {
-          lines = this.whitespace.getNewlinesBefore(node);
-        } else {
-          lines = this.whitespace.getNewlinesAfter(node);
-        }
-      } else {
-        // generated node
-        if (!leading) lines++; // always include at least a single line after
-        if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
-
-        var needs = n.needsWhitespaceAfter;
-        if (leading) needs = n.needsWhitespaceBefore;
-        if (needs(node, parent)) lines++;
-
-        // generated nodes can't add starting file whitespace
-        if (!this.buffer.buf) lines = 0;
-      }
-
-      this.newline(lines);
-    };
-
     if (this[node.type]) {
       var needsNoLineTermParens = n.needsParensNoLineTerminator(node, parent);
       var needsParens           = needsNoLineTermParens || n.needsParens(node, parent);
@@ -214,9 +192,9 @@ class CodeGenerator {
 
       this.printLeadingComments(node, parent);
 
-      var needsParensFromCatchup = this.catchUp(node, parent);
+      var needsParensFromCatchup = this.catchUp(node, parent, needsParens);
 
-      newline(true);
+      this._printNewline(true, node, parent, opts);
 
       if (opts.before) opts.before();
       this.map.mark(node, "start");
@@ -232,14 +210,14 @@ class CodeGenerator {
       this.map.mark(node, "end");
       if (opts.after) opts.after();
 
-      newline(false);
+      this.format.concise = oldConcise;
+
+      this._printNewline(false, node, parent, opts);
 
       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 = {}) {
@@ -249,21 +227,24 @@ class CodeGenerator {
 
     if (opts.indent) this.indent();
 
-    each(nodes, (node, i) => {
-      print(node, {
-        statement: opts.statement,
-        addNewlines: opts.addNewlines,
-        after: () => {
-          if (opts.iterator) {
-            opts.iterator(node, i);
-          }
-
-          if (opts.separator && i < len - 1) {
-            this.push(opts.separator);
-          }
+    var printOpts = {
+      statement: opts.statement,
+      addNewlines: opts.addNewlines,
+      after: () => {
+        if (opts.iterator) {
+          opts.iterator(node, i);
         }
-      });
-    });
+
+        if (opts.separator && i < len - 1) {
+          this.push(opts.separator);
+        }
+      }
+    };
+
+    for (var i = 0; i < nodes.length; i++) {
+      var node = nodes[i];
+      print.plain(node, printOpts);
+    }
 
     if (opts.indent) this.dedent();
   }
@@ -271,7 +252,7 @@ class CodeGenerator {
   printAndIndentOnComments(print, node) {
     var indent = !!node.leadingComments;
     if (indent) this.indent();
-    print(node);
+    print.plain(node);
     if (indent) this.dedent();
   }
 
@@ -280,13 +261,13 @@ class CodeGenerator {
       this.semicolon();
     } else {
       this.push(" ");
-      print(node);
+      print.plain(node);
     }
   }
 
   generateComment(comment) {
     var val = comment.value;
-    if (comment.type === "Line") {
+    if (comment.type === "CommentLine") {
       val = `//${val}`;
     } else {
       val = `/*${val}*/`;
@@ -314,9 +295,9 @@ class CodeGenerator {
       nodes.push(node.argument);
     }
 
-    each(nodes, (node) => {
+    for (let node of (nodes: Array)) {
       comments = comments.concat(this._getComments(key, node));
-    });
+    }
 
     return comments;
   }
@@ -327,23 +308,24 @@ class CodeGenerator {
 
   _printComments(comments) {
     if (this.format.compact) return;
-
     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;
 
@@ -361,7 +343,7 @@ class CodeGenerator {
       }
 
       //
-      if (comment.type === "Block" && this.format.indent.adjustMultilineComment) {
+      if (comment.type === "CommentBlock" && this.format.indent.adjustMultilineComment) {
         var offset = comment.loc.start.column;
         if (offset) {
           var newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
@@ -378,7 +360,7 @@ class CodeGenerator {
 
       // 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") {
+      if (this.format.retainLines && comment.type === "CommentLine") {
         val += "\n";
       }
 
@@ -387,7 +369,7 @@ class CodeGenerator {
 
       // whitespace after
       this.newline(this.whitespace.getNewlinesAfter(comment));
-    });
+    }
   }
 }
 

src/babel/generation/node/printer.js

@@ -0,0 +1,32 @@
+export default class NodePrinter {
+  constructor(generator, parent) {
+    this.generator = generator;
+    this.parent = parent;
+  }
+
+  plain(node, opts) {
+    return this.generator.print(node, this.parent, opts);
+  }
+
+  sequence(nodes, opts = {}) {
+    opts.statement = true;
+    return this.generator.printJoin(this, nodes, opts);
+  }
+
+  join(nodes, opts) {
+    return this.generator.printJoin(this, nodes, opts);
+  }
+
+  list(items, opts = {}) {
+    if (opts.separator == null) opts.separator = ", ";
+    return this.join(items, opts);
+  }
+
+  block(node) {
+    return this.generator.printBlock(this, node);
+  }
+
+  indentOnComments(node) {
+    return this.generator.printAndIndentOnComments(this, node);
+  }
+}

src/babel/generation/source-map.js

@@ -8,7 +8,7 @@ export default class SourceMap {
 
     if (opts.sourceMaps) {
       this.map = new sourceMap.SourceMapGenerator({
-        file: opts.sourceMapName,
+        file: opts.sourceMapTarget,
         sourceRoot: opts.sourceRoot
       });
 

src/babel/generation/whitespace.js

@@ -1,5 +1,3 @@
-import sortBy from "lodash/collection/sortBy";
-
 /**
  * Returns `i`th number from `base`, continuing from 0 when `max` is reached.
  * Useful for shifting `for` loop by a fixed number but going over all items.
@@ -21,8 +19,8 @@ function getLookupIndex(i, base, max) {
 }
 
 export default class Whitespace {
-  constructor(tokens, comments) {
-    this.tokens = sortBy(tokens.concat(comments), "start");
+  constructor(tokens) {
+    this.tokens = tokens;
     this.used   = {};
 
     // Profiling this code shows that while generator passes over it, indexes
@@ -40,12 +38,11 @@ export default class Whitespace {
     var startToken;
     var endToken;
     var tokens = this.tokens;
-    var token;
 
     for (var j = 0; j < tokens.length; j++) {
       // optimize for forward traversal by shifting for loop index
       var i = getLookupIndex(j, this._lastFoundIndex, this.tokens.length);
-      token = tokens[i];
+      var token = tokens[i];
 
       // this is the token this node starts with
       if (node.start === token.start) {
@@ -64,17 +61,17 @@ export default class Whitespace {
     var startToken;
     var endToken;
     var tokens = this.tokens;
-    var token;
 
     for (var j = 0; j < tokens.length; j++) {
       // optimize for forward traversal by shifting for loop index
       var i = getLookupIndex(j, this._lastFoundIndex, this.tokens.length);
-      token = tokens[i];
+      var token = tokens[i];
 
       // this is the token this node ends with
       if (node.end === token.end) {
         startToken = token;
         endToken = tokens[i + 1];
+        if (endToken.type.label === ",") endToken = tokens[i + 2];
 
         this._lastFoundIndex = i;
         break;
@@ -85,7 +82,7 @@ export default class Whitespace {
       return 1;
     } else {
       var lines = this.getNewlinesBetween(startToken, endToken);
-      if (node.type === "Line" && !lines) {
+      if (node.type === "CommentLine" && !lines) {
         // line comment
         return 1;
       } else {

src/babel/helpers/code-frame.js

@@ -85,4 +85,4 @@ export default function (lines: number, lineNumber: number, colNumber: number, o
       params.before = params.before.replace(/^./, ">");
     }
   }).join("\n");
-};
+}

src/babel/helpers/merge.js

@@ -0,0 +1,17 @@
+import merge from "lodash/object/merge";
+
+export default function (dest, src) {
+  if (!dest || !src) return;
+
+  return merge(dest, src, function(a, b) {
+    if (Array.isArray(a)) {
+      var c = a.slice(0);
+      for (var v of b) {
+        if (a.indexOf(v) < 0) {
+          c.push(v);
+        }
+      }
+      return c;
+    }
+  });
+}

src/babel/helpers/normalize-ast.js

@@ -6,4 +6,4 @@ export default function (ast, comments, tokens) {
   } else {
     throw new Error("Not a valid ast?");
   }
-};
+}

src/babel/helpers/object.js

@@ -1,3 +1,3 @@
 export default function () {
   return Object.create(null);
-};
+}

src/babel/helpers/parse.js

@@ -1,65 +1,52 @@
 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 commentsAndTokens = [];
+  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,
+    features:                    opts.features || {},
+    plugins:                     opts.plugins || {},
+    onToken:                     tokens,
+    ranges:                      true
+  };
+
+  parseOpts.onToken = function (token) {
+    tokens.push(token);
+    commentsAndTokens.push(token);
+  };
+
+  parseOpts.onComment = function (block, text, start, end, startLoc, endLoc) {
+    var comment = {
+      type: block ? "CommentBlock" : "CommentLine",
+      value: text,
+      start: start,
+      end: end,
+      loc: new acorn.SourceLocation(this, startLoc, endLoc),
+      range: [start, end]
     };
 
-    if (opts.nonStandard) {
-      parseOpts.plugins.jsx = true;
-      parseOpts.plugins.flow = true;
-    }
+    commentsAndTokens.push(comment);
+    comments.push(comment);
+  };
 
-    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, commentsAndTokens);
+  return ast;
+}

src/babel/messages.js

@@ -18,15 +18,16 @@ 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",
+  lostTrackNodePath: "We lost track of this nodes position, likely because the AST was directly manipulated",
+
   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 }`?",
-  traverseVerifyVisitorFunction: "Hey! You passed \`traverse()\` a visitor object with the key $1 that's a straight up `Function` instead of `{ enter: Function }`. You need to normalise it with `traverse.explode(visitor)`.",
   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",

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")
@@ -69,4 +72,10 @@ def("ExportAllDeclaration")
   .field("exported", def("Identifier"))
   .field("source", def("Literal"));
 
+def("BindExpression")
+  .bases("Expression")
+  .build("object", "callee")
+  .field("object", or(def("Expression"), null))
+  .field("callee", def("Expression"));
+
 types.finalize();

src/babel/tools/build-external-helpers.js

@@ -83,4 +83,4 @@ export default function (whitelist, outputType = "global") {
   }
 
   return generator(tree).code;
-};
+}

src/babel/tools/resolve-rc.js

@@ -1,5 +1,5 @@
 import stripJsonComments from "strip-json-comments";
-import merge from "lodash/object/merge";
+import merge from "../helpers/merge";
 import path from "path";
 import fs from "fs";
 
@@ -42,17 +42,7 @@ export default function (loc, opts = {}) {
       opts.babelrc.push(file);
 
       if (json.breakConfig) return;
-      merge(opts, json, function(a, b) {
-        if (Array.isArray(a)) {
-          var c = a.slice(0);
-          for (var v of b) {
-            if (a.indexOf(v) < 0) {
-              c.push(v);
-            }
-          }
-          return c;
-        }
-      });
+      merge(opts, json);
     }
 
     var up = path.dirname(start);
@@ -66,4 +56,4 @@ export default function (loc, opts = {}) {
   }
 
   return opts;
-};
+}

src/babel/transformation/file/index.js

@@ -3,43 +3,31 @@ 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 NodePath 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";
 import assign from "lodash/object/assign";
 import Logger from "./logger";
 import parse from "../../helpers/parse";
-import Scope from "../../traversal/scope";
+import merge from "../../helpers/merge";
 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 = {
-  exit(node, parent, scope, state) {
-    checkPath(state.stack, this);
-  }
-};
-
-function checkPath(stack, path) {
-  each(stack, function (pass) {
-    if (pass.shouldRun || pass.ran) return;
-    pass.checkPath(path);
-  });
-}
-
 export default class File {
   constructor(opts = {}, pipeline) {
+    this.transformerDependencies = {};
+
     this.dynamicImportTypes = {};
     this.dynamicImportIds   = {};
     this.dynamicImports     = [];
@@ -47,8 +35,8 @@ export default class File {
     this.declarations = {};
     this.usedHelpers  = {};
     this.dynamicData  = {};
+    this.metadata     = {};
     this.data         = {};
-    this.uids         = {};
 
     this.pipeline = pipeline;
     this.log      = new Logger(this, opts.filename || "unknown");
@@ -95,10 +83,7 @@ export default class File {
     "interop-require",
   ];
 
-  static soloHelpers = [
-    "ludicrous-proxy-create",
-    "ludicrous-proxy-directory"
-  ];
+  static soloHelpers = [];
 
   static options = require("./options");
 
@@ -120,6 +105,9 @@ export default class File {
       if (!option) this.log.error(`Unknown option: ${key}`, ReferenceError);
     }
 
+    var envKey = process.env.BABEL_ENV || process.env.NODE_ENV || "development";
+    if (opts.env) merge(opts, opts.env[envKey]);
+
     for (let key in File.options) {
       let option = File.options[key];
 
@@ -177,7 +165,7 @@ export default class File {
 
     defaults(opts, {
       sourceFileName: opts.filenameRelative,
-      sourceMapName:  opts.filenameRelative
+      sourceMapTarget:  opts.filenameRelative
     });
 
     //
@@ -202,8 +190,9 @@ export default class File {
     var stack = [];
 
     // build internal transformers
-    each(this.pipeline.transformers, function (transformer, key) {
-      var pass = transformers[key] = transformer.buildPass(file);
+    for (var key in this.pipeline.transformers) {
+      var transformer = this.pipeline.transformers[key];
+      let pass = transformers[key] = transformer.buildPass(file);
 
       if (pass.canTransform()) {
         stack.push(pass);
@@ -216,7 +205,7 @@ export default class File {
           transformer.manipulateOptions(file.opts, file);
         }
       }
-    });
+    }
 
     // init plugins!
     var beforePlugins = [];
@@ -232,50 +221,54 @@ export default class File {
     }
     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 : 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);
-  }
-
-  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);
+    // build dependency graph
+    for (let pass of (stack: Array)) {
+      for (var dep of (pass.transformer.dependencies: Array)) {
+        this.transformerDependencies[dep] = pass.key;
       }
     }
 
-    return code;
+    // collapse stack categories
+    this.transformerStack = this.collapseStack(stack);
   }
 
-  parseShebang(code: string) {
-    var shebangMatch = shebangRegex.exec(code);
+  collapseStack(_stack) {
+    var stack  = [];
+    var ignore = [];
 
-    if (shebangMatch) {
-      this.shebang = shebangMatch[0];
+    for (let pass of (_stack: Array)) {
+      // been merged
+      if (ignore.indexOf(pass) >= 0) continue;
 
-      // remove shebang
-      code = code.replace(shebangRegex, "");
+      var group = pass.transformer.metadata.group;
+
+      // 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);
+        }
+      }
+
+      var visitors = [];
+      for (let pass of (mergeStack: Array)) {
+        visitors.push(pass.handlers);
+      }
+      var visitor = traverse.visitors.merge(visitors);
+      var mergeTransformer = new Transformer(group, visitor);
+      stack.push(mergeTransformer.buildPass(this));
     }
 
-    return code;
+    return stack;
   }
 
   set(key: string, val): any {
@@ -337,7 +330,7 @@ export default class File {
     if (comment) {
       node.leadingComments = node.leadingComments || [];
       node.leadingComments.push({
-        type: "Line",
+        type: "CommentLine",
         value: " " + comment
       });
     }
@@ -351,8 +344,6 @@ export default class File {
       throw new ReferenceError(`Unknown helper ${name}`);
     }
 
-    var program = this.ast.program;
-
     var declar = this.declarations[name];
     if (declar) return declar;
 
@@ -370,47 +361,83 @@ export default class File {
     }
 
     var ref = util.template("helper-" + name);
-    ref._compact = true;
+
     var uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
-    this.scope.push({
-      id: uid,
-      init: ref,
-      unique: true
-    });
+
+    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;
   }
 
   errorWithNode(node, msg, Error = SyntaxError) {
-    var loc = node.loc.start;
-    var err = new Error(`Line ${loc.line}: ${msg}`);
-    err.loc = loc;
+    var err;
+    if (node.loc) {
+      var loc = node.loc.start;
+      err = new Error(`Line ${loc.line}: ${msg}`);
+      err.loc = loc;
+    } else {
+      err = new Error("There's been an error on a dynamic node. This is almost certainly an internal error. Please report it.");
+    }
     return err;
   }
 
-  addCode(code: string) {
-    code = (code || "") + "";
-    code = this.parseInputSourceMap(code);
-    this.code = code;
-    return this.parseShebang(code);
+  mergeSourceMap(map: Object) {
+    var opts = this.opts;
+
+    var inputMap = opts.inputSourceMap;
+
+    if (inputMap) {
+      map.sources[0] = inputMap.file;
+
+      var inputMapConsumer   = new sourceMap.SourceMapConsumer(inputMap);
+      var outputMapConsumer  = new sourceMap.SourceMapConsumer(map);
+      var outputMapGenerator = sourceMap.SourceMapGenerator.fromSourceMap(outputMapConsumer);
+      outputMapGenerator.applySourceMap(inputMapConsumer);
+
+      var mergedMap = outputMapGenerator.toJSON();
+      mergedMap.sources = inputMap.sources;
+      mergedMap.file    = inputMap.file;
+      return mergedMap;
+    }
+
+    return map;
   }
 
-  shouldIgnore() {
-    var opts = this.opts;
-    return util.shouldIgnore(opts.filename, opts.ignore, opts.only);
+
+  getModuleFormatter(type: string) {
+    if (isFunction(type) || !moduleFormatters[type]) {
+      this.log.deprecate("Custom module formatters are deprecated and will be removed in the next major. Please use Babel plugins instead.");
+    }
+
+    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) {
-    if (this.shouldIgnore()) {
-      return {
-        metadata: {},
-        code:     code,
-        map:      null,
-        ast:      null
-      };
-    }
-
-    code = this.addCode(code);
-
     var opts = this.opts;
 
     //
@@ -433,125 +460,160 @@ export default class File {
     parseOpts.sourceType = "module";
 
     this.log.debug("Parse start");
-
-    //
-
-    return parse(parseOpts, code, (tree) => {
-      this.log.debug("Parse stop");
-      this.transform(tree);
-      return this.generate();
-    });
+    var tree = parse(code, parseOpts);
+    this.log.debug("Parse stop");
+    return tree;
   }
 
-  setAst(ast) {
-    this.path  = TraversalPath.get(null, null, ast, ast, "program", this);
+  _addAst(ast) {
+    this.path  = NodePath.get({
+      parentPath: null,
+      parent: ast,
+      container: ast,
+      key: "program"
+    }).setContext(null, 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) {
+  addAst(ast) {
     this.log.debug("Start set AST");
-    this.setAst(ast);
+    this._addAst(ast);
     this.log.debug("End set AST");
 
-    this.log.debug("Start prepass");
-    this.checkPath(this.path);
-    this.log.debug("End prepass");
-
     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.populateModuleMetadata();
     this.log.debug("End module formatter init");
+  }
 
+  populateModuleMetadata() {
+    var modules = {};
+    this.metadata.modules = modules;
+  }
+
+  transform() {
     this.call("pre");
-    each(this.transformerStack, function (pass) {
+    for (var pass of (this.transformerStack: Array)) {
       pass.transform();
-    });
+    }
     this.call("post");
+
+    return this.generate();
+  }
+
+  wrap(code, callback) {
+    code = code + "";
+
+    try {
+      return callback();
+    } 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) {
+    code = (code || "") + "";
+    code = this.parseInputSourceMap(code);
+    this.code = code;
+  }
+
+  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) {
-    var stack = this.transformerStack;
-    for (var i = 0; i < stack.length; i++) {
-      var transformer = stack[i].transformer;
-      var fn = transformer[key];
+    for (var pass of (this.uncollapsedTransformerStack: Array)) {
+      var fn = pass.transformer[key];
       if (fn) fn(this);
     }
   }
 
-  checkPath(path) {
-    if (Array.isArray(path)) {
-      for (var i = 0; i < path.length; i++) {
-        this.checkPath(path[i]);
+  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;
     }
 
-    var stack = this.transformerStack;
-
-    checkPath(stack, path);
-
-    path.traverse(checkTransformerVisitor, {
-      stack: stack
-    });
+    return code;
   }
 
-  mergeSourceMap(map: Object) {
-    var opts = this.opts;
-
-    var inputMap = opts.inputSourceMap;
-
-    if (inputMap) {
-      map.sources[0] = inputMap.file;
-
-      var inputMapConsumer   = new sourceMap.SourceMapConsumer(inputMap);
-      var outputMapConsumer  = new sourceMap.SourceMapConsumer(map);
-      var outputMapGenerator = sourceMap.SourceMapGenerator.fromSourceMap(outputMapConsumer);
-      outputMapGenerator.applySourceMap(inputMapConsumer);
-
-      var mergedMap = outputMapGenerator.toJSON();
-      mergedMap.sources = inputMap.sources
-      mergedMap.file    = inputMap.file;
-      return mergedMap;
+  parseShebang() {
+    var shebangMatch = shebangRegex.exec(this.code);
+    if (shebangMatch) {
+      this.shebang = shebangMatch[0];
+      this.code = this.code.replace(shebangRegex, "");
     }
-
-    return map;
   }
 
-  generate(): {
-    usedHelpers?: Array<string>;
-    code: string;
-    map?: Object;
-    ast?: Object;
-  } {
-    var opts = this.opts;
-    var ast  = this.ast;
-
+  makeResult({ code, map = null, ast, ignored }) {
     var result = {
-      metadata: {},
-      code:     "",
-      map:      null,
-      ast:      null
+      metadata: null,
+      ignored:  !!ignored,
+      code:     null,
+      ast:      null,
+      map:      map
     };
 
-    if (this.opts.metadataUsedHelpers) {
+    if (this.opts.code) {
+      result.code = code;
+    }
+
+    if (this.opts.ast) {
+      result.ast = ast;
+    }
+
+    if (this.opts.metadata) {
+      result.metadata = this.metadata;
       result.metadata.usedHelpers = Object.keys(this.usedHelpers);
     }
 
-    if (opts.ast) result.ast = ast;
-    if (!opts.code) return result;
+    return result;
+  }
+
+  generate() {
+    var opts = this.opts;
+    var ast  = this.ast;
+
+    var result = { ast };
+    if (!opts.code) return this.makeResult(result);
 
     this.log.debug("Generation start");
 
@@ -578,6 +640,6 @@ export default class File {
       result.map = null;
     }
 
-    return result;
+    return this.makeResult(result);
   }
 }

src/babel/transformation/file/logger.js

@@ -1,4 +1,8 @@
-import * as util from  "../../util";
+import type File from "./index";
+import buildDebug from "debug/node";
+
+var verboseDebug = buildDebug("babel:verbose");
+var generalDebug = buildDebug("babel");
 
 export default class Logger {
   constructor(file: File, filename: string) {
@@ -12,6 +16,10 @@ export default class Logger {
     return parts;
   }
 
+  warn(msg) {
+    console.warn(this._buildMessage(msg));
+  }
+
   error(msg: string, Constructor = Error) {
     throw new Constructor(this._buildMessage(msg));
   }
@@ -22,11 +30,15 @@ export default class Logger {
     }
   }
 
+  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/options.json

@@ -20,13 +20,21 @@
     "default": {}
   },
 
+  "env": {
+    "hidden": true,
+    "default": {}
+  },
+
   "moduleId": {
     "description": "specify a custom name for module ids",
     "type": "string"
   },
 
+  "getModuleId": {
+    "hidden": true
+  },
+
   "retainLines": {
-    "hidden": true,
     "type": "boolean",
     "default": false,
     "description": "retain line numbers - will result in really ugly code"
@@ -35,15 +43,16 @@
   "nonStandard": {
     "type": "boolean",
     "default": true,
-    "description": "enable support for JSX and Flow"
+    "description": "enable/disable support for JSX and Flow (on by default)"
   },
 
   "experimental": {
-    "deprecated": "use `--stage 0`/`{ stage: 0 }` instead"
+    "description": "allow use of experimental transformers",
+    "default": false
   },
 
   "highlightCode": {
-    "description": "ANSI syntax highlight code frames",
+    "description": "enable/disable ANSI syntax highlighting of code frames (on by default)",
     "type": "boolean",
     "default": true
   },
@@ -131,6 +140,12 @@
     "type": "boolean"
   },
 
+  "metadata": {
+    "hidden": true,
+    "default": true,
+    "type": "boolean"
+  },
+
   "ast": {
     "hidden": true,
     "default": true,
@@ -140,7 +155,7 @@
   "comments": {
     "type": "boolean",
     "default": true,
-    "description": "output comments in generated output"
+    "description": "strip/output comments in generated output (on by default)"
   },
 
   "compact": {
@@ -171,6 +186,7 @@
   },
 
   "metadataUsedHelpers": {
+    "deprecated": "Not required anymore as this is enabled by default",
     "type": "boolean",
     "default": false,
     "hidden": true
@@ -189,6 +205,11 @@
   },
 
   "sourceMapName": {
+    "alias": "sourceMapTarget",
+    "description": "DEPRECATED - Please use sourceMapTarget"
+  },
+
+  "sourceMapTarget": {
     "type": "string",
     "description": "set `file` on returned source map"
   },

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

@@ -35,11 +35,12 @@ export default class PluginManager {
     var match = name.match(/^(.*?):(after|before)$/);
     if (match) [, name, position] = match;
 
-    var loc = util.resolveRelative(name) || util.resolveRelative(`babel-plugin-${name}`);
+    var loc = util.resolveRelative(`babel-plugin-${name}`) || util.resolveRelative(name);
     if (loc) {
+      var plugin = require(loc);
       return {
         position: position,
-        plugin:   require(loc)
+        plugin:   plugin.default || plugin
       };
     } else {
       throw new ReferenceError(messages.get("pluginUnknown", name));
@@ -57,6 +58,9 @@ export default class PluginManager {
     if (!plugin.buildPass || plugin.constructor.name !== "Transformer") {
       throw new TypeError(messages.get("pluginNotTransformer", name));
     }
+
+    // register as a plugin
+    plugin.metadata.plugin = true;
   }
 
   add(name) {
@@ -65,7 +69,7 @@ export default class PluginManager {
 
     if (name) {
       if (typeof name === "object" && name.transformer) {
-        ({ plugin: name, position } = name);
+        ({ 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

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 + "=";
   };
@@ -10,10 +12,6 @@ export default function (exports, opts) {
     return t.assignmentExpression("=", left, right);
   };
 
-  exports.shouldVisit = function (node) {
-    return node.operator && (node.operator === opts.operator || node.operator === opts.operator + "=");
-  };
-
   exports.ExpressionStatement = function (node, parent, scope, file) {
     // hit the `AssignmentExpression` one below
     if (this.isCompletionRecord()) return;
@@ -44,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

@@ -42,4 +42,4 @@ export default function (exports, opts) {
 
     return nodes;
   };
-};
+}

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)) {
+  exports.JSXIdentifier = function (node) {
+    if (node.name === "this" && this.isReferenced()) {
       return t.thisExpression();
     } else if (esutils.keyword.isIdentifierNameES6(node.name)) {
       node.type = "Identifier";
@@ -26,7 +20,7 @@ export default function (exports, opts) {
     }
   };
 
-  exports.JSXNamespacedName = function (node, parent, scope, file) {
+  exports.JSXNamespacedName = function () {
     throw this.errorWithNode(messages.get("JSXNamespacedTags"));
   };
 
@@ -167,7 +161,8 @@ export default function (exports, opts) {
 
     for (var i = 0; i < props.length; i++) {
       var prop = props[i];
-      if (t.isIdentifier(prop.key, { name: "displayName" })) {
+      var key = t.toComputedKey(prop);
+      if (t.isLiteral(key, { value: "displayName" })) {
         safe = false;
         break;
       }
@@ -208,4 +203,4 @@ export default function (exports, opts) {
       addDisplayName(left.name, right);
     }
   };
-};
+}

src/babel/transformation/helpers/call-delegate.js

@@ -1,4 +1,3 @@
-import traverse from "../../traversal";
 import * as t from "../../types";
 
 var visitor = {
@@ -7,10 +6,10 @@ var visitor = {
       state.found = true;
       this.stop();
     }
+  },
 
-    if (this.isFunction()) {
-      this.skip();
-    }
+  Function() {
+    this.skip();
   }
 };
 

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

@@ -1,5 +1,3 @@
-import cloneDeep from "lodash/lang/cloneDeep";
-import traverse from "../../traversal";
 import each from "lodash/collection/each";
 import has from "lodash/object/has";
 import * as t from "../../types";
@@ -26,7 +24,7 @@ export function push(mutatorMap, node, kind, file) {
 
   if (node.decorators) {
     var decorators = map.decorators = map.decorators || t.arrayExpression([]);
-    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression));
+    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression).reverse());
   }
 
   if (map.value || map.initializer) {

src/babel/transformation/helpers/explode-assignable-expression.js

@@ -26,7 +26,7 @@ var getObjRef = function (node, nodes, file, scope) {
     throw new Error(`We can't explode this node type ${node.type}`);
   }
 
-  var temp = scope.generateUidBasedOnNode(ref);
+  var temp = scope.generateUidIdentifierBasedOnNode(ref);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(temp, ref)
   ]));
@@ -38,7 +38,7 @@ var getPropRef = function (node, nodes, file, scope) {
   var key = t.toComputedKey(node, prop);
   if (t.isLiteral(key)) return key;
 
-  var temp = scope.generateUidBasedOnNode(prop);
+  var temp = scope.generateUidIdentifierBasedOnNode(prop);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(temp, prop)
   ]));
@@ -68,4 +68,4 @@ export default function (node, nodes, file, scope, allowedSingleIdent) {
     uid: uid,
     ref: ref
   };
-};
+}

src/babel/transformation/helpers/get-function-arity.js

@@ -6,4 +6,4 @@ export default function (node) {
     if (!t.isAssignmentPattern(node.params[i])) lastNonDefault = i + 1;
   }
   return lastNonDefault;
-};
+}

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

@@ -6,7 +6,7 @@ export default function (decorators, scope) {
     var expression = decorator.expression;
     if (!t.isMemberExpression(expression)) continue;
 
-    var temp = scope.generateMemoisedReference(expression.object);
+    var temp = scope.maybeGenerateMemoised(expression.object);
     var ref;
 
     var nodes = [];

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

@@ -2,25 +2,35 @@ import getFunctionArity from "./get-function-arity";
 import * as util from  "../../util";
 import * as t from "../../types";
 
+function visitIdentifier(context, node, scope, state) {
+  // check if this node matches our function id
+  if (node.name !== state.name) return;
+
+  // check that we don't have a local variable declared as that removes the need
+  // for the wrapper
+  var localDeclar = scope.getBindingIdentifier(state.name);
+  if (localDeclar !== state.outerDeclar) return;
+
+  state.selfReference = true;
+  context.stop();
+}
+
 var visitor = {
-  enter(node, parent, scope, state) {
-    // check if this node is a referenced identifier that matches the same as our
-    // function id
-    if (!this.isReferencedIdentifier({ name: state.name })) return;
+  ReferencedIdentifier(node, parent, scope, state) {
+    visitIdentifier(this, node, scope, state);
+  },
 
-    // check that we don't have a local variable declared as that removes the need
-    // for the wrapper
-    var localDeclar = scope.getBindingIdentifier(state.name);
-    if (localDeclar !== state.outerDeclar) return;
-
-    state.selfReference = true;
-    this.stop();
+  AssignmentExpression(node, parent, scope, state) {
+    var ids = this.getBindingIdentifiers();
+    for (var name in ids) {
+      visitIdentifier(this, ids[name], scope, state);
+    }
   }
 };
 
 var wrap = function (state, method, id, scope) {
   if (state.selfReference) {
-    if (scope.hasBinding(id.name)) {
+    if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
       // we can just munge the local binding
       scope.rename(id.name);
     } else {
@@ -46,6 +56,7 @@ var wrap = function (state, method, id, scope) {
   }
 
   method.id = id;
+  scope.getProgramParent().references[id.name] = true;
 };
 
 var visit = function (node, name, scope) {

src/babel/transformation/helpers/react.js

@@ -1,4 +1,3 @@
-import isString from "lodash/lang/isString";
 import * as t from "../../types";
 
 var isCreateClassCallExpression = t.buildMatchMemberExpression("React.createClass");
@@ -26,10 +25,6 @@ export function isCompatTag(tagName) {
   return tagName && /^[a-z]|\-/.test(tagName);
 }
 
-function isStringLiteral(node) {
-  return t.isLiteral(node) && isString(node.value);
-}
-
 function cleanJSXElementLiteralChild(child, args) {
   var lines = child.value.split(/\r\n|\n|\r/);
 

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

@@ -1,25 +1,25 @@
 import * as t from "../../types";
 
 var awaitVisitor = {
-  enter(node, parent, scope, state) {
-    if (t.isFunction(node)) this.skip();
+  Function() {
+    this.skip();
+  },
 
-    if (t.isAwaitExpression(node)) {
-      node.type = "YieldExpression";
+  AwaitExpression(node) {
+    node.type = "YieldExpression";
 
-      if (node.all) {
-        // await* foo; -> yield Promise.all(foo);
-        node.all = false;
-        node.argument = t.callExpression(t.memberExpression(t.identifier("Promise"), t.identifier("all")), [node.argument]);
-      }
+    if (node.all) {
+      // await* foo; -> yield Promise.all(foo);
+      node.all = false;
+      node.argument = t.callExpression(t.memberExpression(t.identifier("Promise"), t.identifier("all")), [node.argument]);
     }
   }
 };
 
 var referenceVisitor = {
-  enter(node, parent, scope, state) {
+  ReferencedIdentifier(node, parent, scope, state) {
     var name = state.id.name;
-    if (t.isReferencedIdentifier(node, parent, { name: name }) && scope.bindingIdentifierEquals(name, state.id)) {
+    if (node.name === name && scope.bindingIdentifierEquals(name, state.id)) {
       return state.ref = state.ref || scope.generateUidIdentifier(name);
     }
   }
@@ -55,4 +55,4 @@ export default function (node, callId, scope) {
 
     return call;
   }
-};
+}

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

@@ -1,3 +1,4 @@
+import type NodePath from "../../traversal/path";
 import * as messages from "../../messages";
 import * as t from "../../types";
 
@@ -130,7 +131,7 @@ export default class ReplaceSupers {
    * Description
    */
 
-  traverseLevel(path: TraversalPath, topLevel: boolean) {
+  traverseLevel(path: NodePath, topLevel: boolean) {
     var state = { self: this, topLevel: topLevel };
     path.traverse(visitor, state);
   }
@@ -192,7 +193,7 @@ export default class ReplaceSupers {
    * Description
    */
 
-  looseHandle(path: TraversalPath, getThisReference: Function) {
+  looseHandle(path: NodePath, getThisReference: Function) {
     var node = path.node;
     if (path.isSuper()) {
       return this.getLooseSuperProperty(node, path.parent);
@@ -234,7 +235,7 @@ export default class ReplaceSupers {
    * Description
    */
 
-  specHandle(path: TraversalPath, getThisReference: Function) {
+  specHandle(path: NodePath, getThisReference: Function) {
     var methodNode = this.methodNode;
     var property;
     var computed;
@@ -274,7 +275,7 @@ export default class ReplaceSupers {
       property = node.property;
       computed = node.computed;
     } else if (t.isUpdateExpression(node) && isMemberExpressionSuper(node.argument)) {
-      var binary = t.binaryExpression(node.operator[0], node.argument, t.literal(1))
+      var binary = t.binaryExpression(node.operator[0], node.argument, t.literal(1));
       if (node.prefix) {
         // ++super.foo; -> super.foo += 1;
         return this.specHandleAssignmentExpression(null, path, binary, getThisReference);

src/babel/transformation/helpers/strict.js

@@ -1,19 +0,0 @@
-import * as t from "../../types";
-
-export function has(node) {
-  var first = node.body[0];
-  return t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" });
-}
-
-export function wrap(node, callback) {
-  var useStrictNode;
-  if (has(node)) {
-    useStrictNode = node.body.shift();
-  }
-
-  callback();
-
-  if (useStrictNode) {
-    node.body.unshift(useStrictNode);
-  }
-}

src/babel/transformation/index.js

@@ -5,6 +5,13 @@ 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";
+}
+
 pipeline.addTransformers(transformers);
 
 //
@@ -15,7 +22,7 @@ pipeline.addDeprecated(deprecated);
 //
 
 import aliases from "./transformers/aliases";
-pipeline.addDeprecated(aliases);
+pipeline.addAliases(aliases);
 
 //
 

src/babel/transformation/modules/_default.js

@@ -1,109 +1,120 @@
 import * as messages from "../../messages";
-import traverse from "../../traversal";
 import extend from "lodash/object/extend";
 import object from "../../helpers/object";
 import * as util from  "../../util";
 import * as t from "../../types";
 
 var remapVisitor = {
-  enter(node, parent, scope, formatter) {
-    var remap = formatter.internalRemap[node.name];
-    if (this.isReferencedIdentifier() && 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;
-        }
-
-        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);
-      }
-    }
-
+  enter(node) {
     if (node._skipModulesRemap) {
       return this.skip();
     }
   },
 
-  exit(node, parent, scope, formatter) {
-    if (t.isAssignmentExpression(node) && !node._ignoreModulesRemap) {
-      var exported = formatter.getExport(node.left, scope);
-      if (exported) {
-        return formatter.remapExportAssignment(node, exported);
+  ReferencedIdentifier(node, parent, scope, formatter) {
+    var remap = formatter.internalRemap[node.name];
+
+    if (remap && node !== remap) {
+      if (!scope.hasBinding(node.name) || scope.bindingIdentifierEquals(node.name, formatter.localImports[node.name])) {
+        if (this.key === "callee" && this.parentPath.isCallExpression()) {
+          return t.sequenceExpression([t.literal(0), remap]);
+        } else {
+          return remap;
+        }
       }
     }
+  },
+
+  AssignmentExpression: {
+    exit(node, parent, scope, formatter) {
+      if (!node._ignoreModulesRemap) {
+        var exported = formatter.getExport(node.left, scope);
+        if (exported) {
+          return formatter.remapExportAssignment(node, exported);
+        }
+      }
+    }
+  },
+
+  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;
+    }
+
+    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);
   }
 };
 
-var importsVisitor = {
-  ImportDeclaration: {
-    enter(node, parent, scope, formatter) {
-      formatter.hasLocalImports = true;
-      extend(formatter.localImports, this.getBindingIdentifiers());
+var metadataVisitor = {
+  ModuleDeclaration(node, parent, scope, formatter) {
+    if (node.source) {
+      node.source.value = formatter.file.resolveModuleSource(node.source.value);
     }
+  },
+
+  ImportDeclaration(node, parent, scope, formatter) {
+    formatter.hasLocalImports = true;
+    extend(formatter.localImports, this.getBindingIdentifiers());
+  },
+
+  ExportDeclaration(node, parent, scope, formatter) {
+    formatter.hasLocalExports = true;
+
+    var declar = this.get("declaration");
+    if (declar.isStatement()) {
+      var bindings = declar.getBindingIdentifiers();
+      for (var name in bindings) {
+        var binding = bindings[name];
+        formatter._addExport(name, binding);
+      }
+    }
+
+    if (this.isExportNamedDeclaration() && node.specifiers) {
+      for (var i = 0; i < node.specifiers.length; i++) {
+        var specifier = node.specifiers[i];
+        var local = specifier.local;
+        if (!local) continue;
+
+        formatter._addExport(local.name, specifier.exported);
+      }
+    }
+
+    if (!t.isExportDefaultDeclaration(node)) {
+      var onlyDefault = node.specifiers && node.specifiers.length === 1 && t.isSpecifierDefault(node.specifiers[0]);
+      if (!onlyDefault) {
+        formatter.hasNonDefaultExports = true;
+      }
+    }
+  },
+
+  Scope() {
+    this.skip();
   }
 };
 
-var exportsVisitor = traverse.explode({
-  ExportDeclaration: {
-    enter(node, parent, scope, formatter) {
-      formatter.hasLocalExports = true;
-
-      var declar = this.get("declaration");
-      if (declar.isStatement()) {
-        var bindings = declar.getBindingIdentifiers()
-        for (var name in bindings) {
-          var binding = bindings[name];
-          formatter._addExport(name, binding);
-        }
-      }
-
-      if (this.isExportNamedDeclaration() && node.specifiers) {
-        for (var i = 0; i < node.specifiers.length; i++) {
-          var specifier = node.specifiers[i];
-          var local = specifier.local;
-          if (!local) continue;
-
-          formatter._addExport(local.name, specifier.exported);
-        }
-      }
-
-      if (!t.isExportDefaultDeclaration(node)) {
-        var onlyDefault = node.specifiers && node.specifiers.length === 1 && t.isSpecifierDefault(node.specifiers[0]);
-        if (!onlyDefault) {
-          formatter.hasNonDefaultExports = true;
-        }
-      }
-    }
-  }
-});
-
 export default class DefaultFormatter {
   constructor(file) {
     this.internalRemap = object();
@@ -120,8 +131,7 @@ export default class DefaultFormatter {
     this.localExports = object();
     this.localImports = object();
 
-    this.getLocalExports();
-    this.getLocalImports();
+    this.getMetadata();
   }
 
   isModuleType(node, type) {
@@ -137,12 +147,15 @@ export default class DefaultFormatter {
     return (t.isExportDefaultDeclaration(node) || t.isSpecifierDefault(node)) && !this.noInteropRequireExport && !this.hasNonDefaultExports;
   }
 
-  getLocalExports() {
-    this.file.path.traverse(exportsVisitor, this);
-  }
-
-  getLocalImports() {
-    this.file.path.traverse(importsVisitor, this);
+  getMetadata() {
+    var has = false;
+    for (var node of (this.file.ast.program.body: Array)) {
+      if (t.isModuleDeclaration(node)) {
+        has = true;
+        break;
+      }
+    }
+    if (has) this.file.path.traverse(metadataVisitor, this);
   }
 
   remapAssignments() {
@@ -184,7 +197,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 = "";
@@ -213,7 +229,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/_strict.js

@@ -10,4 +10,4 @@ export default function (Parent) {
   util.inherits(Constructor, Parent);
 
   return Constructor;
-};
+}

src/babel/transformation/modules/amd.js

@@ -6,8 +6,8 @@ import * as util from  "../../util";
 import * as t from "../../types";
 
 export default class AMDFormatter extends DefaultFormatter {
-  init() {
-    CommonFormatter.prototype._init.call(this, this.hasNonDefaultExports);
+  setup() {
+    CommonFormatter.prototype._setup.call(this, this.hasNonDefaultExports);
   }
 
   buildDependencyLiterals() {
@@ -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;
 
@@ -92,9 +92,9 @@ export default class AMDFormatter extends DefaultFormatter {
       // import foo from "foo";
       var uid = this.scope.generateUidIdentifier(specifier.local.name);
       nodes.push(t.variableDeclaration("var", [
-        t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require"), [ref]))
+        t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-default"), [ref]))
       ]));
-      ref = uid;
+      ref = t.memberExpression(uid, t.identifier("default"));
     } else {
       // import { foo } from "foo";
       var imported = specifier.imported;
@@ -108,12 +108,16 @@ export default class AMDFormatter extends DefaultFormatter {
   exportSpecifier(specifier, node, nodes) {
     if (this.doDefaultExportInterop(specifier)) {
       this.passModuleArg = true;
-      nodes.push(util.template("exports-default-assign", {
-        VALUE: specifier.local
-      }, true));
-    } else {
-      CommonFormatter.prototype.exportSpecifier.apply(this, arguments);
+
+      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

@@ -1,14 +1,13 @@
 import DefaultFormatter from "./_default";
-import includes from "lodash/collection/includes";
 import * as util from  "../../util";
 import * as t from "../../types";
 
 export default class CommonJSFormatter extends DefaultFormatter {
-  init() {
-    this._init(this.hasLocalExports);
+  setup() {
+    this._setup(this.hasLocalExports);
   }
 
-  _init(conditional) {
+  _setup(conditional) {
     var file  = this.file;
     var scope = file.scope;
 
@@ -52,7 +51,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
       } else if (this.noInteropRequireImport) {
         this.internalRemap[variableName.name] = t.memberExpression(ref, t.identifier("default"));
       } else {
-        var uid = this.scope.generateUidBasedOnNode(node, "import");
+        var uid = this.scope.generateUidIdentifierBasedOnNode(node, "import");
 
         nodes.push(t.variableDeclaration("var", [
           t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-default"), [ref]))
@@ -84,7 +83,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     }, true));
   }
 
-  exportSpecifier(specifier, node, nodes) {
+  exportSpecifier(specifier) {
     if (this.doDefaultExportInterop(specifier)) {
       this.hasDefaultOnlyExport = true;
     }
@@ -92,7 +91,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     DefaultFormatter.prototype.exportSpecifier.apply(this, arguments);
   }
 
-  exportDeclaration(node, nodes) {
+  exportDeclaration(node) {
     if (this.doDefaultExportInterop(node)) {
       this.hasDefaultOnlyExport = true;
     }
@@ -101,8 +100,6 @@ export default class CommonJSFormatter extends DefaultFormatter {
   }
 
   _getExternalReference(node, nodes) {
-    var source = node.source.value;
-
     var call = t.callExpression(t.identifier("require"), [node.source]);
     var uid;
 
@@ -111,7 +108,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     } else if (this.isModuleType(node, "absoluteDefault")) {
       call = t.memberExpression(call, t.identifier("default"));
     } else {
-      uid = this.scope.generateUidBasedOnNode(node, "import");
+      uid = this.scope.generateUidIdentifierBasedOnNode(node, "import");
     }
 
     uid = uid || node.specifiers[0].local;

src/babel/transformation/modules/system.js

@@ -1,57 +1,57 @@
 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";
 import map from "lodash/collection/map";
 import * as t from "../../types";
 
 var hoistVariablesVisitor = {
-  enter(node, parent, scope, state) {
-    if (t.isFunction(node)) {
-      // nothing inside is accessible
-      return this.skip();
+  Function() {
+    // nothing inside is accessible
+    this.skip();
+  },
+
+  VariableDeclaration(node, parent, scope, state) {
+    if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
+      // can't be accessed
+      return;
     }
 
-    if (t.isVariableDeclaration(node)) {
-      if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
-        // can't be accessed
-        return;
+    // ignore block hoisted nodes as these can be left in
+    if (state.formatter._canHoist(node)) return;
+
+    var nodes = [];
+
+    for (var i = 0; i < node.declarations.length; i++) {
+      var declar = node.declarations[i];
+      state.hoistDeclarators.push(t.variableDeclarator(declar.id));
+      if (declar.init) {
+        // no initializer so we can just hoist it as-is
+        var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
+        nodes.push(assign);
       }
-
-      // ignore block hoisted nodes as these can be left in
-      if (state.formatter.canHoist(node)) return;
-
-      var nodes = [];
-
-      for (var i = 0; i < node.declarations.length; i++) {
-        var declar = node.declarations[i];
-        state.hoistDeclarators.push(t.variableDeclarator(declar.id));
-        if (declar.init) {
-          // no initializer so we can just hoist it as-is
-          var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
-          nodes.push(assign);
-        }
-      }
-
-      // for (var i in test)
-      // for (var i = 0;;)
-      if (t.isFor(parent) && parent.left === node) {
-        return node.declarations[0].id;
-      }
-
-      return nodes;
     }
+
+    // for (var i in test)
+    // for (var i = 0;;)
+    if (t.isFor(parent) && (parent.left === node || parent.init === node)) {
+      return node.declarations[0].id;
+    }
+
+    return nodes;
   }
 };
 
 var hoistFunctionsVisitor = {
-  enter(node, parent, scope, state) {
-    if (t.isFunction(node)) this.skip();
+  Function() {
+    this.skip();
+  },
 
-    if (t.isFunctionDeclaration(node) || state.formatter.canHoist(node)) {
+  enter(node, parent, scope, state) {
+    if (t.isFunctionDeclaration(node) || state.formatter._canHoist(node)) {
       state.handlerBody.push(node);
-      this.remove();
+      this.dangerouslyRemove();
     }
   }
 };
@@ -60,17 +60,17 @@ 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);
       }
 
-      this.remove();
+      this.dangerouslyRemove();
     }
   }
 };
@@ -100,14 +100,14 @@ export default class SystemFormatter extends AMDFormatter {
     var right = objectIdentifier;
 
     var block = t.blockStatement([
-      t.expressionStatement(this.buildExportCall(leftIdentifier, valIdentifier))
+      t.expressionStatement(this._buildExportCall(leftIdentifier, valIdentifier))
     ]);
 
     return this._addImportSource(t.forInStatement(left, right, block), node);
   }
 
   buildExportsAssignment(id, init, node) {
-    var call = this.buildExportCall(t.literal(id.name), init, true);
+    var call = this._buildExportCall(t.literal(id.name), init, true);
     return this._addImportSource(call, node);
   }
 
@@ -119,13 +119,13 @@ export default class SystemFormatter extends AMDFormatter {
     var assign = node;
 
     for (var i = 0; i < exported.length; i++) {
-      assign = this.buildExportCall(t.literal(exported[i].name), assign);
+      assign = this._buildExportCall(t.literal(exported[i].name), assign);
     }
 
     return assign;
   }
 
-  buildExportCall(id, init, isStatement) {
+  _buildExportCall(id, init, isStatement) {
     var call = t.callExpression(this.exportIdentifier, [id, init]);
     if (isStatement) {
       return t.expressionStatement(call);
@@ -143,12 +143,12 @@ export default class SystemFormatter extends AMDFormatter {
       ]));
     }
 
-    this.internalRemap = {};
+    this.internalRemap = object();
 
     this._addImportSource(last(nodes), node);
   }
 
-  buildRunnerSetters(block, hoistDeclarators) {
+  _buildRunnerSetters(block, hoistDeclarators) {
     var scope = this.file.scope;
 
     return t.arrayExpression(map(this.ids, function (uid, source) {
@@ -164,7 +164,7 @@ export default class SystemFormatter extends AMDFormatter {
     }));
   }
 
-  canHoist(node) {
+  _canHoist(node) {
     return node._blockHoist && !this.file.dynamicImports.length;
   }
 
@@ -181,7 +181,7 @@ export default class SystemFormatter extends AMDFormatter {
       MODULE_DEPENDENCIES: t.arrayExpression(this.buildDependencyLiterals()),
       EXPORT_IDENTIFIER:   this.exportIdentifier,
       MODULE_NAME:         moduleNameLiteral,
-      SETTERS:             this.buildRunnerSetters(block, hoistDeclarators),
+      SETTERS:             this._buildRunnerSetters(block, hoistDeclarators),
       EXECUTE:             t.functionExpression(null, [], block)
     }, true);
 

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

@@ -28,8 +28,9 @@
 
     if (descriptor.initializer) {
       descriptor.value = descriptor.initializer.call(target);
-      Object.defineProperty(target, key, descriptor);
     }
+
+    Object.defineProperty(target, key, descriptor);
   }
 
   return target;

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

@@ -1,12 +1,12 @@
 (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
-  if (!descriptor.initializer) return;
   descriptor.value = descriptor.initializer.call(target);
 
   Object.defineProperty(target, key, descriptor);

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

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

src/babel/transformation/templates/helper-ludicrous-proxy-create.js

@@ -1,4 +0,0 @@
-(function (proxy, directory) {
-  directory.push(proxy);
-  return proxy;
-})

src/babel/transformation/templates/helper-ludicrous-proxy-directory.js

@@ -1 +0,0 @@
-[];

src/babel/transformation/templates/rest.js

@@ -1,3 +1,3 @@
-for (var LEN = ARGUMENTS.length, ARRAY = Array(ARRAY_LEN), KEY = START; KEY < LEN; KEY++) {
+for (var LEN = ARGUMENTS.length, ARRAY: ARRAY_TYPE = Array(ARRAY_LEN), KEY = START; KEY < LEN; KEY++) {
   ARRAY[ARRAY_KEY] = ARGUMENTS[KEY];
 }

src/babel/transformation/transformer-pass.js

@@ -1,5 +1,6 @@
-import includes from "lodash/collection/includes";
+import type Transformer from "./transformer";
 import traverse from "../traversal";
+import type File from "./file";
 
 /**
  * This class is responsible for traversing over the provided `File`s
@@ -8,35 +9,27 @@ import traverse from "../traversal";
 
 export default class TransformerPass {
   constructor(file: File, transformer: Transformer) {
-    this.shouldTransform = !transformer.shouldVisit;
-    this.transformer     = transformer;
-    this.handlers        = transformer.handlers;
-    this.skipKey         = transformer.skipKey;
-    this.file            = file;
-    this.ran             = false;
+    this.transformer = transformer;
+    this.handlers    = transformer.handlers;
+    this.file        = file;
+    this.key         = transformer.key;
+
+    if (this.canTransform() && transformer.metadata.experimental && !file.opts.experimental) {
+      file.log.warn(`THE TRANSFORMER ${this.key} HAS BEEN MARKED AS EXPERIMENTAL AND IS WIP. USE AT YOUR OWN RISK. ` +
+                    "THIS WILL HIGHLY LIKELY BREAK YOUR CODE SO USE WITH **EXTREME** CAUTION. ENABLE THE " +
+                    "`experimental` OPTION TO IGNORE THIS WARNING.");
+    }
   }
 
   canTransform(): boolean {
-    return this.file.pipeline.canTransform(this.transformer, this.file.opts);
-  }
-
-  checkPath(path: TraversalPath): boolean {
-    if (this.shouldTransform || this.ran) return;
-
-    this.shouldTransform = this.transformer.shouldVisit(path.node);
+    return this.file.transformerDependencies[this.key] ||
+           this.file.pipeline.canTransform(this.transformer, this.file.opts);
   }
 
   transform() {
-    if (!this.shouldTransform) return;
-
     var file = this.file;
-
-    file.log.debug(`Start 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.transformer.key}`);
-
-    this.ran = true;
+    file.log.debug(`Finish transformer ${this.key}`);
   }
 }

src/babel/transformation/transformer-pipeline.js

@@ -47,6 +47,8 @@ export default class TransformerPipeline {
   }
 
   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;
@@ -55,18 +57,33 @@ export default class TransformerPipeline {
     return true;
   }
 
+  pretransform(code: string, opts?: Object) {
+    var file = new File(opts, this);
+    return file.wrap(code, function () {
+      file.addCode(code);
+      file.parseCode(code);
+      return file;
+    });
+  }
+
   transform(code: string, opts?: Object) {
     var file = new File(opts, this);
-    return file.parse(code);
+    return file.wrap(code, function () {
+      file.addCode(code);
+      file.parseCode(code);
+      return file.transform();
+    });
   }
 
   transformFromAst(ast, code, opts) {
     ast = normalizeAst(ast);
 
     var file = new File(opts, this);
-    file.addCode(code);
-    file.transform(ast);
-    return file.generate();
+    return file.wrap(code, function () {
+      file.addCode(code);
+      file.addAst(ast);
+      return file.transform();
+    });
   }
 
   _ensureTransformerNames(type: string, rawKeys: Array<string>) {
@@ -81,7 +98,7 @@ export default class TransformerPipeline {
         keys.push(aliasKey);
       } else if (deprecatedKey) {
         // deprecated key, remap it to the new one
-        console.error(`The transformer ${key} has been renamed to ${deprecatedKey}`);
+        console.error(`[BABEL] The transformer ${key} has been renamed to ${deprecatedKey}`);
         rawKeys.push(deprecatedKey);
       } else if (this.transformers[key]) {
         // valid key

src/babel/transformation/transformer.js

@@ -4,7 +4,6 @@ import isFunction from "lodash/lang/isFunction";
 import traverse from "../traversal";
 import isObject from "lodash/lang/isObject";
 import assign from "lodash/object/assign";
-import * as acorn from "../../acorn";
 import File from "./file";
 import each from "lodash/collection/each";
 
@@ -25,8 +24,8 @@ export default class Transformer {
     };
 
     this.manipulateOptions = take("manipulateOptions");
-    this.shouldVisit       = take("shouldVisit");
     this.metadata          = take("metadata") || {};
+    this.dependencies      = this.metadata.dependencies || [];
     this.parser            = take("parser");
     this.post              = take("post");
     this.pre               = take("pre");
@@ -41,18 +40,6 @@ export default class Transformer {
 
     this.handlers = this.normalize(transformer);
     this.key      = transformerKey;
-
-    //
-
-    if (!this.shouldVisit) {
-      var types = Object.keys(this.handlers);
-      this.shouldVisit = function (node) {
-        for (var i = 0; i < types.length; i++) {
-          if (node.type === types[i]) return true;
-        }
-        return false;
-      };
-    }
   }
 
   normalize(transformer: Object): Object {

src/babel/transformation/transformers/aliases.json

@@ -1,5 +1,6 @@
 {
   "useStrict": "strict",
   "es5.runtime": "runtime",
-  "es6.runtime": "runtime"
+  "es6.runtime": "runtime",
+  "minification.inlineExpressions": "minification.constantFolding"
 }

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.constantFolding",
+  "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,17 +1,20 @@
 import * as defineMap from "../../helpers/define-map";
 import * as t from "../../../types";
 
-export function shouldVisit(node) {
-  return t.isProperty(node) && (node.kind === "get" || node.kind === "set");
-}
-
 export function ObjectExpression(node, parent, scope, file) {
-  var mutatorMap = {};
   var hasAny = false;
+  for (var prop of (node.properties: Array)) {
+    if (prop.kind === "get" || prop.kind === "set") {
+      hasAny = true;
+      break;
+    }
+  }
+  if (!hasAny) return;
+
+  var mutatorMap = {};
 
   node.properties = node.properties.filter(function (prop) {
     if (prop.kind === "get" || prop.kind === "set") {
-      hasAny = true;
       defineMap.push(mutatorMap, prop, prop.kind, file);
       return false;
     } else {
@@ -19,8 +22,6 @@ export function ObjectExpression(node, parent, scope, file) {
     }
   });
 
-  if (!hasAny) return;
-
   return t.callExpression(
     t.memberExpression(t.identifier("Object"), t.identifier("defineProperties")),
     [node, defineMap.toDefineObject(mutatorMap)]

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

@@ -1,13 +1,9 @@
 import * as t from "../../../types";
 
-export var shouldVisit = 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

@@ -1,3 +1,6 @@
+import type NodePath from "../../../traversal/path";
+import type Scope from "../../../traversal/scope";
+import type File from "../../file";
 import traverse from "../../../traversal";
 import object from "../../../helpers/object";
 import * as util from  "../../../util";
@@ -32,14 +35,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 shouldVisit(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;
@@ -84,8 +87,6 @@ export function BlockStatement(block, parent, scope, file) {
 export { BlockStatement as Program };
 
 function replace(node, parent, scope, remaps) {
-  if (!t.isReferencedIdentifier(node, parent)) return;
-
   var remap = remaps[node.name];
   if (!remap) return;
 
@@ -100,28 +101,33 @@ function replace(node, parent, scope, remaps) {
 }
 
 var replaceVisitor = {
-  enter: replace
+  ReferencedIdentifier: replace,
+
+  AssignmentExpression(node, parent, scope, remaps) {
+    var ids = this.getBindingIdentifiers();
+    for (var name in ids) {
+      replace(ids[name], node, scope, remaps);
+    }
+  },
 };
 
 function traverseReplace(node, parent, scope, remaps) {
-  replace(node, parent, scope, remaps);
+  if (t.isIdentifier(node)) {
+    replace(node, parent, scope, remaps);
+  }
+
   scope.traverse(node, replaceVisitor, 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
@@ -159,10 +165,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);
   }
 };
 
@@ -187,19 +191,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) {
@@ -215,6 +228,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;
       }
@@ -233,6 +249,7 @@ var loopVisitor = {
 
     if (replace) {
       replace = t.returnStatement(replace);
+      this.skip();
       return t.inherits(replace, node);
     }
   }
@@ -244,7 +261,7 @@ class BlockScoping {
    * Description
    */
 
-  constructor(loopPath?: TraversalPath, blockPath: TraversalPath, parent: Object, scope: Scope, file: File) {
+  constructor(loopPath?: NodePath, blockPath: NodePath, parent: Object, scope: Scope, file: File) {
     this.parent = parent;
     this.scope  = scope;
     this.file   = file;
@@ -467,18 +484,17 @@ class BlockScoping {
     var block = this.block;
 
     var declarators = block._letDeclarators || [];
-    var declar;
 
     //
     for (let i = 0; i < declarators.length; i++) {
-      declar = declarators[i];
+      let declar = declarators[i];
       extend(this.outsideLetReferences, t.getBindingIdentifiers(declar));
     }
 
     //
     if (block.body) {
       for (let i = 0; i < block.body.length; i++) {
-        declar = block.body[i];
+        let declar = block.body[i];
         if (isLet(declar, block)) {
           declarators = declarators.concat(declar.declarations);
         }
@@ -487,7 +503,7 @@ class BlockScoping {
 
     //
     for (let i = 0; i < declarators.length; i++) {
-      declar = declarators[i];
+      let declar = declarators[i];
       var keys = t.getBindingIdentifiers(declar);
       extend(this.letReferences, keys);
       this.hasLetReferences = true;
@@ -524,6 +540,7 @@ class BlockScoping {
     var state = {
       hasBreakContinue: false,
       ignoreLabeless:   false,
+      inSwitchCase:     false,
       innerLabels:      [],
       hasReturn:        false,
       isLoop:           !!this.loop,
@@ -551,9 +568,13 @@ class BlockScoping {
    */
 
   pushDeclar(node: { type: "VariableDeclaration" }): Array<Object> {
-    this.body.push(t.variableDeclaration(node.kind, node.declarations.map(function (declar) {
-      return t.variableDeclarator(declar.id);
-    })));
+    var declars = [];
+    var names = t.getBindingIdentifiers(node);
+    for (var name in names) {
+      declars.push(t.variableDeclarator(names[name]));
+    }
+
+    this.body.push(t.variableDeclaration(node.kind, declars));
 
     var replace = [];
 
@@ -579,7 +600,6 @@ class BlockScoping {
       t.variableDeclarator(ret, call)
     ]));
 
-    var loop = this.loop;
     var retCheck;
     var has = this.has;
     var cases = [];

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

@@ -1,18 +1,15 @@
+import type NodePath from "../../../traversal/path";
+import type File from "../../file";
 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";
 import * as messages from "../../../messages";
 import * as util from  "../../../util";
-import traverse from "../../../traversal";
-import each from "lodash/collection/each";
-import has from "lodash/object/has";
 import * as t from "../../../types";
 
 const PROPERTY_COLLISION_METHOD_NAME = "__initializeProperties";
 
-export var shouldVisit = t.isClass;
-
 export function ClassDeclaration(node, parent, scope, file) {
   return t.variableDeclaration("let", [
     t.variableDeclarator(node.id, t.toExpression(node))
@@ -37,23 +34,7 @@ var collectPropertyReferencesVisitor = {
   }
 };
 
-var constructorVisitor = traverse.explode({
-  ThisExpression: {
-    enter(node, parent, scope, ref) {
-      return ref;
-    }
-  },
-
-  Function: {
-    enter(node) {
-      if (!node.shadow) {
-        this.skip();
-      }
-    }
-  }
-});
-
-var verifyConstructorVisitor = traverse.explode({
+var verifyConstructorVisitor = {
   MethodDefinition: {
     enter() {
       this.skip();
@@ -96,13 +77,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 {
 
@@ -110,7 +87,7 @@ class ClassTransformer {
    * Description
    */
 
-  constructor(path: TraversalPath, file: File) {
+  constructor(path: NodePath, file: File) {
     this.parent = path.parent;
     this.scope  = path.scope;
     this.node   = path.node;
@@ -147,22 +124,11 @@ class ClassTransformer {
 
   run() {
     var superName = this.superName;
-    var className = this.className;
-    var classBody = this.node.body.body;
     var classRef  = this.classRef;
     var file      = this.file;
 
     //
 
-    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;
 
     //
@@ -188,7 +154,7 @@ class ClassTransformer {
     if (this.hasSuper) {
       closureArgs.push(superName);
 
-      superName = this.scope.generateUidBasedOnNode(superName);
+      superName = this.scope.generateUidIdentifierBasedOnNode(superName);
       closureParams.push(superName);
 
       this.superName = superName;
@@ -234,12 +200,6 @@ 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]);
@@ -283,7 +243,7 @@ class ClassTransformer {
     var map = defineMap.push(mutatorMap, node, kind, this.file);
 
     if (enumerable) {
-      map.enumerable = t.literal(true)
+      map.enumerable = t.literal(true);
     }
 
     if (map.decorators) {
@@ -297,9 +257,6 @@ class ClassTransformer {
 
   buildBody() {
     var constructorBody = this.constructorBody;
-    var constructor     = this.constructor;
-    var className       = this.className;
-    var superName       = this.superName;
     var classBody       = this.node.body.body;
     var body            = this.body;
 
@@ -333,7 +290,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);
@@ -344,9 +301,7 @@ 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: this.classRef,
         SUPER_NAME: this.superName
       }, true));
@@ -398,7 +353,7 @@ class ClassTransformer {
       }
 
       var lastNonNullIndex = 0;
-      for (var i = 0; i < args.length; i++) {
+      for (let i = 0; i < args.length; i++) {
         if (args[i] !== nullNode) lastNonNullIndex = i;
       }
       args = args.slice(0, lastNonNullIndex + 1);
@@ -433,7 +388,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);
@@ -473,14 +428,12 @@ class ClassTransformer {
    * Description
    */
 
-   verifyConstructor(path: TraversalPath) {
+   verifyConstructor(path: NodePath) {
     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);
@@ -490,36 +443,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?: NodePath, 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;
@@ -541,8 +479,6 @@ class ClassTransformer {
    */
 
   pushProperty(node: { type: "ClassProperty" }) {
-    var key;
-
     this.scope.traverse(node, collectPropertyReferencesVisitor, {
       references: this.instancePropRefs,
       scope:      this.scope
@@ -559,7 +495,6 @@ class ClassTransformer {
       this.pushToMap(node, true, "initializer");
 
       var initializers;
-      var body;
       var target;
       if (node.static) {
         initializers = this.staticInitializersId = this.staticInitializersId || this.scope.generateUidIdentifier("staticInitializers");
@@ -598,17 +533,13 @@ class ClassTransformer {
    * Replace the constructor body of our class.
    */
 
-  pushConstructor(method: { type: "MethodDefinition" }, path: TraversalPath) {
+  pushConstructor(method: { type: "MethodDefinition" }, path: NodePath) {
     // https://github.com/babel/babel/issues/1077
     var fnPath = path.get("value");
     if (fnPath.scope.hasOwnBinding(this.classRef.name)) {
       fnPath.scope.rename(this.classRef.name);
     }
 
-    if (this.isNativeSuper) {
-      fnPath.traverse(constructorVisitor, this.nativeSuperRef);
-    }
-
     var construct = this.constructor;
     var fn        = method.value;
 

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

@@ -1,48 +1,41 @@
 import * as messages from "../../../messages";
-import * as t from "../../../types";
 
-export function shouldVisit(node) {
-  return t.isVariableDeclaration(node, { kind: "const" }) || t.isImportDeclaration(node);
-}
+function checkPath(path, file) {
+  var ids = path.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 = path.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 function AssignmentExpression(node, parent, scope, file) {
+  checkPath(this, file);
+}
+
+export { AssignmentExpression as UpdateExpression };
+
 export function VariableDeclaration(node) {
   if (node.kind === "const") node.kind = "let";
 }
+
+export function ForXStatement(node, parent, scope, file) {
+  var left = this.get("left");
+  if (left.isIdentifier() || left.isPattern()) {
+    checkPath(left, file);
+  }
+}

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

@@ -1,7 +1,9 @@
 import * as messages from "../../../messages";
 import * as t from "../../../types";
 
-export var shouldVisit = 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/*tion*/(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,
@@ -82,8 +85,7 @@ exports.Function = function (node, parent, scope, file) {
 
   var block = node.body;
   block.body = nodes.concat(block.body);
-  return node;
-};
+}
 
 export function CatchClause(node, parent, scope, file) {
   var pattern = node.param;
@@ -103,34 +105,12 @@ 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 (this.isCompletionRecord()) return;
-
-  var destructuring = new DestructuringTransformer({
-    operator: expr.operator,
-    scope:    scope,
-    file:     file,
-  });
-
-  return destructuring.init(expr.left, expr.right);
 }
 
 export function AssignmentExpression(node, parent, scope, file) {
   if (!t.isPattern(node.left)) return;
 
-  var ref = scope.generateUidIdentifier("temp");
-
   var nodes = [];
-  nodes.push(t.variableDeclaration("var", [
-    t.variableDeclarator(ref, node.right)
-  ]));
 
   var destructuring = new DestructuringTransformer({
     operator: node.operator,
@@ -139,13 +119,24 @@ export function AssignmentExpression(node, parent, scope, file) {
     nodes: nodes
   });
 
-  if (t.isArrayExpression(node.right)) {
-    destructuring.arrays[ref.name] = true;
+  var ref;
+  if (this.isCompletionRecord() || !this.parentPath.isExpressionStatement()) {
+    ref = scope.generateUidIdentifierBasedOnNode(node.right, "ref");
+
+    nodes.push(t.variableDeclaration("var", [
+      t.variableDeclarator(ref, node.right)
+    ]));
+
+    if (t.isArrayExpression(node.right)) {
+      destructuring.arrays[ref.name] = true;
+    }
   }
 
-  destructuring.init(node.left, ref);
+  destructuring.init(node.left, ref || node.right);
 
-  nodes.push(t.expressionStatement(ref));
+  if (ref) {
+    nodes.push(t.expressionStatement(ref));
+  }
 
   return nodes;
 }
@@ -160,7 +151,7 @@ function variableDeclarationHasPattern(node) {
 }
 
 export function VariableDeclaration(node, parent, scope, file) {
-  if (t.isForInStatement(parent) || t.isForOfStatement(parent)) return;
+  if (t.isForXStatement(parent)) return;
   if (!variableDeclarationHasPattern(node)) return;
 
   var nodes = [];
@@ -179,7 +170,7 @@ export function VariableDeclaration(node, parent, scope, file) {
       file:  file
     });
 
-    if (t.isPattern(pattern) && patternId) {
+    if (t.isPattern(pattern)) {
       destructuring.init(pattern, patternId);
 
       if (+i !== node.declarations.length - 1) {
@@ -295,7 +286,7 @@ class DestructuringTransformer {
     // we need to assign the current value of the assignment to avoid evaluating
     // it more than once
 
-    var tempValueRef = this.scope.generateUidBasedOnNode(valueRef);
+    var tempValueRef = this.scope.generateUidIdentifierBasedOnNode(valueRef);
 
     var declar = t.variableDeclaration("var", [
       t.variableDeclarator(tempValueRef, valueRef)
@@ -377,7 +368,7 @@ class DestructuringTransformer {
     // only evaluated once
 
     if (pattern.properties.length > 1 && t.isMemberExpression(objRef)) {
-      var temp = this.scope.generateUidBasedOnNode(objRef, this.file);
+      var temp = this.scope.generateUidIdentifierBasedOnNode(objRef, this.file);
       this.nodes.push(this.buildVariableDeclaration(temp, objRef));
       objRef = temp;
     }
@@ -461,7 +452,7 @@ class DestructuringTransformer {
       // array
       arrayRef = toArray;
     } else {
-      arrayRef = this.scope.generateUidBasedOnNode(arrayRef);
+      arrayRef = this.scope.generateUidIdentifierBasedOnNode(arrayRef);
       this.arrays[arrayRef.name] = true;
       this.nodes.push(this.buildVariableDeclaration(arrayRef, toArray));
     }
@@ -498,9 +489,8 @@ class DestructuringTransformer {
     // trying to destructure a value that we can't evaluate more than once so we
     // need to save it to a variable
 
-    var shouldMemoise = true;
     if (!t.isArrayExpression(ref) && !t.isMemberExpression(ref)) {
-      var memo = this.scope.generateMemoisedReference(ref, true);
+      var memo = this.scope.maybeGenerateMemoised(ref, true);
       if (memo) {
         this.nodes.push(this.buildVariableDeclaration(memo, ref));
         ref = memo;

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 shouldVisit = t.isForOfStatement;
-
 export function ForOfStatement(node, parent, scope, file) {
   if (this.get("right").isArrayExpression()) {
     return _ForOfStatementArray.call(this, node, scope, file);
@@ -33,9 +31,9 @@ export function ForOfStatement(node, parent, scope, file) {
 
   if (build.replaceParent) {
     this.parentPath.replaceWithMultiple(build.node);
-    this.remove();
+    this.dangerouslyRemove();
   } else {
-    this.replaceWithMultiple(build.node);
+    return build.node;
   }
 }
 

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;
@@ -17,8 +19,8 @@ export function ImportDeclaration(node, parent, scope, file) {
   var nodes = [];
 
   if (node.specifiers.length) {
-    for (var i = 0; i < node.specifiers.length; i++) {
-      file.moduleFormatter.importSpecifier(node.specifiers[i], node, nodes, parent);
+    for (var specifier of (node.specifiers: Array)) {
+      file.moduleFormatter.importSpecifier(specifier, node, nodes, parent);
     }
   } else {
     file.moduleFormatter.importDeclaration(node, nodes, parent);

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

@@ -1,33 +1,20 @@
 import ReplaceSupers from "../../helpers/replace-supers";
 import * as t from "../../../types";
 
-export var shouldVisit = 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) {

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

@@ -2,10 +2,6 @@ import callDelegate from "../../helpers/call-delegate";
 import * as util from  "../../../util";
 import * as t from "../../../types";
 
-export function shouldVisit(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 +10,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/*tion*/(node, parent, scope, file) {
   if (!hasDefaults(node)) return;
 
   t.ensureBlock(node);
@@ -96,6 +93,4 @@ exports.Function = function (node, parent, scope, file) {
   } else {
     node.body.body = body.concat(node.body.body);
   }
-
-  return node;
-};
+}