v4.7.2

Add choice of output format to babel-external-helpers

CHANGELOG.md

@@ -13,6 +13,78 @@ _Note: Gaps between patch versions are faulty/broken releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 4.7.2
+
+ * **New Feature**
+  * `"both"` option for `sourceMap`.
+  * Add output types to external helpers. Thanks [@neVERberleRfellerER](https://github.com/neVERberleRfellerER)!
+ * **Bug Fix**
+  * Fix node duplication sometimes resulting in a recursion error.
+  * Ignore `break`s within cases inside `for...of`.
+ * **Polish**
+  * Split up variable declarations and export declarations to allow easier transformation.
+
+## 4.7.0
+
+ * **Bug Fix**
+  * Add `alternate` to list of `STATEMENT_OR_BLOCK` keys.
+  * Add support for module specifiers to `t.isReferenced`.
+ * **New Feature**
+  * Add `inputSourceMap` option.
+ * **Polish**
+  * Throw an error on different `babel` and `babel-runtime` versions.
+  * Replicate module environment for `babel-node` eval.
+  * Clean up classes output.
+ * **Spec Compliancy**
+  * Make it illegal to use a rest parameter on a setter.
+
+## 4.6.6
+
+ * **Bug Fix**
+  * Fix incorrect method call in `utility.deadCodeElimination` transformer.
+  * Fix `es6.blockScopingTDZ` transformer duplicating binding nodes.
+
+## 4.6.5
+
+ * **Internal**
+  * `useStrict` transformer has been renamed to `strict`.
+
+## 4.6.4
+
+ * **Bug Fix**
+  * Fix `ForOfStatement` not proplery inheriting labels.
+  * When in closure mode in block scoping transformer, properly check for variable shadowing.
+ * **New Feature**
+  * New `utility.inlineEnvironmentVariables` and `utility.inlineExpression` transformers.
+
+## 4.6.3
+
+ * **Bug Fix**
+  * Fix `arguments` being incorrectly aliased in arrow function rest parameter optimisation.
+  * Make deoptimisation trigger safer.
+ * **New Feature**
+  * Flow types are now retained when blacklisting the `flow` transformer.
+
+## 4.6.1
+
+ * **Bug Fix**
+  * Fix generators in template directory being transformed.
+  * Fix exposure of `util` for plugins.
+
+## 4.6.0
+
+ * **New Feature**
+  * Desugar sticky regexes to a new constructor expression so it can be handled by a polyfill.
+ * **Spec Compliancy**
+  * `for...of` now outputs in a lengthy `try...catch` this is to ensure spec compliancy in regards to iterator returns and abrupt completions. See [google/traceur-compiler#1773](https://github.com/google/traceur-compiler/issues/1773) and [babel/babel/#838](https://github.com/babel/babel/issues/838) for more information.
+ * **Polish**
+  * Rest parameters that are only refered to via number properties on member expressions are desugared into a direct `arguments` reference. Thanks [@neVERberleRfellerER](https://github.com/neVERberleRfellerER)!
+  * `$ babel` no longer exits on syntax errors.
+ * **Internal**
+  * Upgrade `browserify`.
+  * Upgrade `source-map`.
+  * Publicly expose more internals.
+
 ## 4.5.5
 
  * **Polish**

CONTRIBUTING.md

@@ -53,7 +53,6 @@ $ mocha test/transformation.js
 #### Code Standards
 
  * **General**
-   * No ES6 syntax features or methods, exclusively ES5.
    * Max of five arguments for functions
    * Max depth of four nested blocks
    * 2-spaced soft tabs

bin/_babel-node

@@ -60,7 +60,18 @@ if (program.eval || program.print) {
   var code = program.eval;
   if (!code || code === true) code = program.print;
 
-  var result = _eval(code, "eval");
+  global.__filename = "[eval]";
+  global.__dirname = process.cwd();
+
+  var module = new Module(global.__filename);
+  module.filename = global.__filename;
+  module.paths    = Module._nodeModulePaths(global.__dirname);
+
+  global.exports = module.exports;
+  global.module  = module;
+  global.require = module.require.bind(module);
+
+  var result = _eval(code, global.__filename);
   if (program.print) console.log(result);
 } else {
   if (program.args.length) {
@@ -88,7 +99,7 @@ if (program.eval || program.print) {
     args = args.slice(i);
 
     // make the filename absolute
-    var filename = args[0]
+    var filename = args[0];
     if (!pathIsAbsolute(filename)) args[0] = path.join(process.cwd(), filename);
 
     // add back on node and concat the sliced args

bin/babel-external-helpers

@@ -1,4 +1,13 @@
 #!/usr/bin/env node
 
+var commander = require("commander");
+var util      = require("../lib/babel/util");
 var runtime = require("../lib/babel/build-external-helpers");
-console.log(runtime());
+
+commander.option("-l, --whitelist [whitelist]", "Whitelist of helpers to ONLY include", util.list);
+commander.option("-t, --output-type [type]", "Type of output (global|umd|var)", "global");
+
+commander.usage("[options]");
+commander.parse(process.argv);
+
+console.log(runtime(commander.whitelist, commander.outputType));

bin/babel-node

@@ -7,7 +7,17 @@
 
 var args  = [__dirname + "/_babel-node"];
 
-process.argv.slice(2).forEach(function(arg){
+var babelArgs = process.argv.slice(2);
+var userArgs;
+
+// separate node arguments from script arguments
+var argSeparator = babelArgs.indexOf("--");
+if (argSeparator > -1) {
+  userArgs  = babelArgs.slice(argSeparator); // including the  --
+  babelArgs = babelArgs.slice(0, argSeparator);
+}
+
+babelArgs.forEach(function(arg){
   var flag = arg.split("=")[0];
 
   switch (flag) {
@@ -49,6 +59,11 @@ process.argv.slice(2).forEach(function(arg){
   }
 });
 
+// append arguments passed after --
+if (argSeparator > -1) {
+  args = args.concat(userArgs);
+}
+
 try {
   var kexec = require("kexec");
   kexec(process.argv[0], args);

bin/babel/dir.js

@@ -31,6 +31,14 @@ module.exports = function (commander, filenames, opts) {
     console.log(src + " -> " + dest);
   };
 
+  var handleFile = function (src, filename) {
+    if (util.canCompile(filename)) {
+      write(src, filename);
+    } else if (commander.copyFiles) {
+      outputFileSync(path.join(commander.outDir, filename), fs.readFileSync(src));
+    }
+  };
+
   var handle = function (filename) {
     if (!fs.existsSync(filename)) return;
 
@@ -41,11 +49,7 @@ module.exports = function (commander, filenames, opts) {
 
       _.each(util.readdir(dirname), function (filename) {
         var src = path.join(dirname, filename);
-        if (util.canCompile(filename)) {
-          write(src, filename);
-        } else if (commander.copyFiles) {
-          outputFileSync(path.join(commander.outDir, filename), fs.readFileSync(src));
-        }
+        handleFile(src, filename);
       });
     } else {
       write(filename, filename);
@@ -65,7 +69,7 @@ module.exports = function (commander, filenames, opts) {
         watcher.on(type, function (filename) {
           var relative = path.relative(dirname, filename) || filename;
           try {
-            if (util.canCompile(filename)) write(filename, relative);
+            handleFile(filename, relative);
           } catch (err) {
             console.error(err.stack);
           }

bin/babel/file.js

@@ -1,10 +1,10 @@
-var sourceMapToComment = require("source-map-to-comment");
-var sourceMap          = require("source-map");
-var chokidar           = require("chokidar");
-var path               = require("path");
-var util               = require("./util");
-var fs                 = require("fs");
-var _                  = require("lodash");
+var convertSourceMap = require("convert-source-map");
+var sourceMap        = require("source-map");
+var chokidar         = require("chokidar");
+var path             = require("path");
+var util             = require("./util");
+var fs               = require("fs");
+var _                = require("lodash");
 
 module.exports = function (commander, filenames) {
   var results = [];
@@ -42,7 +42,7 @@ module.exports = function (commander, filenames) {
     });
 
     if (commander.sourceMapsInline || (!commander.outFile && commander.sourceMaps)) {
-      code += "\n" + sourceMapToComment(map);
+      code += "\n" + convertSourceMap.fromObject(map).toComment();
     }
 
     return {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "4.6.0",
+  "version": "4.7.2",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
   "repository": "babel/babel",
@@ -36,11 +36,12 @@
     "test": "make test"
   },
   "dependencies": {
-    "acorn-babel": "0.11.1-35",
-    "ast-types": "~0.6.1",
+    "acorn-babel": "0.11.1-37",
+    "ast-types": "~0.7.0",
     "chalk": "^1.0.0",
     "chokidar": "^0.12.6",
     "commander": "^2.6.0",
+    "convert-source-map": "^0.5.0",
     "core-js": "^0.6.1",
     "debug": "^2.1.1",
     "detect-indent": "^3.0.0",
@@ -56,22 +57,22 @@
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
     "private": "^0.1.6",
-    "regenerator-babel": "0.8.13-1",
-    "regexpu": "^1.1.1",
+    "regenerator-babel": "0.8.13-2",
+    "regexpu": "^1.1.2",
     "repeating": "^1.1.2",
     "shebang-regex": "^1.0.0",
     "slash": "^1.0.0",
     "source-map": "^0.4.0",
     "source-map-support": "^0.2.9",
-    "source-map-to-comment": "^1.0.0",
+    "to-fast-properties": "^1.0.0",
     "trim-right": "^1.0.0"
   },
   "devDependencies": {
-    "babel": "4.5.1",
+    "babel": "4.6.0",
     "browserify": "^9.0.3",
     "chai": "^2.0.0",
     "eslint": "^0.15.1",
-    "babel-eslint": "^1.0.0",
+    "babel-eslint": "^1.0.1",
     "esvalid": "^1.1.0",
     "istanbul": "^0.3.5",
     "matcha": "^0.6.0",

packages/babel-runtime/package.json

@@ -1,7 +1,7 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "4.5.5",
+  "version": "4.7.1",
   "repository": "babel/babel",
   "author": "Sebastian McKenzie <sebmck@gmail.com>"
 }

src/babel/api/browser.js

@@ -25,7 +25,7 @@ transform.load = function (url, callback, opts = {}, hold) {
       if (!hold) transform.run.apply(transform, param);
       if (callback) callback(param);
     } else {
-      throw new Error("Could not load " + url);
+      throw new Error(`Could not load ${url}`);
     }
   };
 

src/babel/api/node.js

@@ -2,8 +2,11 @@ import isFunction from "lodash/lang/isFunction";
 import transform from "../transformation";
 import fs from "fs";
 
+import * as util from "../util";
+export { util as _util };
+export { canCompile } from "../util";
+
 export { default as acorn } from "acorn-babel";
-export { default as _util, canCompile } from "../util";
 export { default as transform } from "../transformation";
 export { default as traverse } from "../traversal";
 export { default as buildExternalHelpers } from "../build-external-helpers";

src/babel/api/register/node.js

@@ -46,7 +46,7 @@ var compile = function (filename) {
   var opts = extend({}, transformOpts);
   resolveRc(filename, opts);
 
-  var cacheKey = filename + ":" + JSON.stringify(opts);
+  var cacheKey = `${filename}:${JSON.stringify(opts)}`;
 
   if (cache) {
     var cached = cache[cacheKey];
@@ -57,7 +57,7 @@ var compile = function (filename) {
 
   if (!result) {
     result = babel.transformFileSync(filename, extend(opts, {
-      sourceMap: true,
+      sourceMap: "both",
       ast:       false
     }));
   }
@@ -153,3 +153,16 @@ export default function (opts = {}) {
 
   extend(transformOpts, opts);
 };
+
+//
+
+try {
+  var runtimePackage = require("babel-runtime/package");
+  var version = require("../../package").version;
+  if (runtimePackage.version !== version) {
+    throw new ReferenceError(`The verison of babel-runtime of ${runtimePackage.runtime} that you have installed does not match the babel verison of ${version}`);
+  }
+} catch (err) {
+  if (err.code !== "MODULE_NOT_FOUND") throw err;
+}
+

src/babel/api/register/resolve-rc.js

@@ -23,7 +23,7 @@ export default function (loc, opts = {}) {
       try {
         json = JSON.parse(content);
       } catch (err) {
-        err.message = file + ": " + err.message;
+        err.message = `${file}: ${err.message}`;
         throw err;
       }
 

src/babel/build-external-helpers.js

@@ -1,11 +1,10 @@
 import buildHelpers from "./build-helpers";
 import generator from "./generation";
+import * as messages from "./messages";
 import * as util from  "./util";
 import t from "./types";
 
-export default function (whitelist) {
-  var namespace = t.identifier("babelHelpers");
-
+function buildGlobal(namespace, builder) {
   var body      = [];
   var container = t.functionExpression(null, [t.identifier("global")], t.blockStatement(body));
   var tree      = t.program([t.expressionStatement(t.callExpression(container, [util.template("self-global")]))]);
@@ -17,7 +16,58 @@ export default function (whitelist) {
     )
   ]));
 
-  buildHelpers(body, namespace, whitelist);
+  builder(body);
+
+  return tree;
+}
+
+function buildUmd(namespace, builder) {
+  var body = [];
+  body.push(t.variableDeclaration("var", [
+    t.variableDeclarator(namespace, t.identifier("global"))
+  ]));
+
+  builder(body);
+
+  var container = util.template("umd-commonjs-strict", {
+    FACTORY_PARAMETERS: t.identifier("global"),
+    BROWSER_ARGUMENTS:  t.assignmentExpression("=", t.memberExpression(t.identifier("root"), namespace), t.objectExpression({})),
+    COMMON_ARGUMENTS:   t.identifier("exports"),
+    AMD_ARGUMENTS:      t.arrayExpression([t.literal("exports")]),
+    FACTORY_BODY:       body,
+    UMD_ROOT:           t.identifier("this")
+  });
+  return t.program([container]);
+}
+
+function buildVar(namespace, builder) {
+  var body = [];
+  body.push(t.variableDeclaration("var", [
+    t.variableDeclarator(namespace, t.objectExpression({}))
+  ]));
+  builder(body);
+  return t.program(body);
+}
+
+export default function (whitelist, outputType = "global") {
+  var namespace = t.identifier("babelHelpers");
+  var builder = function (body) {
+    return buildHelpers(body, namespace, whitelist);
+  };
+
+  var tree;
+
+  var build = {
+    global: buildGlobal,
+    umd:    buildUmd,
+    var:    buildVar
+  }[outputType];
+
+  if (build) {
+    tree = build(namespace, builder);
+  } else {
+    throw new Error(messages.get("unsupportedOutputType", outputType));
+  }
 
   return generator(tree).code;
 };

src/babel/generation/buffer.js

@@ -140,7 +140,7 @@ export default class Buffer {
       var indent = this.getIndent();
 
       // replace all newlines with newlines with the indentation
-      str = str.replace(/\n/g, "\n" + indent);
+      str = str.replace(/\n/g, `\n${indent}`);
 
       // we've got a newline before us so prepend on the indentation
       if (this.isLast("\n")) this._push(indent);

src/babel/generation/generators/classes.js

@@ -1,5 +1,4 @@
-exports.ClassExpression =
-exports.ClassDeclaration = function (node, print) {
+export function ClassDeclaration(node, print) {
   this.push("class");
 
   if (node.id) {
@@ -7,14 +6,24 @@ exports.ClassDeclaration = function (node, print) {
     print(node.id);
   }
 
+  print(node.typeParameters);
+
   if (node.superClass) {
     this.push(" extends ");
     print(node.superClass);
+    print(node.superTypeParameters);
+  }
+
+  if (node.implements) {
+    this.push(" implements ");
+    print.join(node.implements, { separator: ", " });
   }
 
   this.space();
   print(node.body);
-};
+}
+
+export { ClassDeclaration as ClassExpression };
 
 export function ClassBody(node, print) {
   if (node.body.length === 0) {

src/babel/generation/generators/expressions.js

@@ -109,16 +109,19 @@ export function ExpressionStatement(node, print) {
   this.semicolon();
 }
 
-exports.BinaryExpression =
-exports.LogicalExpression =
-exports.AssignmentPattern =
-exports.AssignmentExpression = function (node, print) {
+export function AssignmentExpression(node, print) {
   // todo: add cases where the spaces can be dropped when in compact mode
   print(node.left);
   this.push(" ");
   this.push(node.operator);
   this.push(" ");
   print(node.right);
+}
+
+export {
+  AssignmentExpression as BinaryExpression,
+  AssignmentExpression as LogicalExpression,
+  AssignmentExpression as AssignmentPattern
 };
 
 var SCIENTIFIC_NOTATION = /e/i;

src/babel/generation/generators/flow.js

@@ -1,34 +1,226 @@
-exports.AnyTypeAnnotation =
-exports.ArrayTypeAnnotation =
-exports.BooleanTypeAnnotation =
-exports.ClassProperty =
-exports.DeclareClass =
-exports.DeclareFunction =
-exports.DeclareModule =
-exports.DeclareVariable =
-exports.FunctionTypeAnnotation =
-exports.FunctionTypeParam =
-exports.GenericTypeAnnotation =
-exports.InterfaceExtends =
-exports.InterfaceDeclaration =
-exports.IntersectionTypeAnnotation =
-exports.NullableTypeAnnotation =
-exports.NumberTypeAnnotation =
-exports.StringLiteralTypeAnnotation =
-exports.StringTypeAnnotation =
-exports.TupleTypeAnnotation =
-exports.TypeofTypeAnnotation =
-exports.TypeAlias =
-exports.TypeAnnotation =
-exports.TypeParameterDeclaration =
-exports.TypeParameterInstantiation =
-exports.ObjectTypeAnnotation =
-exports.ObjectTypeCallProperty =
-exports.ObjectTypeIndexer =
-exports.ObjectTypeProperty =
-exports.QualifiedTypeIdentifier =
-exports.UnionTypeAnnotation =
-exports.TypeCastExpression =
-exports.VoidTypeAnnotation = function () {
-  // todo: implement these once we have a `--keep-types` option
-};
+import t from "../../types";
+
+export function AnyTypeAnnotation() {
+  this.push("any");
+}
+
+export function ArrayTypeAnnotation(node, print) {
+  print(node.elementType);
+  this.push("[");
+  this.push("]");
+}
+
+export function BooleanTypeAnnotation(node) {
+  this.push("bool");
+}
+
+export function ClassProperty(node, print) {
+  if (node.static) this.push("static ");
+  print(node.key);
+  print(node.typeAnnotation);
+  this.semicolon();
+}
+
+export function DeclareClass(node, print) {
+  this.push("declare class ");
+  this._interfaceish(node, print);
+}
+
+export function DeclareFunction(node, print) {
+  this.push("declare function ");
+  print(node.id);
+  print(node.id.typeAnnotation.typeAnnotation);
+  this.semicolon();
+}
+
+export function DeclareModule(node, print) {
+  this.push("declare module ");
+  print(node.id);
+  this.space();
+  print(node.body);
+}
+
+export function DeclareVariable(node, print) {
+  this.push("declare var ");
+  print(node.id);
+  print(node.id.typeAnnotation);
+  this.semicolon();
+}
+
+export function FunctionTypeAnnotation(node, print, parent) {
+  print(node.typeParameters);
+  this.push("(");
+  print.list(node.params);
+
+  if (node.rest) {
+    if (node.params.length) {
+      this.push(",");
+      this.space();
+    }
+    this.push("...");
+    print(node.rest);
+  }
+
+  this.push(")");
+
+  // this node type is overloaded, not sure why but it makes it EXTREMELY annoying
+  if (parent.type === "ObjectTypeProperty" || parent.type === "ObjectTypeCallProperty" || parent.type === "DeclareFunction") {
+    this.push(":");
+  } else {
+    this.space();
+    this.push("=>");
+  }
+
+  this.space();
+  print(node.returnType);
+}
+
+export function FunctionTypeParam(node, print) {
+  print(node.name);
+  if (node.optional) this.push("?");
+  this.push(":");
+  this.space();
+  print(node.typeAnnotation);
+}
+
+export function InterfaceExtends(node, print) {
+  print(node.id);
+  print(node.typeParameters);
+}
+
+export { InterfaceExtends as ClassImplements, InterfaceExtends as GenericTypeAnnotation };
+
+export function _interfaceish(node, print) {
+  print(node.id);
+  print(node.typeParameters);
+  if (node.extends.length) {
+    this.push(" extends ");
+    print.join(node.extends, { separator: ", " });
+  }
+  this.space();
+  print(node.body);
+}
+
+export function InterfaceDeclaration(node, print) {
+  this.push("interface ");
+  this._interfaceish(node, print);
+}
+
+export function IntersectionTypeAnnotation(node, print) {
+  print.join(node.types, { separator: " & " });
+}
+
+export function NullableTypeAnnotation(node, print) {
+  this.push("?");
+  print(node.typeAnnotation);
+}
+
+export function NumberTypeAnnotation() {
+  this.push("number");
+}
+
+export function StringLiteralTypeAnnotation(node) {
+  this._stringLiteral(node.value);
+}
+
+export function StringTypeAnnotation() {
+  this.push("string");
+}
+
+export function TupleTypeAnnotation(node, print) {
+  this.push("[");
+  print.join(node.types, { separator: ", " });
+  this.push("]");
+}
+
+export function TypeofTypeAnnotation(node, print) {
+  this.push("typeof ");
+  print(node.argument);
+}
+
+export function TypeAlias(node, print) {
+  this.push("type ");
+  print(node.id);
+  print(node.typeParameters);
+  this.space();
+  this.push("=");
+  this.space();
+  print(node.right);
+  this.semicolon();
+}
+
+export function TypeAnnotation(node, print) {
+  this.push(":");
+  this.space();
+  if (node.optional) this.push("?");
+  print(node.typeAnnotation);
+}
+
+export function TypeParameterInstantiation(node, print) {
+  this.push("<");
+  print.join(node.params, { separator: ", " });
+  this.push(">");
+}
+
+export { TypeParameterInstantiation as TypeParameterDeclaration };
+
+export function ObjectTypeAnnotation(node, print) {
+  this.push("{");
+  var props = node.properties.concat(node.callProperties, node.indexers);
+  if (props.length) {
+    this.space();
+    print.list(props, { indent: true, separator: "; " });
+    this.space();
+  }
+  this.push("}");
+}
+
+export function ObjectTypeCallProperty(node, print) {
+  if (node.static) this.push("static ");
+  print(node.value);
+}
+
+export function ObjectTypeIndexer(node, print) {
+  if (node.static) this.push("static ");
+  this.push("[");
+  print(node.id);
+  this.push(":");
+  this.space();
+  print(node.key);
+  this.push("]");
+  this.push(":");
+  this.space();
+  print(node.value);
+}
+
+export function ObjectTypeProperty(node, print) {
+  if (node.static) this.push("static ");
+  print(node.key);
+  if (node.optional) this.push("?");
+  if (!t.isFunctionTypeAnnotation(node.value)) {
+    this.push(":");
+    this.space();
+  }
+  print(node.value);
+}
+
+export function QualifiedTypeIdentifier(node, print) {
+  print(node.qualification);
+  this.push(".");
+  print(node.id);
+}
+
+export function UnionTypeAnnotation(node, print) {
+  print.join(node.types, { separator: " | " });
+}
+
+export function TypeCastExpression(node, print) {
+  this.push("(");
+  print(node.expression);
+  print(node.typeAnnotation);
+  this.push(")");
+}
+
+export function VoidTypeAnnotation(node) {
+  this.push("void");
+}

src/babel/generation/generators/methods.js

@@ -1,9 +1,19 @@
 import t from "../../types";
 
 export function _params(node, print) {
+  print(node.typeParameters);
   this.push("(");
-  print.list(node.params);
+  print.list(node.params, {
+    iterator: (node) =>{
+      if (node.optional) this.push("?");
+      print(node.typeAnnotation);
+    }
+  });
   this.push(")");
+
+  if (node.returnType) {
+    print(node.returnType);
+  }
 }
 
 export function _method(node, print) {
@@ -34,8 +44,7 @@ export function _method(node, print) {
   print(value.body);
 }
 
-exports.FunctionDeclaration =
-exports.FunctionExpression = function (node, print) {
+export function FunctionExpression(node, print) {
   if (node.async) this.push("async ");
   this.push("function");
   if (node.generator) this.push("*");
@@ -50,7 +59,9 @@ exports.FunctionExpression = function (node, print) {
   this._params(node, print);
   this.space();
   print(node.body);
-};
+}
+
+export { FunctionExpression as FunctionDeclaration };
 
 export function ArrowFunctionExpression(node, print) {
   if (node.async) this.push("async ");

src/babel/generation/generators/modules.js

@@ -5,7 +5,7 @@ export function ImportSpecifier(node, print) {
   if (t.isSpecifierDefault(node)) {
     print(t.getSpecifierName(node));
   } else {
-    return exports.ExportSpecifier.apply(this, arguments);
+    return ExportSpecifier.apply(this, arguments);
   }
 }
 

src/babel/generation/generators/playground.js

@@ -2,6 +2,6 @@ import each from "lodash/collection/each";
 
 each(["BindMemberExpression", "BindFunctionExpression"], function (type) {
   exports[type] = function () {
-    throw new ReferenceError("Trying to render non-standard playground node " + JSON.stringify(type));
+    throw new ReferenceError(`Trying to render non-standard playground node ${JSON.stringify(type)}`);
   };
 });

src/babel/generation/generators/statements.js

@@ -60,7 +60,7 @@ var buildForXStatement = function (op) {
     this.keyword("for");
     this.push("(");
     print(node.left);
-    this.push(" " + op + " ");
+    this.push(` ${op} `);
     print(node.right);
     this.push(")");
     print.block(node.body);
@@ -192,7 +192,7 @@ export function VariableDeclaration(node, print, parent) {
 
   var sep = ",";
   if (!this.format.compact && hasInits) {
-    sep += "\n" + repeating(" ", node.kind.length + 1);
+    sep += `\n${repeating(" ", node.kind.length + 1)}`;
   } else {
     sep += " ";
   }
@@ -211,13 +211,12 @@ export function PrivateDeclaration(node, print) {
 }
 
 export function VariableDeclarator(node, print) {
+  print(node.id);
+  print(node.id.typeAnnotation);
   if (node.init) {
-    print(node.id);
     this.space();
     this.push("=");
     this.space();
     print(node.init);
-  } else {
-    print(node.id);
   }
 }

src/babel/generation/generators/types.js

@@ -4,12 +4,12 @@ export function Identifier(node) {
   this.push(node.name);
 }
 
-exports.RestElement =
-exports.SpreadElement =
-exports.SpreadProperty = function (node, print) {
+export function RestElement(node, print) {
   this.push("...");
   print(node.argument);
-};
+}
+
+export { RestElement as SpreadElement, RestElement as SpreadProperty };
 
 export function VirtualPropertyExpression(node, print) {
   print(node.object);
@@ -17,8 +17,7 @@ export function VirtualPropertyExpression(node, print) {
   print(node.property);
 }
 
-exports.ObjectExpression =
-exports.ObjectPattern = function (node, print) {
+export function ObjectExpression(node, print) {
   var props = node.properties;
 
   if (props.length) {
@@ -32,7 +31,9 @@ exports.ObjectPattern = function (node, print) {
   } else {
     this.push("{}");
   }
-};
+}
+
+export { ObjectExpression as ObjectPattern };
 
 export function Property(node, print) {
   if (node.method || node.kind === "get" || node.kind === "set") {
@@ -53,8 +54,7 @@ export function Property(node, print) {
   }
 }
 
-exports.ArrayExpression =
-exports.ArrayPattern = function (node, print) {
+export function ArrayExpression(node, print) {
   var elems = node.elements;
   var len   = elems.length;
 
@@ -76,28 +76,34 @@ exports.ArrayPattern = function (node, print) {
   });
 
   this.push("]");
-};
+}
+
+export { ArrayExpression as ArrayPattern };
 
 export function Literal(node) {
   var val  = node.value;
   var type = typeof val;
 
   if (type === "string") {
-    val = JSON.stringify(val);
-
-    // escape illegal js but valid json unicode characters
-    val = val.replace(/[\u000A\u000D\u2028\u2029]/g, function (c) {
-      return "\\u" + ("0000" + c.charCodeAt(0).toString(16)).slice(-4);
-    });
-
-    this.push(val);
+    this._stringLiteral(val);
   } else if (type === "number") {
     this.push(val + "");
   } else if (type === "boolean") {
     this.push(val ? "true" : "false");
   } else if (node.regex) {
-    this.push("/" + node.regex.pattern + "/" + node.regex.flags);
+    this.push(`/${node.regex.pattern}/${node.regex.flags}`);
   } else if (val === null) {
     this.push("null");
   }
 }
+
+export function _stringLiteral(val) {
+  val = JSON.stringify(val);
+
+  // escape illegal js but valid json unicode characters
+  val = val.replace(/[\u000A\u000D\u2028\u2029]/g, function (c) {
+    return "\\u" + ("0000" + c.charCodeAt(0).toString(16)).slice(-4);
+  });
+
+  this.push(val);
+}

src/babel/generation/index.js

@@ -117,7 +117,7 @@ class CodeGenerator {
   }
 
   print(node, parent, opts = {}) {
-    if (!node) return "";
+    if (!node) return;
 
     if (parent && parent._compact) {
       node._compact = true;
@@ -187,7 +187,7 @@ class CodeGenerator {
 
       this.printTrailingComments(node, parent);
     } else {
-      throw new ReferenceError("unknown node of type " + JSON.stringify(node.type) + " with constructor " + JSON.stringify(node && node.constructor.name));
+      throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node && node.constructor.name)}`);
     }
 
     this.format.concise = oldConcise;
@@ -238,9 +238,9 @@ class CodeGenerator {
   generateComment(comment) {
     var val = comment.value;
     if (comment.type === "Line") {
-      val = "//" + val;
+      val = `//${val}`;
     } else {
-      val = "/*" + val + "*/";
+      val = `/*${val}*/`;
     }
     return val;
   }
@@ -319,7 +319,7 @@ class CodeGenerator {
         }
 
         var indent = Math.max(this.indentSize(), column);
-        val = val.replace(/\n/g, "\n" + repeating(" ", indent));
+        val = val.replace(/\n/g, `\n${repeating(" ", indent)}`);
       }
 
       if (column === 0) {

src/babel/generation/node/parentheses.js

@@ -21,6 +21,12 @@ each([
   });
 });
 
+export function NullableTypeAnnotation(node, parent) {
+  return t.isArrayTypeAnnotation(parent);
+}
+
+export { NullableTypeAnnotation as FunctionTypeAnnotation };
+
 export function UpdateExpression(node, parent) {
   if (t.isMemberExpression(parent) && parent.object === node) {
     // (foo++).test()
@@ -139,8 +145,7 @@ export function FunctionExpression(node, parent) {
   }
 }
 
-exports.AssignmentExpression =
-exports.ConditionalExpression = function (node, parent) {
+export function ConditionalExpression(node, parent) {
   if (t.isUnaryLike(parent)) {
     return true;
   }
@@ -164,4 +169,6 @@ exports.ConditionalExpression = function (node, parent) {
   }
 
   return false;
-};
+}
+
+export { ConditionalExpression as AssignmentExpression };

src/babel/helpers/code-frame.js

@@ -55,7 +55,7 @@ var highlight = function (text) {
   });
 };
 
-module.exports = function (lines, lineNumber, colNumber) {
+export default function (lines, lineNumber, colNumber) {
   colNumber = Math.max(colNumber, 0);
 
   if (chalk.supportsColor) {
@@ -81,8 +81,7 @@ module.exports = function (lines, lineNumber, colNumber) {
         return;
       }
       if (colNumber) {
-        params.line += "\n" + params.before + repeating(" ", params.width) +
-                       params.after + repeating(" ", colNumber - 1) + "^";
+        params.line += `\n${params.before}${repeating(" ", params.width)}${params.after}${repeating(" ", colNumber - 1)}^`;
       }
       params.before = params.before.replace(/^./, ">");
     }

src/babel/helpers/normalize-ast.js

@@ -1,6 +1,6 @@
 import t from "../types";
 
-module.exports = function (ast, comments, tokens) {
+export default function (ast, comments, tokens) {
   if (ast && ast.type === "Program") {
     return t.file(ast, comments || [], tokens || []);
   } else {

src/babel/helpers/object.js

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

src/babel/helpers/parse.js

@@ -3,7 +3,7 @@ import estraverse from "estraverse";
 import codeFrame from "./code-frame";
 import acorn from "acorn-babel";
 
-module.exports = function (opts, code, callback) {
+export default function (opts, code, callback) {
   try {
     var comments = [];
     var tokens   = [];
@@ -32,7 +32,7 @@ module.exports = function (opts, code, callback) {
   } catch (err) {
     if (!err._babel) {
       err._babel = true;
-      var message = opts.filename + ": " + err.message;
+      var message = `${opts.filename}: ${err.message}`;
 
       var loc = err.loc;
       if (loc) {

src/babel/helpers/to-fast-properties.js

@@ -1,15 +0,0 @@
-/**
- * A trick from Bluebird to force V8 to use fast properties for an object.
- * Read more: http://stackoverflow.com/questions/24987896/
- *
- * Use %HasFastProperties(obj) and --allow-natives-syntax to check whether
- * a particular object already has fast properties.
- */
-
-module.exports = function toFastProperties(obj) {
-  /*jshint -W027*/
-  function f() {}
-  f.prototype = obj;
-  return f;
-  eval(obj);
-};

src/babel/messages.js

@@ -10,6 +10,7 @@ export var messages = {
   undeclaredVariable: "Reference to undeclared variable $1",
   undeclaredVariableSuggestion: "Reference to undeclared variable $1 - did you mean $2?",
   settersInvalidParamLength: "Setters must have exactly one parameter",
+  settersNoRest: "Setters aren't allowed to have a rest",
   noAssignmentsInForHead: "No assignments allowed in for-in/of head",
   expectedMemberExpressionOrIdentifier: "Expected type MemeberExpression or Identifier",
   invalidParentForThisNode: "We don't know how to handle this node within the current parent - please open an issue",
@@ -18,18 +19,20 @@ export var messages = {
   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."
+  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"
 };
 
 export function get(key) {
-  var msg = exports.messages[key];
-  if (!msg) throw new ReferenceError("Unknown message `" + key + "`");
+  var msg = messages[key];
+  if (!msg) throw new ReferenceError(`Unknown message ${JSON.stringify(key)}`);
 
   var args = [];
   for (var i = 1; i < arguments.length; i++) {
     args.push(arguments[i]);
   }
-  args = exports.parseArgs(args);
+  args = parseArgs(args);
 
   return msg.replace(/\$(\d+)/g, function (str, i) {
     return args[--i];

src/babel/transformation/file.js

@@ -1,6 +1,7 @@
-import sourceMapToComment from "source-map-to-comment";
+import convertSourceMap from "convert-source-map";
 import shebangRegex from "shebang-regex";
 import isFunction from "lodash/lang/isFunction";
+import sourceMap from "source-map";
 import transform from "./index";
 import generate from "../generation";
 import defaults from "lodash/object/defaults";
@@ -20,12 +21,12 @@ var checkTransformerVisitor = {
   }
 };
 
-var checkNode = function (stack, node, scope) {
+function checkNode(stack, node, scope) {
   each(stack, function (pass) {
     if (pass.shouldRun) return;
     pass.checkNode(node, scope);
   });
-};
+}
 
 export default class File {
   constructor(opts) {
@@ -48,7 +49,7 @@ export default class File {
   static helpers = [
     "inherits",
     "defaults",
-    "prototype-properties",
+    "create-class",
     "apply-constructor",
     "tagged-template-literal",
     "tagged-template-literal-loose",
@@ -77,34 +78,41 @@ export default class File {
   static validOptions = [
     "filename",
     "filenameRelative",
+
     "blacklist",
     "whitelist",
-    "loose",
     "optional",
+
+    "loose",
+    "playground",
+    "experimental",
+
     "modules",
+    "moduleIds",
+    "moduleId",
+    "resolveModuleSource",
+    "keepModuleIdExtensions",
+
+    "code",
+    "ast",
+
+    "comments",
+    "compact",
+
+    "auxiliaryComment",
+    "externalHelpers",
+    "returnUsedHelpers",
+
+    "inputSourceMap",
     "sourceMap",
     "sourceMapName",
     "sourceFileName",
     "sourceRoot",
     "moduleRoot",
-    "moduleIds",
-    "comments",
-    "reactCompat",
-    "keepModuleIdExtensions",
-    "code",
-    "ast",
-    "playground",
-    "experimental",
-    "externalHelpers",
-    "auxiliaryComment",
-    "compact",
-    "returnUsedHelpers",
-
-    "resolveModuleSource",
-    "moduleId",
 
     // legacy
     "format",
+    "reactCompat",
 
     // these are used by plugins
     "ignore",
@@ -118,7 +126,7 @@ export default class File {
 
     for (var key in opts) {
       if (key[0] !== "_" && File.validOptions.indexOf(key) < 0) {
-        throw new ReferenceError("Unknown option: " + key);
+        throw new ReferenceError(`Unknown option: ${key}`);
       }
     }
 
@@ -128,6 +136,7 @@ export default class File {
       returnUsedHelpers:      false,
       externalHelpers:        false,
       auxilaryComment:        "",
+      inputSourceMap:         false,
       experimental:           false,
       reactCompat:            false,
       playground:             false,
@@ -145,6 +154,10 @@ export default class File {
       ast:                    true
     });
 
+    if (opts.inputSourceMap) {
+      opts.sourceMap = true;
+    }
+
     // normalize windows path separators to unix
     opts.filename = slash(opts.filename);
     if (opts.sourceRoot) {
@@ -248,7 +261,7 @@ export default class File {
 
   debug(msg) {
     var parts = this.opts.filename;
-    if (msg) parts += ": " + msg;
+    if (msg) parts += `: ${msg}`;
     util.debug(parts);
   }
 
@@ -261,12 +274,24 @@ export default class File {
     }
 
     if (!ModuleFormatter) {
-      throw new ReferenceError("Unknown module formatter type " + JSON.stringify(type));
+      throw new ReferenceError(`Unknown module formatter type ${JSON.stringify(type)}`);
     }
 
     return new ModuleFormatter(this);
   }
 
+  parseInputSourceMap(code) {
+    var opts = this.opts;
+
+    var inputMap = convertSourceMap.fromSource(code);
+    if (inputMap) {
+      opts.inputSourceMap = inputMap.toObject();
+      code = convertSourceMap.removeComments(code);
+    }
+
+    return code;
+  }
+
   parseShebang(code) {
     var shebangMatch = shebangRegex.exec(code);
 
@@ -314,7 +339,11 @@ export default class File {
       this.dynamicImported.push(declar);
       if (noDefault) this.dynamicImportedNoDefault.push(declar);
 
-      this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
+      if (this.transformers["es6.modules"].canRun()) {
+        this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
+      } else {
+        this.dynamicImports.push(declar);
+      }
     }
 
     return id;
@@ -338,7 +367,7 @@ export default class File {
 
   addHelper(name) {
     if (!includes(File.helpers, name)) {
-      throw new ReferenceError("Unknown helper " + name);
+      throw new ReferenceError(`Unknown helper ${name}`);
     }
 
     var program = this.ast.program;
@@ -371,13 +400,14 @@ export default class File {
 
   errorWithNode(node, msg, Error = SyntaxError) {
     var loc = node.loc.start;
-    var err = new Error("Line " + loc.line + ": " + msg);
+    var err = new Error(`Line ${loc.line}: ${msg}`);
     err.loc = loc;
     return err;
   }
 
   addCode(code) {
     code = (code || "") + "";
+    code = this.parseInputSourceMap(code);
     this.code = code;
     return this.parseShebang(code);
   }
@@ -388,7 +418,7 @@ export default class File {
     var opts = this.opts;
 
     opts.allowImportExportEverywhere = this.isLoose("es6.modules");
-    opts.strictMode = this.transformers.useStrict.canRun();
+    opts.strictMode = this.transformers.strict.canRun();
 
     return parse(opts, code, (tree) => {
       this.transform(tree);
@@ -430,6 +460,13 @@ export default class File {
   }
 
   checkNode(node, scope) {
+    if (Array.isArray(node)) {
+      for (var i = 0; i < node.length; i++) {
+        this.checkNode(node[i], scope);
+      }
+      return;
+    }
+
     var stack = this.transformerStack;
     scope ||= this.scope;
 
@@ -440,6 +477,28 @@ export default class File {
     });
   }
 
+  mergeSourceMap(map) {
+    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;
+  }
+
   generate() {
     var opts = this.opts;
     var ast  = this.ast;
@@ -463,11 +522,16 @@ export default class File {
 
     if (this.shebang) {
       // add back shebang
-      result.code = this.shebang + "\n" + result.code;
+      result.code = `${this.shebang}\n${result.code}`;
     }
 
-    if (opts.sourceMap === "inline") {
-      result.code += "\n" + sourceMapToComment(result.map);
+    result.map = this.mergeSourceMap(result.map);
+
+    if (opts.sourceMap === "inline" || opts.sourceMap === "both") {
+      result.code += "\n" + convertSourceMap.fromObject(result.map).toComment();
+    }
+
+    if (opts.sourceMap === "both") {
       result.map = null;
     }
 

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

@@ -1,7 +1,7 @@
 import explode from "./explode-assignable-expression";
 import t from "../../types";
 
-module.exports = function (exports, opts) {
+export default function (exports, opts) {
   var isAssignment = function (node) {
     return node.operator === opts.operator + "=";
   };

src/babel/transformation/helpers/build-comprehension.js

@@ -1,6 +1,6 @@
 import t from "../../types";
 
-module.exports = function build(node, buildBody) {
+export default function build(node, buildBody) {
   var self = node.blocks.shift();
   if (!self) return;
 
@@ -20,4 +20,4 @@ module.exports = function build(node, buildBody) {
     self.right,
     t.blockStatement([child])
   );
-};
+}

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

@@ -1,7 +1,7 @@
 import explode from "./explode-assignable-expression";
 import t from "../../types";
 
-module.exports = function (exports, opts) {
+export default function (exports, opts) {
   var buildAssignment = function (left, right) {
     return t.assignmentExpression("=", left, right);
   };

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

@@ -6,10 +6,10 @@
 import isString from "lodash/lang/isString";
 import * as messages from "../../messages";
 import esutils from "esutils";
-import react from "./react";
+import * as react from "./react";
 import t from "../../types";
 
-module.exports = function (exports, opts) {
+export default function (exports, opts) {
   exports.check = function (node) {
     if (t.isJSX(node)) return true;
     if (react.isCreateClass(node)) return true;

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

@@ -1,20 +1,19 @@
 import cloneDeep from "lodash/lang/cloneDeep";
 import traverse from "../../traversal";
-import clone from "lodash/lang/clone";
 import each from "lodash/collection/each";
 import has from "lodash/object/has";
 import t from "../../types";
 
-exports.push = function (mutatorMap, key, kind, computed, value) {
+export function push(mutatorMap, key, kind, computed, value) {
   var alias;
 
   if (t.isIdentifier(key)) {
     alias = key.name;
-    if (computed) alias = "computed:" + alias;
+    if (computed) alias = `computed:${alias}`;
   } else if (t.isLiteral(key)) {
     alias = String(key.value);
   } else {
-    alias = JSON.stringify(traverse.removeProperties(cloneDeep(key)));
+    alias = JSON.stringify(traverse.removeProperties(t.cloneDeep(key)));
   }
 
   var map;
@@ -31,9 +30,9 @@ exports.push = function (mutatorMap, key, kind, computed, value) {
   }
 
   map[kind] = value;
-};
+}
 
-exports.build = function (mutatorMap) {
+export function toClassObject(mutatorMap) {
   var objExpr = t.objectExpression([]);
 
   each(mutatorMap, function (map) {
@@ -41,22 +40,9 @@ exports.build = function (mutatorMap) {
 
     var propNode = t.property("init", map._key, mapNode, map._computed);
 
-    if (!map.get && !map.set) {
-      map.writable = t.literal(true);
-    }
-
-    if (map.enumerable === false) {
-      delete map.enumerable;
-    } else {
-      map.enumerable = t.literal(true);
-    }
-
-    map.configurable = t.literal(true);
-
     each(map, function (node, key) {
       if (key[0] === "_") return;
 
-      node = clone(node);
       var inheritNode = node;
       if (t.isMethodDefinition(node)) node = node.value;
 
@@ -70,4 +56,38 @@ exports.build = function (mutatorMap) {
   });
 
   return objExpr;
-};
+}
+
+export function toDefineObject(mutatorMap) {
+  var objExpr = t.objectExpression([]);
+
+  each(mutatorMap, function (map) {
+    var mapNode = t.objectExpression([]);
+
+    var propNode = t.property("init", map._key, mapNode, map._computed);
+
+    if (map.value) {
+      map.writable = t.literal(true);
+    }
+
+    map.configurable = t.literal(true);
+    map.enumerable = t.literal(true);
+
+    each(map, function (node, key) {
+      if (key[0] === "_") return;
+
+      node = t.clone(node);
+      var inheritNode = node;
+      if (t.isMethodDefinition(node)) node = node.value;
+
+      var prop = t.property("init", t.identifier(key), node);
+      t.inheritsComments(prop, inheritNode);
+      t.removeComments(inheritNode);
+      mapNode.properties.push(prop);
+    });
+
+    objExpr.properties.push(propNode);
+  });
+
+  return objExpr;
+}

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

@@ -23,7 +23,7 @@ var getObjRef = function (node, nodes, file, scope) {
       return ref;
     }
   } else {
-    throw new Error("We can't explode this node type " + node.type);
+    throw new Error(`We can't explode this node type ${node.type}`);
   }
 
   var temp = scope.generateUidBasedOnNode(ref);
@@ -45,7 +45,7 @@ var getPropRef = function (node, nodes, file, scope) {
   return temp;
 };
 
-module.exports = function (node, nodes, file, scope, allowedSingleIdent) {
+export default function (node, nodes, file, scope, allowedSingleIdent) {
   var obj;
   if (t.isIdentifier(node) && allowedSingleIdent) {
     obj = node;

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

@@ -1,6 +1,6 @@
 import t from "../../types";
 
-module.exports = function (node) {
+export default function (node) {
   var lastNonDefault = 0;
   for (var i = 0; i < node.params.length; i++) {
     if (!t.isAssignmentPattern(node.params[i])) lastNonDefault = i + 1;

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

@@ -6,7 +6,7 @@ var visitor = {
   enter(node, parent, scope, state) {
     // check if this node is a referenced identifier that matches the same as our
     // function id
-    if (!t.isReferencedIdentifier(node, parent, { name: state.name })) return;
+    if (!this.isReferencedIdentifier({ name: state.name })) return;
 
     // check that we don't have a local variable declared as that removes the need
     // for the wrapper
@@ -89,7 +89,12 @@ var visit = function (node, name, scope) {
   return state;
 };
 
-exports.property = function (node, file, scope) {
+export function custom(node, id, scope) {
+  var state = visit(node, id.name, scope);
+  return wrap(state, node, id, scope);
+}
+
+export function property(node, file, scope) {
   var key = t.toComputedKey(node, node.key);
   if (!t.isLiteral(key)) return node; // we can't set a function id with this
 
@@ -99,11 +104,11 @@ exports.property = function (node, file, scope) {
   var method = node.value;
   var state  = visit(method, name, scope);
   node.value = wrap(state, method, id, scope);
-};
+}
 
-exports.bare = function (node, parent, scope) {
+export function bare(node, parent, scope) {
   // has an `id` so we don't need to infer one
-  if (node.id) return;
+  if (node.id) return node;
 
   var id;
   if (t.isProperty(parent) && parent.kind === "init" && !parent.computed) {
@@ -113,14 +118,14 @@ exports.bare = function (node, parent, scope) {
     // var foo = function () {};
     id = parent.id;
   } else {
-    return;
+    return node;
   }
 
-  if (!t.isIdentifier(id)) return;
+  if (!t.isIdentifier(id)) return node;
 
   var name = t.toIdentifier(id.name);
   id = t.identifier(name);
 
   var state = visit(node, name, scope);
   return wrap(state, node, id, scope);
-};
+}

src/babel/transformation/helpers/react.js

@@ -2,7 +2,7 @@ import t from "../../types";
 
 var isCreateClassCallExpression = t.buildMatchMemberExpression("React.createClass");
 
-exports.isCreateClass = function (node) {
+export function isCreateClass(node) {
   if (!node || !t.isCallExpression(node)) return false;
 
   // not React.createClass call member object
@@ -17,10 +17,10 @@ exports.isCreateClass = function (node) {
   if (!t.isObjectExpression(first)) return false;
 
   return true;
-};
+}
 
-exports.isReactComponent = t.buildMatchMemberExpression("React.Component");
+export var isReactComponent = t.buildMatchMemberExpression("React.Component");
 
-exports.isCompatTag = function (tagName) {
+export function isCompatTag(tagName) {
   return tagName && /^[a-z]|\-/.test(tagName);
-};
+}

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

@@ -16,7 +16,7 @@ var visitor = {
   }
 };
 
-module.exports = function (node, callId, scope) {
+export default function (node, callId, scope) {
   node.async = false;
   node.generator = true;
 
@@ -24,7 +24,7 @@ module.exports = function (node, callId, scope) {
 
   var call = t.callExpression(callId, [node]);
   var id = node.id;
-  delete node.id;
+  node.id = null;
 
   if (t.isFunctionDeclaration(node)) {
     var declar = t.variableDeclaration("let", [

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

@@ -55,14 +55,18 @@ export default class ReplaceSupers {
   constructor(opts, inClass) {
     this.topLevelThisReference = opts.topLevelThisReference;
     this.methodNode            = opts.methodNode;
-    this.className             = opts.className;
-    this.superName             = opts.superName;
+    this.superRef              = opts.superRef;
     this.isStatic              = opts.isStatic;
     this.hasSuper              = false;
     this.inClass               = inClass;
     this.isLoose               = opts.isLoose;
     this.scope                 = opts.scope;
     this.file                  = opts.file;
+    this.opts                  = opts;
+  }
+
+  getObjectRef() {
+    return this.opts.objectRef || this.opts.getObjectRef();
   }
 
   /**
@@ -87,7 +91,7 @@ export default class ReplaceSupers {
         t.callExpression(
           t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")),
           [
-            this.isStatic ? this.className : t.memberExpression(this.className, t.identifier("prototype"))
+            this.isStatic ? this.getObjectRef() : t.memberExpression(this.getObjectRef(), t.identifier("prototype"))
           ]
         ),
         isComputed ? property : t.literal(property.name),
@@ -118,7 +122,7 @@ export default class ReplaceSupers {
         t.callExpression(
           t.memberExpression(t.identifier("Object"), t.identifier("getPrototypeOf")),
           [
-            this.isStatic ? this.className : t.memberExpression(this.className, t.identifier("prototype"))
+            this.isStatic ? this.getObjectRef() : t.memberExpression(this.getObjectRef(), t.identifier("prototype"))
           ]
         ),
         isComputed ? property : t.literal(property.name),
@@ -175,19 +179,19 @@ export default class ReplaceSupers {
   getLooseSuperProperty(id, parent) {
     var methodNode = this.methodNode;
     var methodName = methodNode.key;
-    var superName  = this.superName || t.identifier("Function");
+    var superRef   = this.superRef || t.identifier("Function");
 
     if (parent.property === id) {
       return;
     } else if (t.isCallExpression(parent, { callee: id })) {
-      // super(); -> ClassName.prototype.MethodName.call(this);
+      // super(); -> objectRef.prototype.MethodName.call(this);
       parent.arguments.unshift(t.thisExpression());
 
       if (methodName.name === "constructor") {
         // constructor() { super(); }
-        return t.memberExpression(superName, t.identifier("call"));
+        return t.memberExpression(superRef, t.identifier("call"));
       } else {
-        id = superName;
+        id = superRef;
 
         // foo() { super(); }
         if (!methodNode.static) {
@@ -198,10 +202,10 @@ export default class ReplaceSupers {
         return t.memberExpression(id, t.identifier("call"));
       }
     } else if (t.isMemberExpression(parent) && !methodNode.static) {
-      // super.test -> ClassName.prototype.test
-      return t.memberExpression(superName, t.identifier("prototype"));
+      // super.test -> objectRef.prototype.test
+      return t.memberExpression(superRef, t.identifier("prototype"));
     } else {
-      return superName;
+      return superRef;
     }
   }
 
@@ -222,7 +226,7 @@ export default class ReplaceSupers {
       if (!t.isMemberExpression(callee)) return;
       if (callee.object.name !== "super") return;
 
-      // super.test(); -> ClassName.prototype.MethodName.call(this);
+      // super.test(); -> objectRef.prototype.MethodName.call(this);
       this.hasSuper = true;
       t.appendToMemberExpression(callee, t.identifier("call"));
       node.arguments.unshift(getThisReference());
@@ -251,7 +255,7 @@ export default class ReplaceSupers {
     if (t.isCallExpression(node)) {
       var callee = node.callee;
       if (isSuper(callee, node)) {
-        // super(); -> _get(Object.getPrototypeOf(ClassName), "MethodName", this).call(this);
+        // super(); -> _get(Object.getPrototypeOf(objectRef), "MethodName", this).call(this);
         property = methodNode.key;
         computed = methodNode.computed;
         args = node.arguments;
@@ -264,17 +268,17 @@ export default class ReplaceSupers {
           throw this.file.errorWithNode(node, messages.get("classesIllegalSuperCall", methodName));
         }
       } else if (t.isMemberExpression(callee) && isSuper(callee.object, callee)) {
-        // super.test(); -> _get(Object.getPrototypeOf(ClassName.prototype), "test", this).call(this);
+        // super.test(); -> _get(Object.getPrototypeOf(objectRef.prototype), "test", this).call(this);
         property = callee.property;
         computed = callee.computed;
         args = node.arguments;
       }
     } else if (t.isMemberExpression(node) && isSuper(node.object, node)) {
-      // super.name; -> _get(Object.getPrototypeOf(ClassName.prototype), "name", this);
+      // super.name; -> _get(Object.getPrototypeOf(objectRef.prototype), "name", this);
       property = node.property;
       computed = node.computed;
     } else if (t.isAssignmentExpression(node) && isSuper(node.left.object, node.left) && methodNode.kind === "set") {
-      // super.name = "val"; -> _set(Object.getPrototypeOf(ClassName.prototype), "name", this);
+      // super.name = "val"; -> _set(Object.getPrototypeOf(objectRef.prototype), "name", this);
       this.hasSuper = true;
       return this.setSuperProperty(node.left.property, node.right, node.left.computed, getThisReference());
     }

src/babel/transformation/helpers/strict.js

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

src/babel/transformation/index.js

@@ -25,9 +25,12 @@ transform._ensureTransformerNames = function (type, rawKeys) {
     var key = rawKeys[i];
 
     var deprecatedKey = transform.deprecatedTransformerMap[key];
-    if (deprecatedKey) {
+    var aliasKey = transform.aliasTransformerMap[key];
+    if (aliasKey) {
+      keys.push(aliasKey);
+    } else if (deprecatedKey) {
       // deprecated key, remap it to the new one
-      console.error("The transformer " + key + " has been renamed to " + deprecatedKey);
+      console.error(`The transformer ${key} has been renamed to ${deprecatedKey}`);
       rawKeys.push(deprecatedKey);
     } else if (transform.transformers[key]) {
       // valid key
@@ -37,7 +40,7 @@ transform._ensureTransformerNames = function (type, rawKeys) {
       keys = keys.concat(transform.namespaces[key]);
     } else {
       // invalid key
-      throw new ReferenceError("Unknown transformer " + key + " specified in " + type);
+      throw new ReferenceError(`Unknown transformer ${key} specified in ${type}`);
     }
   }
 
@@ -49,6 +52,7 @@ transform.transformers          = object();
 transform.namespaces            = object();
 
 transform.deprecatedTransformerMap = require("./transformers/deprecated");
+transform.aliasTransformerMap = require("./transformers/aliases");
 transform.moduleFormatters = require("./modules");
 
 import rawTransformers from "./transformers";

src/babel/transformation/modules/_default.js

@@ -42,8 +42,8 @@ var remapVisitor = {
 };
 
 var importsVisitor = {
-  enter(node, parent, scope, formatter) {
-    if (t.isImportDeclaration(node)) {
+  ImportDeclaration: {
+    enter(node, parent, scope, formatter) {
       formatter.hasLocalImports = true;
       extend(formatter.localImports, t.getBindingIdentifiers(node));
       formatter.bumpImportOccurences(node);
@@ -52,9 +52,9 @@ var importsVisitor = {
 };
 
 var exportsVisitor = {
-  enter(node, parent, scope, formatter) {
-    var declar = node && node.declaration;
-    if (t.isExportDeclaration(node)) {
+  ExportDeclaration: {
+    enter(node, parent, scope, formatter) {
+      var declar = node.declaration;
       formatter.hasLocalImports = true;
 
       if (declar && t.isStatement(declar)) {

src/babel/transformation/modules/index.js

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   commonStrict: require("./common-strict"),
   amdStrict:    require("./amd-strict"),
   umdStrict:    require("./umd-strict"),

src/babel/transformation/modules/system.js

@@ -142,9 +142,9 @@ export default class SystemFormatter extends AMDFormatter {
 
     return t.arrayExpression(map(this.ids, function (uid, source) {
       var state = {
+        hoistDeclarators: hoistDeclarators,
         source:           source,
-        nodes:            [],
-        hoistDeclarators: hoistDeclarators
+        nodes:            []
       };
 
       scope.traverse(block, runnerSettersVisitor, state);
@@ -161,11 +161,11 @@ export default class SystemFormatter extends AMDFormatter {
     var block = t.blockStatement(program.body);
 
     var runner = util.template("system", {
-      MODULE_NAME: moduleNameLiteral,
       MODULE_DEPENDENCIES: t.arrayExpression(this.buildDependencyLiterals()),
-      EXPORT_IDENTIFIER: this.exportIdentifier,
-      SETTERS: this.buildRunnerSetters(block, hoistDeclarators),
-      EXECUTE: t.functionExpression(null, [], block)
+      EXPORT_IDENTIFIER:   this.exportIdentifier,
+      MODULE_NAME:         moduleNameLiteral,
+      SETTERS:             this.buildRunnerSetters(block, hoistDeclarators),
+      EXECUTE:             t.functionExpression(null, [], block)
     }, true);
 
     var handlerBody = runner.expression.arguments[2].body.body;

src/babel/transformation/templates/.babelrc

@@ -1,3 +1,3 @@
 {
-  "blacklist": ["useStrict", "es6.blockScoping"]
+  "blacklist": ["useStrict", "es6.blockScoping", "regenerator"]
 }

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

@@ -0,0 +1,16 @@
+(function() {
+  function defineProperties(target, props) {
+    for (var key in props) {
+      var prop = props[key];
+      prop.configurable = true;
+      if (prop.value) prop.writable = true;
+    }
+    Object.defineProperties(target, props);
+  }
+
+  return function (Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) defineProperties(Constructor, staticProps);
+    return Constructor;
+  };
+})()

src/babel/transformation/templates/prototype-properties.js

@@ -1,4 +0,0 @@
-(function (child, staticProps, instanceProps) {
-  if (staticProps) Object.defineProperties(child, staticProps);
-  if (instanceProps) Object.defineProperties(child.prototype, instanceProps);
-})

src/babel/transformation/templates/umd-commonjs-strict.js

@@ -0,0 +1,11 @@
+(function (root, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(AMD_ARGUMENTS, factory);
+  } else if (typeof exports === 'object') {
+    factory(COMMON_ARGUMENTS);
+  } else {
+    factory(BROWSER_ARGUMENTS);
+  }
+})(UMD_ROOT, function (FACTORY_PARAMETERS) {
+  FACTORY_BODY
+});

src/babel/transformation/transformer-pass.js

@@ -56,7 +56,7 @@ export default class TransformerPass {
 
     var file = this.file;
 
-    file.debug("Running transformer " + this.transformer.key);
+    file.debug(`Running transformer ${this.transformer.key}`);
 
     file.scope.traverse(file.ast, this.handlers, file);
   }

src/babel/transformation/transformers/aliases.json

@@ -0,0 +1,3 @@
+{
+  "useStrict": "strict"
+}

src/babel/transformation/transformers/deprecated.json

@@ -1,4 +1,8 @@
 {
   "selfContained": "runtime",
-  "unicode-regex": "regex.unicode"
+  "unicode-regex": "regex.unicode",
+
+  "minification.deadCodeElimination": "utility.deadCodeElimination",
+  "minification.removeConsoleCalls": "utility.removeConsole",
+  "minification.removeDebugger": "utility.removeDebugger"
 }

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

@@ -1,4 +1,4 @@
-import defineMap from "../../helpers/define-map";
+import * as defineMap from "../../helpers/define-map";
 import t from "../../../types";
 
 export function check(node) {
@@ -23,6 +23,6 @@ export function ObjectExpression(node) {
 
   return t.callExpression(
     t.memberExpression(t.identifier("Object"), t.identifier("defineProperties")),
-    [node, defineMap.build(mutatorMap)]
+    [node, defineMap.toDefineObject(mutatorMap)]
   );
 }

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

@@ -1,6 +1,6 @@
 import t from "../../../types";
 
-exports.check = t.isArrowFunctionExpression;
+export var check = t.isArrowFunctionExpression;
 
 export function ArrowFunctionExpression(node) {
   t.ensureBlock(node);

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

@@ -2,7 +2,7 @@ import t from "../../../types";
 
 var visitor = {
   enter(node, parent, scope, state) {
-    if (!t.isReferencedIdentifier(node, parent)) return;
+    if (!this.isReferencedIdentifier()) return;
 
     var declared = state.letRefs[node.name];
     if (!declared) return;
@@ -26,18 +26,16 @@ var visitor = {
   }
 };
 
-exports.optional = true;
+export var optional = true;
 
-exports.Loop =
-exports.Program =
-exports.BlockStatement = function (node, parent, scope, file) {
+export function BlockStatement(node, parent, scope, file) {
   var letRefs = node._letReferences;
   if (!letRefs) return;
 
-  var state = {
+  scope.traverse(node, visitor, {
     letRefs: letRefs,
     file:    file
-  };
+  });
+}
 
-  scope.traverse(node, visitor, state);
-};
+export { BlockStatement as Program, BlockStatement as Loop };

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

@@ -5,11 +5,7 @@ import t from "../../../types";
 import values from "lodash/object/values";
 import extend from "lodash/object/extend";
 
-exports.check = function (node) {
-  return t.isVariableDeclaration(node) && (node.kind === "let" || node.kind === "const");
-};
-
-var isLet = function (node, parent) {
+function isLet(node, parent) {
   if (!t.isVariableDeclaration(node)) return false;
   if (node._let) return true;
   if (node.kind !== "let") return false;
@@ -25,23 +21,27 @@ var isLet = function (node, parent) {
   node._let = true;
   node.kind = "var";
   return true;
-};
+}
 
-var isLetInitable = function (node, parent) {
+function isLetInitable(node, parent) {
   return !t.isFor(parent) || !t.isFor(parent, { left: node });
-};
+}
 
-var isVar = function (node, parent) {
+function isVar(node, parent) {
   return t.isVariableDeclaration(node, { kind: "var" }) && !isLet(node, parent);
-};
+}
 
-var standardizeLets = function (declars) {
+function standardizeLets(declars) {
   for (var i = 0; i < declars.length; i++) {
     delete declars[i]._let;
   }
-};
+}
 
-exports.VariableDeclaration = function (node, parent, scope, file) {
+export function check(node) {
+  return t.isVariableDeclaration(node) && (node.kind === "let" || node.kind === "const");
+}
+
+export function VariableDeclaration(node, parent, scope, file) {
   if (!isLet(node, parent)) return;
 
   if (isLetInitable(node) && file.transformers["es6.blockScopingTDZ"].canRun()) {
@@ -61,9 +61,9 @@ exports.VariableDeclaration = function (node, parent, scope, file) {
 
     return nodes;
   }
-};
+}
 
-exports.Loop = function (node, parent, scope, file) {
+export function Loop(node, parent, scope, file) {
   var init = node.left || node.init;
   if (isLet(init, node)) {
     t.ensureBlock(node);
@@ -71,15 +71,16 @@ exports.Loop = function (node, parent, scope, file) {
   }
   var blockScoping = new BlockScoping(node, node.body, parent, scope, file);
   blockScoping.run();
-};
+}
 
-exports.Program =
-exports.BlockStatement = function (block, parent, scope, file) {
+export function BlockStatement(block, parent, scope, file) {
   if (!t.isLoop(parent)) {
     var blockScoping = new BlockScoping(false, block, parent, scope, file);
     blockScoping.run();
   }
-};
+}
+
+export { BlockStatement as Program };
 
 function replace(node, parent, scope, remaps) {
   if (!t.isReferencedIdentifier(node, parent)) return;
@@ -108,7 +109,7 @@ function traverseReplace(node, parent, scope, remaps) {
 
 var letReferenceBlockVisitor = {
   enter(node, parent, scope, state) {
-    if (t.isFunction(node)) {
+    if (this.isFunction()) {
       scope.traverse(node, letReferenceFunctionVisitor, state);
       return this.skip();
     }
@@ -118,7 +119,7 @@ var letReferenceBlockVisitor = {
 var letReferenceFunctionVisitor = {
   enter(node, parent, scope, state) {
     // not a direct reference
-    if (!t.isReferencedIdentifier(node, parent)) return;
+    if (!this.isReferencedIdentifier()) return;
 
     // this scope has a variable with the same name so it couldn't belong
     // to our let scope
@@ -133,17 +134,17 @@ var letReferenceFunctionVisitor = {
 
 var hoistVarDeclarationsVisitor = {
   enter(node, parent, scope, self) {
-    if (t.isForStatement(node)) {
+    if (this.isForStatement()) {
       if (isVar(node.init, node)) {
         node.init = t.sequenceExpression(self.pushDeclar(node.init));
       }
-    } else if (t.isFor(node)) {
+    } else if (this.isFor()) {
       if (isVar(node.left, node)) {
         node.left = node.left.declarations[0].id;
       }
     } else if (isVar(node, parent)) {
       return self.pushDeclar(node).map(t.expressionStatement);
-    } else if (t.isFunction(node)) {
+    } else if (this.isFunction()) {
       return this.skip();
     }
   }
@@ -151,7 +152,7 @@ var hoistVarDeclarationsVisitor = {
 
 var loopLabelVisitor = {
   enter(node, parent, scope, state) {
-    if (t.isLabeledStatement(node)) {
+    if (this.isLabeledStatement()) {
       state.innerLabels.push(node.label.name);
     }
   }
@@ -169,13 +170,13 @@ var loopVisitor = {
   enter(node, parent, scope, state) {
     var replace;
 
-    if (t.isLoop(node)) {
+    if (this.isLoop()) {
       state.ignoreLabeless = true;
       scope.traverse(node, loopVisitor, state);
       state.ignoreLabeless = false;
     }
 
-    if (t.isFunction(node) || t.isLoop(node)) {
+    if (this.isFunction() || this.isLoop()) {
       return this.skip();
     }
 
@@ -188,7 +189,7 @@ var loopVisitor = {
           return;
         }
 
-        loopText = loopText + "|" + node.label.name;
+        loopText = `${loopText}|${node.label.name}`;
       } else {
         // we shouldn't be transforming these statements because
         // they don't refer to the actual loop we're scopifying
@@ -203,7 +204,7 @@ var loopVisitor = {
       replace = t.literal(loopText);
     }
 
-    if (t.isReturnStatement(node)) {
+    if (this.isReturnStatement()) {
       state.hasReturn = true;
       replace = t.objectExpression([
         t.property("init", t.identifier("v"), node.argument || t.identifier("undefined"))
@@ -326,7 +327,7 @@ class BlockScoping {
       for (var name in outsideRefs) {
         var id = outsideRefs[name];
 
-        if (this.scope.hasGlobal(id.name)) {
+        if (this.scope.hasGlobal(id.name) || this.scope.parentHasBinding(id.name)) {
           delete outsideRefs[id.name];
           delete this.letReferences[id.name];
 

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

@@ -1,31 +1,56 @@
 import ReplaceSupers from "../../helpers/replace-supers";
-import nameMethod from "../../helpers/name-method";
-import defineMap from "../../helpers/define-map";
+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 t from "../../../types";
 
-exports.check = t.isClass;
+export var check = t.isClass;
 
-exports.ClassDeclaration = function (node, parent, scope, file) {
-  return new ClassTransformer(node, file, scope, true).run();
-};
+export function ClassDeclaration(node, parent, scope, file) {
+  return t.variableDeclaration("let", [
+    t.variableDeclarator(node.id, t.toExpression(node))
+  ]);
+}
 
-exports.ClassExpression = function (node, parent, scope, file) {
-  if (!node.id) {
-    if (t.isProperty(parent) && parent.value === node && !parent.computed && t.isIdentifier(parent.key)) {
-      // var o = { foo: class {} };
-      node.id = parent.key;
+export function ClassExpression(node, parent, scope, file) {
+  return new ClassTransformer(node, parent, scope, file).run();
+}
+
+var verifyConstructorVisitor = traverse.explode({
+  MethodDefinition: {
+    enter() {
+      this.skip();
     }
+  },
 
-    if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
-      // var foo = class {};
-      node.id = parent.id;
+  Property: {
+    enter(node) {
+      if (node.method) this.skip();
+    }
+  },
+
+  CallExpression: {
+    enter(node, parent, scope, state) {
+      if (t.isIdentifier(node.callee, { name: "super" })) {
+        state.hasBareSuper = true;
+
+        if (!state.hasSuper) {
+          throw state.file.errorWithNode(node, "super call is only allowed in derived constructor");
+        }
+      }
+    }
+  },
+
+  ThisExpression: {
+    enter(node, parent, scope, state) {
+      if (state.hasSuper && !state.hasBareSuper) {
+        throw state.file.errorWithNode(node, "'this' is not allowed before super()");
+      }
     }
   }
-
-  return new ClassTransformer(node, file, scope, false).run();
-};
+});
 
 class ClassTransformer {
 
@@ -33,27 +58,31 @@ class ClassTransformer {
    * Description
    *
    * @param {Node} node
-   * @param {File} file
+   * @param {Node} parent
    * @param {Scope} scope
-   * @param {Boolean} isStatement
+   * @param {File} file
    */
 
-  constructor(node, file, scope, isStatement) {
-    this.isStatement = isStatement;
-    this.scope       = scope;
-    this.node        = node;
-    this.file        = file;
+  constructor(node, parent, scope, file) {
+    this.parent = parent;
+    this.scope  = scope;
+    this.node   = node;
+    this.file   = file;
 
     this.hasInstanceMutators = false;
     this.hasStaticMutators   = false;
 
     this.instanceMutatorMap = {};
     this.staticMutatorMap   = {};
-    this.hasConstructor     = false;
-    this.className          = node.id || scope.generateUidIdentifier("class");
-    this.superName          = node.superClass || t.identifier("Function");
-    this.hasSuper           = !!node.superClass;
-    this.isLoose            = file.isLoose("es6.classes");
+
+    this.hasConstructor = false;
+    this.className      = node.id;
+    this.classRef       = node.id || scope.generateUidIdentifier("class");
+
+    this.superName = node.superClass || t.identifier("Function");
+    this.hasSuper  = !!node.superClass;
+
+    this.isLoose = file.isLoose("es6.classes");
   }
 
   /**
@@ -66,39 +95,35 @@ class ClassTransformer {
     var superName = this.superName;
     var className = this.className;
     var classBody = this.node.body.body;
+    var classRef  = this.classRef;
     var file      = this.file;
 
     //
 
     var body = this.body = [];
 
+    //
+
     var constructorBody = t.blockStatement([
       t.expressionStatement(t.callExpression(file.addHelper("class-call-check"), [
         t.thisExpression(),
-        className
+        classRef
       ]))
     ]);
 
     var constructor;
-    if (this.node.id) {
-      constructor = t.functionDeclaration(className, [], constructorBody);
+
+    if (this.className) {
+      constructor = t.functionDeclaration(this.className, [], constructorBody);
       body.push(constructor);
     } else {
-      var constructorName = null;
-      // when a class has no parent and there is only a constructor or no body
-      // then the constructor is not wrapped in a closure and needs to be named
-      var containsOnlyConstructor = classBody.length === 1 && classBody[0].key.name === "constructor";
-      if (!this.hasSuper && (classBody.length === 0 || containsOnlyConstructor)) {
-        constructorName = className;
-      }
-
-      constructor = t.functionExpression(constructorName, [], constructorBody);
-      body.push(t.variableDeclaration("var", [
-        t.variableDeclarator(className, constructor)
-      ]));
+      constructor = t.functionExpression(null, [], constructorBody);
     }
+
     this.constructor = constructor;
 
+    //
+
     var closureParams = [];
     var closureArgs = [];
 
@@ -107,40 +132,40 @@ class ClassTransformer {
     if (this.hasSuper) {
       closureArgs.push(superName);
 
-      if (!t.isIdentifier(superName)) {
-        superName = this.scope.generateUidBasedOnNode(superName, this.file);
-      }
-
+      superName = this.scope.generateUidBasedOnNode(superName, this.file);
       closureParams.push(superName);
 
       this.superName = superName;
-      body.push(t.expressionStatement(t.callExpression(file.addHelper("inherits"), [className, superName])));
+      body.push(t.expressionStatement(t.callExpression(file.addHelper("inherits"), [classRef, superName])));
     }
 
+    //
+
     this.buildBody();
 
-    t.inheritsComments(body[0], this.node);
 
-    var init;
-
-    if (body.length === 1) {
-      // only a constructor so no need for a closure container
-      init = t.toExpression(constructor);
+    if (this.className) {
+      // named class with only a constructor
+      if (body.length === 1) return t.toExpression(body[0]);
     } else {
-      body.push(t.returnStatement(className));
-      init = t.callExpression(
-        t.functionExpression(null, closureParams, t.blockStatement(body)),
-        closureArgs
-      );
+      // infer class name if this is a nameless class expression
+      constructor = nameMethod.bare(constructor, this.parent, this.scope);
+
+      body.unshift(t.variableDeclaration("var", [
+        t.variableDeclarator(classRef, constructor)
+      ]));
+
+      t.inheritsComments(body[0], this.node);
     }
 
-    if (this.isStatement) {
-      return t.variableDeclaration("let", [
-        t.variableDeclarator(className, init)
-      ]);
-    } else {
-      return init;
-    }
+    //
+
+    body.push(t.returnStatement(classRef));
+
+    return t.callExpression(
+      t.functionExpression(null, closureParams, t.blockStatement(body)),
+      closureArgs
+    );
   }
 
   /**
@@ -157,18 +182,22 @@ class ClassTransformer {
     for (var i = 0; i < classBody.length; i++) {
       var node = classBody[i];
       if (t.isMethodDefinition(node)) {
+        var isConstructor = (!node.computed && t.isIdentifier(node.key, { name: "constructor" })) || t.isLiteral(node.key, { value: "constructor" });
+        if (isConstructor) this.verifyConstructor(node);
+
         var replaceSupers = new ReplaceSupers({
           methodNode: node,
-          className:  this.className,
-          superName:  this.superName,
+          objectRef:  this.classRef,
+          superRef:   this.superName,
           isStatic:   node.static,
           isLoose:    this.isLoose,
           scope:      this.scope,
           file:       this.file
         }, true);
+
         replaceSupers.replace();
 
-        if ((!node.computed && t.isIdentifier(node.key, { name: "constructor" })) || t.isLiteral(node.key, { value: "constructor" })) {
+        if (isConstructor) {
           this.pushConstructor(node);
         } else {
           this.pushMethod(node);
@@ -182,7 +211,7 @@ class ClassTransformer {
     }
 
     // we have no constructor, we have a super, and the super doesn't appear to be falsy
-    if (!this.hasConstructor && this.hasSuper && !t.isFalsyExpression(superName)) {
+    if (!this.hasConstructor && this.hasSuper && t.evaluateTruthy(superName, this.scope) !== false) {
       var helperName = "class-super-constructor-call";
       if (this.isLoose) helperName += "-loose";
       constructor.body.body.push(util.template(helperName, {
@@ -195,25 +224,47 @@ class ClassTransformer {
     var staticProps;
 
     if (this.hasInstanceMutators) {
-      instanceProps = defineMap.build(this.instanceMutatorMap);
+      instanceProps = defineMap.toClassObject(this.instanceMutatorMap);
     }
 
     if (this.hasStaticMutators) {
-      staticProps = defineMap.build(this.staticMutatorMap);
+      staticProps = defineMap.toClassObject(this.staticMutatorMap);
     }
 
     if (instanceProps || staticProps) {
-      staticProps ||= t.literal(null);
+      instanceProps ||= t.literal(null);
 
-      var args = [className, staticProps];
-      if (instanceProps) args.push(instanceProps);
+      var args = [this.classRef, instanceProps];
+      if (staticProps) args.push(staticProps);
 
       body.push(t.expressionStatement(
-        t.callExpression(this.file.addHelper("prototype-properties"), args)
+        t.callExpression(this.file.addHelper("create-class"), args)
       ));
     }
   }
 
+  /**
+   * Description
+   *
+   * @param {Node} node
+   */
+
+   verifyConstructor(node) {
+    return; // enable this for the next major
+
+    var state = {
+      hasBareSuper: false,
+      hasSuper:     this.hasSuper,
+      file:         this.file
+    };
+
+    traverse(node, verifyConstructorVisitor, this.scope, state);
+
+    if (!state.hasBareSuper && this.hasSuper) {
+      throw this.file.errorWithNode(node, "Derived constructor must call super()");
+    }
+   }
+
   /**
    * Push a method to its respective mutatorMap.
    *
@@ -231,9 +282,9 @@ class ClassTransformer {
       if (this.isLoose) {
         // use assignments instead of define properties for loose classes
 
-        var className = this.className;
-        if (!node.static) className = t.memberExpression(className, t.identifier("prototype"));
-        methodName = t.memberExpression(className, methodName, node.computed);
+        var classRef = this.classRef;
+        if (!node.static) classRef = t.memberExpression(classRef, t.identifier("prototype"));
+        methodName = t.memberExpression(classRef, methodName, node.computed);
 
         var expr = t.expressionStatement(t.assignmentExpression("=", methodName, node.value));
         t.inheritsComments(expr, node);
@@ -253,7 +304,6 @@ class ClassTransformer {
     }
 
     defineMap.push(mutatorMap, methodName, kind, node.computed, node);
-    defineMap.push(mutatorMap, methodName, "enumerable", node.computed, false);
   }
 
   /**
@@ -268,7 +318,7 @@ class ClassTransformer {
     var key;
 
     if (node.static) {
-      key = t.memberExpression(this.className, node.key);
+      key = t.memberExpression(this.classRef, node.key);
       this.body.push(
         t.expressionStatement(t.assignmentExpression("=", key, node.value))
       );
@@ -301,6 +351,8 @@ class ClassTransformer {
 
     construct._ignoreUserWhitespace = true;
     construct.params                = fn.params;
-    construct.body.body             = construct.body.body.concat(fn.body.body);
+
+    t.inherits(construct.body, fn.body);
+    construct.body.body = construct.body.body.concat(fn.body.body);
   }
 }

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

@@ -1,14 +1,14 @@
 import * as messages from "../../../messages";
 import t from "../../../types";
 
-exports.check = function (node) {
+export function check(node) {
   return t.isVariableDeclaration(node, { kind: "const" });
-};
+}
 
 var visitor = {
   enter(node, parent, scope, state) {
-    if (t.isAssignmentExpression(node) || t.isUpdateExpression(node)) {
-      var ids = t.getBindingIdentifiers(node);
+    if (this.isAssignmentExpression() || this.isUpdateExpression()) {
+      var ids = this.getBindingIdentifiers();
 
       for (var name in ids) {
         var id = ids[name];
@@ -30,19 +30,19 @@ var visitor = {
 
         throw state.file.errorWithNode(id, messages.get("readOnly", name));
       }
-    } else if (t.isScope(node, parent)) {
+    } else if (this.isScope()) {
       this.skip();
     }
   }
 };
 
-exports.Scopable = function (node, parent, scope, file) {
+export function Scopable(node, parent, scope, file) {
   scope.traverse(node, visitor, {
     constants: scope.getAllBindingsOfKind("const"),
     file:      file
   });
-};
+}
 
-exports.VariableDeclaration = function (node) {
+export function VariableDeclaration(node) {
   if (node.kind === "const") node.kind = "let";
-};
+}

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

@@ -1,10 +1,9 @@
 import * as messages from "../../../messages";
 import t from "../../../types";
 
-exports.check = t.isPattern;
+export var check = t.isPattern;
 
-exports.ForInStatement =
-exports.ForOfStatement = function (node, parent, scope, file) {
+export function ForOfStatement(node, parent, scope, file) {
   var left = node.left;
 
   if (t.isPattern(left)) {
@@ -50,17 +49,19 @@ exports.ForOfStatement = function (node, parent, scope, file) {
 
   var block = node.body;
   block.body = nodes.concat(block.body);
-};
+}
+
+export { ForOfStatement as ForInStatement };
 
 exports.Function = function (node, parent, scope, file) {
   var nodes = [];
 
-  var hasDestructuringTransformer = false;
+  var hasDestructuring = false;
 
   node.params = node.params.map(function (pattern, i) {
     if (!t.isPattern(pattern)) return pattern;
 
-    hasDestructuringTransformer = true;
+    hasDestructuring = true;
     var ref = scope.generateUidIdentifier("ref");
 
     var destructuring = new DestructuringTransformer({
@@ -68,22 +69,23 @@ exports.Function = function (node, parent, scope, file) {
       nodes:      nodes,
       scope:      scope,
       file:       file,
-      kind:       "var",
+      kind:       "let"
     });
     destructuring.init(pattern, ref);
 
     return ref;
   });
 
-  if (!hasDestructuringTransformer) return;
+  if (!hasDestructuring) return;
 
+  file.checkNode(nodes);
   t.ensureBlock(node);
 
   var block = node.body;
   block.body = nodes.concat(block.body);
 };
 
-exports.CatchClause = function (node, parent, scope, file) {
+export function CatchClause(node, parent, scope, file) {
   var pattern = node.param;
   if (!t.isPattern(pattern)) return;
 
@@ -103,9 +105,9 @@ exports.CatchClause = function (node, parent, scope, file) {
   node.body.body = nodes.concat(node.body.body);
 
   return node;
-};
+}
 
-exports.ExpressionStatement = function (node, parent, scope, file) {
+export function ExpressionStatement(node, parent, scope, file) {
   var expr = node.expression;
   if (expr.type !== "AssignmentExpression") return;
   if (!t.isPattern(expr.left)) return;
@@ -127,9 +129,9 @@ exports.ExpressionStatement = function (node, parent, scope, file) {
   destructuring.init(expr.left, ref);
 
   return nodes;
-};
+}
 
-exports.AssignmentExpression = function (node, parent, scope, file) {
+export function AssignmentExpression(node, parent, scope, file) {
   if (!t.isPattern(node.left)) return;
 
   var ref = scope.generateUidIdentifier("temp");
@@ -152,18 +154,18 @@ exports.AssignmentExpression = function (node, parent, scope, file) {
   nodes.push(ref);
 
   return t.toSequenceExpression(nodes, scope);
-};
+}
 
-var variableDeclarationHasPattern = function (node) {
+function variableDeclarationHasPattern(node) {
   for (var i = 0; i < node.declarations.length; i++) {
     if (t.isPattern(node.declarations[i].id)) {
       return true;
     }
   }
   return false;
-};
+}
 
-exports.VariableDeclaration = function (node, parent, scope, file) {
+export function VariableDeclaration(node, parent, scope, file) {
   if (t.isForInStatement(parent) || t.isForOfStatement(parent)) return;
   if (!variableDeclarationHasPattern(node)) return;
 
@@ -217,7 +219,7 @@ exports.VariableDeclaration = function (node, parent, scope, file) {
   }
 
   return nodes;
-};
+}
 
 var hasRest = function (pattern) {
   for (var i = 0; i < pattern.elements.length; i++) {

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

@@ -2,9 +2,9 @@ import * as messages from "../../../messages";
 import * as util from  "../../../util";
 import t from "../../../types";
 
-exports.check = t.isForOfStatement;
+export var check = t.isForOfStatement;
 
-exports.ForOfStatement = function (node, parent, scope, file) {
+export function ForOfStatement(node, parent, scope, file) {
   var callback = spec;
   if (file.isLoose("es6.forOf")) callback = loose;
 
@@ -32,22 +32,29 @@ exports.ForOfStatement = function (node, parent, scope, file) {
   // todo: find out why this is necessary? #538
   loop._scopeInfo = node._scopeInfo;
 
-  return build.node;
-};
+  if (build.replaceParent) {
+    this.parentPath.node = build.node;
+  } else {
+    return build.node;
+  }
+}
 
 var breakVisitor = {
   enter(node, parent, scope, state) {
-    if (t.isLoop(node)) {
+    if (this.isLoop()) {
       state.ignoreLabeless = true;
       scope.traverse(node, breakVisitor, state);
       state.ignoreLabeless = false;
       return this.skip();
     }
 
-    if (t.isBreakStatement(node)) {
+    if (this.isBreakStatement()) {
       if (!node.label && state.ignoreLabeless) return;
       if (node.label && node.label.name !== state.label) return;
 
+      // break statements mean something different in this context
+      if (t.isSwitchCase(parent)) return;
+
       var ret = t.expressionStatement(
         t.callExpression(t.memberExpression(state.iteratorKey, t.identifier("return")), [])
       );
@@ -97,7 +104,9 @@ var loose = function (node, parent, scope, file) {
 
   scope.traverse(node, breakVisitor, {
     iteratorKey: iteratorKey,
-    wrapReturn:  function (node) {
+    label:       t.isLabeledStatement(parent) && parent.label.name,
+
+    wrapReturn(node) {
       return t.ifStatement(
         t.logicalExpression(
           "&&",
@@ -105,8 +114,7 @@ var loose = function (node, parent, scope, file) {
           t.memberExpression(iteratorKey, t.identifier("return")
         )
       ), node);
-    },
-    label:       t.isLabeledStatement(parent) && parent.label.name
+    }
   });
 
   //
@@ -151,14 +159,22 @@ var spec = function (node, parent, scope, file) {
     BODY:                   null
   });
 
-  var loop = template[3].block.body[0];
+  var isLabeledParent = t.isLabeledStatement(parent);
+
+  var tryBody = template[3].block.body;
+  var loop = tryBody[0];
+
+  if (isLabeledParent) {
+    tryBody[0] = t.labeledStatement(parent.label, loop);
+  }
 
   //
 
   scope.traverse(node, breakVisitor, {
     iteratorKey: iteratorKey,
-    label:       t.isLabeledStatement(parent) && parent.label.name,
-    wrapReturn:  function (node) {
+    label:       isLabeledParent && parent.label.name,
+
+    wrapReturn(node) {
       return t.ifStatement(t.memberExpression(iteratorKey, t.identifier("return")), node);
     }
   });
@@ -166,8 +182,9 @@ var spec = function (node, parent, scope, file) {
   //
 
   return {
-    declar: declar,
-    loop:   loop,
-    node:   template
+    replaceParent: isLabeledParent,
+    declar:        declar,
+    loop:          loop,
+    node:          template
   };
 };

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

@@ -5,7 +5,7 @@ export function check(node) {
   return t.isIdentifier(node, { name: "super" });
 }
 
-export function Property(node, parent, scope, file) {
+function Property(node, scope, getObjectRef, file) {
   if (!node.method) return;
 
   var value = node.value;
@@ -13,8 +13,8 @@ export function Property(node, parent, scope, file) {
 
   var replaceSupers = new ReplaceSupers({
     topLevelThisReference: thisExpr,
+    getObjectRef:          getObjectRef,
     methodNode:            node,
-    className:             thisExpr,
     isStatic:              true,
     scope:                 scope,
     file:                  file
@@ -30,3 +30,20 @@ export function Property(node, parent, scope, file) {
     );
   }
 }
+
+export function ObjectExpression(node, parent, scope, file) {
+  var objectRef;
+  var getObjectRef = () => objectRef ||= scope.generateUidIdentifier("obj");
+
+  for (var i = 0; i < node.properties.length; i++) {
+    Property(node.properties[i], scope, getObjectRef, file);
+  }
+
+  if (objectRef) {
+    scope.push({
+      id: objectRef
+    });
+
+    return t.assignmentExpression("=", objectRef, node);
+  }
+}

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

@@ -14,7 +14,7 @@ var hasDefaults = function (node) {
 
 var iifeVisitor = {
   enter(node, parent, scope, state) {
-    if (!t.isReferencedIdentifier(node, parent)) return;
+    if (!this.isReferencedIdentifier()) return;
     if (!state.scope.hasOwnBinding(node.name)) return;
     if (state.scope.bindingIdentifierEquals(node.name, node)) return;
 
@@ -61,7 +61,7 @@ exports.Function = function (node, parent, scope, file) {
         scope.traverse(param, iifeVisitor, state);
       }
 
-      if (file.transformers["es6.blockScopingTDZ"].canRun()) {
+      if (file.transformers["es6.blockScopingTDZ"].canRun() && t.isIdentifier(param)) {
         pushDefNode(param, t.identifier("undefined"), i);
       }
 

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

@@ -2,18 +2,18 @@ import isNumber from "lodash/lang/isNumber";
 import * as util from  "../../../util";
 import t from "../../../types";
 
-exports.check = t.isRestElement;
+export var check = t.isRestElement;
 
 var memberExpressionOptimisationVisitor = {
   enter(node, parent, scope, state) {
     // check if this scope has a local binding that will shadow the rest parameter
-    if (t.isScope(node, parent) && !scope.bindingIdentifierEquals(state.name, state.outerBinding)) {
+    if (this.isScope() && !scope.bindingIdentifierEquals(state.name, state.outerBinding)) {
       return this.skip();
     }
 
     // skip over functions as whatever `arguments` we reference inside will refer
     // to the wrong function
-    if (t.isFunctionDeclaration(node) || t.isFunctionExpression(node)) {
+    if (this.isFunctionDeclaration() || this.isFunctionExpression()) {
       state.noOptimise = true;
       scope.traverse(node, memberExpressionOptimisationVisitor, state);
       state.noOptimise = false;
@@ -21,33 +21,31 @@ var memberExpressionOptimisationVisitor = {
     }
 
     // is this a referenced identifier and is it referencing the rest parameter?
-    if (!t.isReferencedIdentifier(node, parent, { name: state.name })) return;
+    if (!this.isReferencedIdentifier({ name: state.name })) return;
 
     if (!state.noOptimise && t.isMemberExpression(parent) && parent.computed) {
       // if we know that this member expression is referencing a number then we can safely
       // optimise it
       var prop = parent.property;
       if (isNumber(prop.value) || t.isUnaryExpression(prop) || t.isBinaryExpression(prop)) {
-        optimizeMemberExpression(node, parent, state.method.params.length);
-        state.hasShorthand = true;
+        state.candidates.push(this);
         return;
       }
     }
 
-    state.longForm = true;
+    state.canOptimise = false;
+    this.stop();
   }
 };
 
-function optimizeMemberExpression(node, parent, offset) {
+function optimizeMemberExpression(parent, offset) {
   var newExpr;
   var prop = parent.property;
 
   if (t.isLiteral(prop)) {
-    node.name = "arguments";
     prop.value += offset;
     prop.raw = String(prop.value);
   } else { // // UnaryExpression, BinaryExpression
-    node.name = "arguments";
     newExpr = t.binaryExpression("+", prop, t.literal(offset));
     parent.property = newExpr;
   }
@@ -57,7 +55,7 @@ var hasRest = function (node) {
   return t.isRestElement(node.params[node.params.length - 1]);
 };
 
-exports.Function = function (node, parent, scope) {
+exports.Function = function (node, parent, scope, file) {
   if (!hasRest(node)) return;
 
   var rest = node.params.pop().argument;
@@ -71,10 +69,12 @@ exports.Function = function (node, parent, scope) {
   if (t.isPattern(rest)) {
     var pattern = rest;
     rest = scope.generateUidIdentifier("ref");
-    var declar = t.variableDeclaration("var", pattern.elements.map(function (elem, index) {
+
+    var declar = t.variableDeclaration("let", pattern.elements.map(function (elem, index) {
       var accessExpr = t.memberExpression(rest, t.literal(index), true);
       return t.variableDeclarator(elem, accessExpr);
     }));
+    file.checkNode(declar);
     node.body.body.unshift(declar);
   }
 
@@ -82,16 +82,23 @@ exports.Function = function (node, parent, scope) {
 
   var state = {
     outerBinding: scope.getBindingIdentifier(rest.name),
-    hasShorthand: true,
-    longForm:     false,
+    canOptimise:  true,
+    candidates:   [],
     method:       node,
-    name:         rest.name,
+    name:         rest.name
   };
 
   scope.traverse(node, memberExpressionOptimisationVisitor, state);
 
   // we only have shorthands and there's no other references
-  if (!state.longForm && state.hasShorthand) return;
+  if (state.canOptimise && state.candidates.length) {
+    for (var i = 0; i < state.candidates.length; i++) {
+      var candidate = state.candidates[i];
+      candidate.node = argsId;
+      optimizeMemberExpression(candidate.parent, node.params.length);
+    }
+    return;
+  }
 
   //
 

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

@@ -1,4 +1,3 @@
-import clone from "lodash/lang/clone";
 import t from "../../../types";
 
 export function check(node) {
@@ -12,6 +11,6 @@ export function Property(node) {
 
   if (node.shorthand) {
     node.shorthand = false;
-    node.key = t.removeComments(clone(node.key));
+    node.key = t.removeComments(t.clone(node.key));
   }
 }

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

@@ -1,8 +1,6 @@
 import includes from "lodash/collection/includes";
 import t from "../../../types";
 
-exports.check = t.isSpreadElement;
-
 function getSpreadLiteral(spread, scope) {
   return scope.toArray(spread.argument, true);
 }
@@ -42,6 +40,8 @@ function build(props, scope) {
   return nodes;
 }
 
+export var check = t.isSpreadElement;
+
 export function ArrayExpression(node, parent, scope) {
   var elements = node.elements;
   if (!hasSpread(elements)) return;

src/babel/transformation/transformers/es6/tail-call.js

@@ -17,7 +17,7 @@ function returnBlock(expr) {
 // looks for and replaces tail recursion calls
 var firstPass = {
   enter(node, parent, scope, state) {
-    if (t.isIfStatement(node)) {
+    if (this.isIfStatement()) {
       if (t.isReturnStatement(node.alternate)) {
         t.ensureBlock(node, "alternate");
       }
@@ -25,7 +25,7 @@ var firstPass = {
       if (t.isReturnStatement(node.consequent)) {
         t.ensureBlock(node, "consequent");
       }
-    } else if (t.isReturnStatement(node)) {
+    } else if (this.isReturnStatement()) {
       this.skip();
       return state.subTransform(node.argument);
     } else if (t.isTryStatement(parent)) {
@@ -34,9 +34,9 @@ var firstPass = {
       } else if (parent.finalizer && node !== parent.finalizer) {
         this.skip();
       }
-    } else if (t.isFunction(node)) {
+    } else if (this.isFunction()) {
       this.skip();
-    } else if (t.isVariableDeclaration(node)) {
+    } else if (this.isVariableDeclaration()) {
       this.skip();
       state.vars.push(node);
     }
@@ -47,15 +47,15 @@ var firstPass = {
 // them as needed
 var secondPass = {
   enter(node, parent, scope, state) {
-    if (t.isThisExpression(node)) {
+    if (this.isThisExpression()) {
       state.needsThis = true;
       return state.getThisId();
-    } else if (t.isReferencedIdentifier(node, parent, { name: "arguments" })) {
+    } else if (this.isReferencedIdentifier({ name: "arguments" })) {
       state.needsArguments = true;
       return state.getArgumentsId();
-    } else if (t.isFunction(node)) {
+    } else if (this.isFunction()) {
       this.skip();
-      if (t.isFunctionDeclaration(node)) {
+      if (this.isFunctionDeclaration()) {
         node = t.variableDeclaration("var", [
           t.variableDeclarator(node.id, t.toExpression(node))
         ]);
@@ -69,7 +69,7 @@ var secondPass = {
 // optimizes recursion by removing `this` and `arguments` if they aren't used
 var thirdPass = {
   enter(node, parent, scope, state) {
-    if (!t.isExpressionStatement(node)) return;
+    if (!this.isExpressionStatement()) return;
 
     var expr = node.expression;
     if (!t.isAssignmentExpression(expr)) return;
@@ -229,7 +229,7 @@ class TailCallTransformer {
   subTransform(node) {
     if (!node) return;
 
-    var handler = this["subTransform" + node.type];
+    var handler = this[`subTransform${node.type}`];
     if (handler) return handler.call(this, node);
   }
 

src/babel/transformation/transformers/index.js

@@ -1,9 +1,9 @@
 export default {
-  useStrict:                               require("./other/use-strict"),
+  strict:                                  require("./other/strict"),
+
+  _validation:                             require("./internal/validation"),
 
   "validation.undeclaredVariableCheck":    require("./validation/undeclared-variable-check"),
-  "validation.noForInOfAssignment":        require("./validation/no-for-in-of-assignment"),
-  "validation.setters":                    require("./validation/setters"),
   "validation.react":                      require("./validation/react"),
 
   // this goes at the start so we only transform the original user code
@@ -97,16 +97,18 @@ export default {
   "spec.typeofSymbol":                     require("./spec/typeof-symbol"),
   "spec.undefinedToVoid":                  require("./spec/undefined-to-void"),
 
-  _useStrict:                              require("./internal/use-strict"),
+  _strict:                                 require("./internal/strict"),
   _moduleFormatter:                        require("./internal/module-formatter"),
 
   "es3.propertyLiterals":                  require("./es3/property-literals"),
   "es3.memberExpressionLiterals":          require("./es3/member-expression-literals"),
 
-  "minification.removeDebugger":           require("./minification/remove-debugger"),
-  "minification.removeConsoleCalls":       require("./minification/remove-console-calls"),
-  "minification.deadCodeElimination":      require("./minification/dead-code-elimination"),
-  "minification.renameLocalVariables":     require("./minification/rename-local-variables"),
+  "utility.removeDebugger":                require("./utility/remove-debugger"),
+  "utility.removeConsole":                 require("./utility/remove-console"),
+
+  "utility.inlineEnvironmentVariables":    require("./utility/inline-environment-variables"),
+  "utility.inlineExpressions":             require("./utility/inline-expressions"),
+  "utility.deadCodeElimination":           require("./utility/dead-code-elimination"),
 
   _cleanUp:                                require("./internal/cleanup")
 };

src/babel/transformation/transformers/internal/alias-functions.js

@@ -2,7 +2,7 @@ import t from "../../../types";
 
 var functionChildrenVisitor = {
   enter(node, parent, scope, state) {
-    if (t.isFunction(node) && !node._aliasFunction) {
+    if (this.isFunction() && !node._aliasFunction) {
       return this.skip();
     }
 
@@ -10,22 +10,22 @@ var functionChildrenVisitor = {
 
     var getId;
 
-    if (t.isIdentifier(node) && node.name === "arguments") {
+    if (this.isIdentifier() && node.name === "arguments") {
       getId = state.getArgumentsId;
-    } else if (t.isThisExpression(node)) {
+    } else if (this.isThisExpression()) {
       getId = state.getThisId;
     } else {
       return;
     }
 
-    if (t.isReferenced(node, parent)) return getId();
+    if (this.isReferenced()) return getId();
   }
 };
 
 var functionVisitor = {
   enter(node, parent, scope, state) {
     if (!node._aliasFunction) {
-      if (t.isFunction(node)) {
+      if (this.isFunction()) {
         // stop traversal of this node as it'll be hit again by this transformer
         return this.skip();
       } else {
@@ -76,16 +76,17 @@ var go = function (getBody, node, scope) {
   }
 };
 
-exports.Program = function (node, parent, scope) {
+export function Program(node, parent, scope) {
   go(function () {
     return node.body;
   }, node, scope);
 };
 
-exports.FunctionDeclaration =
-exports.FunctionExpression = function (node, parent, scope) {
+export function FunctionDeclaration(node, parent, scope) {
   go(function () {
     t.ensureBlock(node);
     return node.body.body;
   }, node, scope);
-};
+}
+
+export { FunctionDeclaration as FunctionExpression };

src/babel/transformation/transformers/internal/block-hoist.js

@@ -9,8 +9,7 @@ import values from "lodash/object/values";
 //  - 2 Priority over normal nodes
 //  - 3 We want this to be at the **very** top
 
-exports.BlockStatement =
-exports.Program = {
+export var BlockStatement = {
   exit(node) {
     var hasChange = false;
     for (var i = 0; i < node.body.length; i++) {
@@ -29,3 +28,5 @@ exports.Program = {
     node.body = flatten(values(nodePriorities).reverse());
   }
 };
+
+export { BlockStatement as Program };

src/babel/transformation/transformers/internal/cleanup.js

@@ -1,5 +1,15 @@
-export function SequenceExpression(node) {
-  if (node.expressions.length === 1) {
-    return node.expressions[0];
+export var SequenceExpression = {
+  exit(node) {
+    if (node.expressions.length === 1) {
+      return node.expressions[0];
+    } else if (!node.expressions.length) {
+      this.remove();
+    }
   }
-}
+};
+
+export var ExpressionStatement = {
+  exit(node) {
+    if (!node.expression) this.remove();
+  }
+};

src/babel/transformation/transformers/internal/declarations.js

@@ -1,13 +1,12 @@
-import useStrict from "../../helpers/use-strict";
+import * as strict from "../../helpers/strict";
 import t from "../../../types";
 
 export var secondPass = true;
 
-exports.BlockStatement =
-exports.Program = function (node, parent, scope, file) {
+export function BlockStatement(node, parent, scope, file) {
   if (!node._declarations) return;
 
-  useStrict.wrap(node, function () {
+  strict.wrap(node, function () {
     var kinds = {};
     var kind;
 
@@ -31,4 +30,6 @@ exports.Program = function (node, parent, scope, file) {
 
     node._declarations = null;
   });
-};
+}
+
+export { BlockStatement as Program };

src/babel/transformation/transformers/internal/module-formatter.js

@@ -1,12 +1,12 @@
-import useStrict from "../../helpers/use-strict";
+import * as strict from "../../helpers/strict";
 
 export function Program(program, parent, scope, file) {
-  if (!file.transformers["es6.modules"].canRun()) return;
-
-  useStrict.wrap(program, function () {
+  strict.wrap(program, function () {
     program.body = file.dynamicImports.concat(program.body);
   });
 
+  if (!file.transformers["es6.modules"].canRun()) return;
+
   if (file.moduleFormatter.transform) {
     file.moduleFormatter.transform(program);
   }

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

@@ -13,7 +13,7 @@ export function check(node) {
 export function ImportDeclaration(node, parent, scope, file) {
   var resolveModuleSource = file.opts.resolveModuleSource;
   if (node.source && resolveModuleSource) {
-    node.source.value = resolveModuleSource(node.source.value);
+    node.source.value = resolveModuleSource(node.source.value, file.opts.filename);
   }
 }
 
@@ -52,6 +52,16 @@ export function ExportDeclaration(node, parent, scope) {
       node.declaration = null;
       node._blockHoist = 2;
       return [getDeclar(), node];
+    } else if (t.isVariableDeclaration(declar)) {
+      var specifiers = [];
+
+      var bindings = t.getBindingIdentifiers(declar);
+      for (var key in bindings) {
+        var id = bindings[key];
+        specifiers.push(t.exportSpecifier(id, id));
+      }
+
+      return [declar, t.exportDeclaration(null, specifiers)];
     }
   }
 }

src/babel/transformation/transformers/internal/strict.js

@@ -1,7 +1,7 @@
 import t from "../../../types";
 
 export function Program(program, parent, scope, file) {
-  if (file.transformers.useStrict.canRun()) {
+  if (file.transformers.strict.canRun()) {
     program.body.unshift(t.expressionStatement(t.literal("use strict")));
   }
 }

src/babel/transformation/transformers/internal/validation.js

@@ -0,0 +1,27 @@
+import * as messages from "../../../messages";
+import t from "../../../types";
+
+export function ForOfStatement(node, parent, scope, file) {
+  var left = node.left;
+  if (t.isVariableDeclaration(left)) {
+    var declar = left.declarations[0];
+    if (declar.init) throw file.errorWithNode(declar, messages.get("noAssignmentsInForHead"));
+  }
+}
+
+export { ForOfStatement as ForInStatement };
+
+export function Property(node, parent, scope, file) {
+  if (node.kind === "set") {
+    if (node.value.params.length !== 1) {
+      throw file.errorWithNode(node.value, messages.get("settersInvalidParamLength"));
+    }
+
+    var first = node.value.params[0];
+    if (t.isRestElement(first)) {
+      throw file.errorWithNode(first, messages.get("settersNoRest"));
+    }
+  }
+}
+
+export { Property as MethodDefinition };

src/babel/transformation/transformers/minification/rename-local-variables.js

@@ -1,9 +0,0 @@
-//import t from "../../../types";
-
-export var optional = true;
-
-export function Scopable() {
-  //for (var name in scope.bindings) {
-  //  scope.rename(name, scope.generateUidIdentifier("a").name);
-  //}
-}

src/babel/transformation/transformers/other/flow.js

@@ -1,5 +1,25 @@
 import t from "../../../types";
 
+export function Flow(node) {
+  this.remove();
+}
+
+export function ClassProperty(node) {
+  node.typeAnnotation = null;
+  if (!node.value) this.remove();
+}
+
+export function Class(node) {
+  node.implements = null;
+}
+
+exports.Function = function (node) {
+  for (var i = 0; i < node.params.length; i++) {
+    var param = node.params[i];
+    param.optional = false;
+  }
+};
+
 export function TypeCastExpression(node) {
   return node.expression;
 }

src/babel/transformation/transformers/other/react-compat.js

@@ -1,4 +1,4 @@
-import react from "../../helpers/react";
+import * as react from "../../helpers/react";
 import t from "../../../types";
 
 export function manipulateOptions(opts) {

src/babel/transformation/transformers/other/react.js

@@ -1,4 +1,4 @@
-import react from "../../helpers/react";
+import * as react from "../../helpers/react";
 import t from "../../../types";
 
 var JSX_ANNOTATION_REGEX = /^\*\s*@jsx\s+([^\s]+)/;

src/babel/transformation/transformers/other/runtime.js

@@ -16,14 +16,15 @@ var ALIASABLE_CONSTRUCTORS = [
   "Map",
   "WeakMap",
   "Set",
-  "WeakSet"
+  "WeakSet",
+  "Number"
 ];
 
 var astVisitor = {
   enter(node, parent, scope, file) {
     var prop;
 
-    if (t.isMemberExpression(node) && t.isReferenced(node, parent)) {
+    if (this.isMemberExpression() && this.isReferenced()) {
       // Array.from -> _core.Array.from
       var obj = node.object;
       prop = node.property;
@@ -34,10 +35,10 @@ var astVisitor = {
         this.skip();
         return t.prependToMemberExpression(node, file.get("coreIdentifier"));
       }
-    } else if (t.isReferencedIdentifier(node, parent) && !t.isMemberExpression(parent) && includes(ALIASABLE_CONSTRUCTORS, node.name) && !scope.getBindingIdentifier(node.name)) {
+    } else if (this.isReferencedIdentifier() && !t.isMemberExpression(parent) && includes(ALIASABLE_CONSTRUCTORS, node.name) && !scope.getBindingIdentifier(node.name)) {
       // Symbol() -> _core.Symbol(); new Promise -> new _core.Promise
       return t.memberExpression(file.get("coreIdentifier"), node);
-    } else if (t.isCallExpression(node)) {
+    } else if (this.isCallExpression()) {
       // arr[Symbol.iterator]() -> _core.$for.getIterator(arr)
 
       var callee = node.callee;
@@ -53,7 +54,7 @@ var astVisitor = {
         CORE_ID: file.get("coreIdentifier"),
         VALUE:   callee.object
       });
-    } else if (t.isBinaryExpression(node)) {
+    } else if (this.isBinaryExpression()) {
       // Symbol.iterator in arr -> core.$for.isIterable(arr)
 
       if (node.operator !== "in") return;
@@ -94,7 +95,7 @@ export function pre(file) {
 }
 
 export function Identifier(node, parent, scope, file) {
-  if (t.isReferencedIdentifier(node, parent, { name: "regeneratorRuntime" })) {
+  if (this.isReferencedIdentifier({ name: "regeneratorRuntime" })) {
     return file.get("regeneratorIdentifier");
   }
 }

src/babel/transformation/transformers/other/strict.js

@@ -8,10 +8,11 @@ export function Program(program) {
   }
 }
 
-exports.FunctionDeclaration =
-exports.FunctionExpression = function () {
+export function FunctionExpression() {
   this.skip();
-};
+}
+
+export { FunctionExpression as FunctionDeclaration };
 
 export function ThisExpression() {
   return t.identifier("undefined");

src/babel/transformation/transformers/playground/mallet-operator.js

@@ -6,8 +6,7 @@ export var playground = true;
 
 build(exports, {
   is(node, file) {
-    var is = t.isAssignmentExpression(node) && node.operator === "||=";
-    if (is) {
+    if (t.isAssignmentExpression(node, { operator: "||=" })) {
       var left = node.left;
       if (!t.isMemberExpression(left) && !t.isIdentifier(left)) {
         throw file.errorWithNode(left, messages.get("expectedMemberExpressionOrIdentifier"));

src/babel/transformation/transformers/playground/memoization-operator.js

@@ -5,7 +5,7 @@ export var playground = true;
 
 build(exports, {
   is(node) {
-    var is = t.isAssignmentExpression(node) && node.operator === "?=";
+    var is = t.isAssignmentExpression(node, { operator: "?=" });
     if (is) t.assertMemberExpression(node.left);
     return is;
   },

src/babel/transformation/transformers/playground/object-getter-memoization.js

@@ -4,9 +4,9 @@ export var playground = true;
 
 var visitor = {
   enter(node, parent, scope, state) {
-    if (t.isFunction(node)) return this.skip();
+    if (this.isFunction()) return this.skip();
 
-    if (t.isReturnStatement(node) && node.argument) {
+    if (this.isReturnStatement() && node.argument) {
       node.argument = t.memberExpression(t.callExpression(state.file.addHelper("define-property"), [
         t.thisExpression(),
         state.key,
@@ -16,8 +16,7 @@ var visitor = {
   }
 };
 
-exports.Property =
-exports.MethodDefinition = function (node, parent, scope, file) {
+export function MethodDefinition(node, parent, scope, file) {
   if (node.kind !== "memo") return;
   node.kind = "get";
 
@@ -38,4 +37,6 @@ exports.MethodDefinition = function (node, parent, scope, file) {
   scope.traverse(value, visitor, state);
 
   return node;
-};
+}
+
+export { MethodDefinition as Property };

src/babel/transformation/transformers/spec/undefined-to-void.js

@@ -3,7 +3,7 @@ import t from "../../../types";
 export var optional = true;
 
 export function Identifier(node, parent) {
-  if (node.name === "undefined" && t.isReferenced(node, parent)) {
+  if (node.name === "undefined" && this.isReferenced()) {
     return t.unaryExpression("void", t.literal(0), true);
   }
 }

src/babel/transformation/transformers/utility/dead-code-elimination.js

@@ -1,31 +1,41 @@
 import t from "../../../types";
 
+function toStatements(node) {
+  if (t.isBlockStatement(node)) {
+    var hasBlockScoped = false;
+
+    for (var i = 0; i < node.body.length; i++) {
+      var bodyNode = node.body[i];
+      if (t.isBlockScoped(bodyNode)) hasBlockScoped = true;
+    }
+
+    if (!hasBlockScoped) {
+      return node.body;
+    }
+  }
+
+  return node;
+}
+
 export var optional = true;
 
-export function ExpressionStatement(node) {
-  // remove consequence-less expressions such as local variables and literals
-  // note: will remove directives
-  //
-  //   var foo = true; foo; -> var foo = true;
-  //   "foo"; ->
-  //
-
-  var expr = node.expression;
-  if (t.isLiteral(expr) || (t.isIdentifier(node) && t.hasBinding(node.name))) {
-    this.remove();
+export function ConditionalExpression(node, parent, scope) {
+  var evaluateTest = t.evaluateTruthy(node.test, scope);
+  if (evaluateTest === true) {
+    return node.consequent;
+  } else if (evaluateTest === false) {
+    return node.alternate;
   }
 }
 
 export var IfStatement = {
-  exit(node) {
-    // todo: in scenarios where we can just return the consequent or
-    // alternate we should drop the block statement if it contains no
-    // block scoped variables
-
+  exit(node, parent, scope) {
     var consequent = node.consequent;
     var alternate  = node.alternate;
     var test       = node.test;
 
+    var evaluateTest = t.evaluateTruthy(test, scope);
+
     // we can check if a test will be truthy 100% and if so then we can inline
     // the consequent and completely ignore the alternate
     //
@@ -33,8 +43,8 @@ export var IfStatement = {
     //   if ("foo") { foo; } -> { foo; }
     //
 
-    if (t.isLiteral(test) && test.value) {
-      return consequent;
+    if (evaluateTest === true) {
+      return toStatements(consequent);
     }
 
     // we can check if a test will be falsy 100% and if so we can inline the
@@ -44,9 +54,9 @@ export var IfStatement = {
     //   if ("") { bar; } ->
     //
 
-    if (t.isFalsyExpression(test)) {
+    if (evaluateTest === false) {
       if (alternate) {
-        return alternate;
+        return toStatements(alternate);
       } else {
         return this.remove();
       }
@@ -67,7 +77,7 @@ export var IfStatement = {
     //   if (foo) {} else { bar; } -> if (!foo) { bar; }
     //
 
-    if (t.blockStatement(consequent) && !consequent.body.length && t.isBlockStatement(alternate) && alternate.body.length) {
+    if (t.isBlockStatement(consequent) && !consequent.body.length && t.isBlockStatement(alternate) && alternate.body.length) {
       node.consequent = node.alternate;
       node.alternate  = null;
       node.test       = t.unaryExpression("!", test, true);

src/babel/transformation/transformers/utility/inline-environment-variables.js

@@ -0,0 +1,14 @@
+import t from "../../../types";
+
+export var optional = true;
+
+var match = t.buildMatchMemberExpression("process.env");
+
+export function MemberExpression(node) {
+  if (match(node.object)) {
+    var key = t.toComputedKey(node, node.property);
+    if (t.isLiteral(key)) {
+      return t.valueToNode(process.env[key.value]);
+    }
+  }
+}

src/babel/transformation/transformers/utility/inline-expressions.js

@@ -0,0 +1,12 @@
+import t from "../../../types";
+
+export var optional = true;
+
+export function Expression(node, parent, scope) {
+  var res = t.evaluate(node, scope);
+  if (res.confident) return t.valueToNode(res.value);
+}
+
+export function Identifier() {
+  // override Expression
+}

src/babel/transformation/transformers/utility/remove-debugger.js

@@ -3,7 +3,7 @@ import t from "../../../types";
 export var optional = true;
 
 export function ExpressionStatement(node) {
-  if (t.isIdentifier(node.expression, { name: "debugger" })) {
+  if (this.get("expression").isIdentifier({ name: "debugger" })) {
     this.remove();
   }
 }

src/babel/transformation/transformers/validation/no-for-in-of-assignment.js

@@ -1,13 +0,0 @@
-import * as messages from "../../../messages";
-import t from "../../../types";
-
-export { isFor as check } from "../../../types";
-
-exports.ForInStatement =
-exports.ForOfStatement = function (node, parent, scope, file) {
-  var left = node.left;
-  if (t.isVariableDeclaration(left)) {
-    var declar = left.declarations[0];
-    if (declar.init) throw file.errorWithNode(declar, messages.get("noAssignmentsInForHead"));
-  }
-};

src/babel/transformation/transformers/validation/react.js

@@ -2,7 +2,7 @@ import * as messages from "../../../messages";
 import t from "../../../types";
 
 // check if the input Literal `source` is an alternate casing of "react"
-var check = function (source, file) {
+function check(source, file) {
   if (t.isLiteral(source)) {
     var name  = source.value;
     var lower = name.toLowerCase();
@@ -11,7 +11,7 @@ var check = function (source, file) {
       throw file.errorWithNode(source, messages.get("didYouMean", "react"));
     }
   }
-};
+}
 
 export function CallExpression(node, parent, scope, file) {
   if (t.isIdentifier(node.callee, { name: "require" }) && node.arguments.length === 1) {

src/babel/transformation/transformers/validation/setters.js

@@ -1,12 +0,0 @@
-import * as messages from "../../../messages";
-
-export function check(node) {
-  return node.kind === "set";
-}
-
-exports.MethodDefinition =
-exports.Property = function (node, parent, scope, file) {
-  if (node.kind === "set" && node.value.params.length !== 1) {
-    throw file.errorWithNode(node.value, messages.get("settersInvalidParamLength"));
-  }
-};

src/babel/transformation/transformers/validation/undeclared-variable-check.js

@@ -1,11 +1,10 @@
 import levenshtein from "leven";
 import * as messages from "../../../messages";
-import t from "../../../types";
 
 export var optional = true;
 
 export function Identifier(node, parent, scope, file) {
-  if (!t.isReferenced(node, parent)) return;
+  if (!this.isReferenced()) return;
   if (scope.hasBinding(node.name)) return;
 
   // get the closest declaration to offer as a suggestion

src/babel/traversal/context.js

@@ -2,14 +2,13 @@ import TraversalPath from "./path";
 import flatten from "lodash/array/flatten";
 import compact from "lodash/array/compact";
 
-export default class TraversalConext {
+export default class TraversalContext {
   constructor(scope, opts, state, parentPath) {
     this.shouldFlatten = false;
     this.parentPath    = parentPath;
-
-    this.scope = scope;
-    this.state = state;
-    this.opts  = opts;
+    this.scope         = scope;
+    this.state         = state;
+    this.opts          = opts;
   }
 
   flatten() {
@@ -17,7 +16,7 @@ export default class TraversalConext {
   }
 
   visitNode(node, obj, key) {
-    var iteration = new TraversalPath(this, node, obj, key);
+    var iteration = TraversalPath.get(this.parentPath, this, node, obj, key);
     return iteration.visit();
   }
 
@@ -43,7 +42,7 @@ export default class TraversalConext {
     if (this.shouldFlatten) {
       node[key] = flatten(node[key]);
 
-      if (key === "body") {
+      if (key === "body" || key === "expressions") {
         // we can safely compact this
         node[key] = compact(node[key]);
       }

src/babel/traversal/index.js

@@ -9,7 +9,7 @@ function traverse(parent, opts, scope, state) {
 
   if (!opts.noScope && !scope) {
     if (parent.type !== "Program" && parent.type !== "File") {
-      throw new Error("Must pass a scope unless traversing a Program/File got a " + parent.type + " node");
+      throw new Error(`Must pass a scope unless traversing a Program/File got a ${parent.type} node`);
     }
   }
 
@@ -42,13 +42,14 @@ traverse.node = function (node, opts, scope, state, parentPath) {
 function clearNode(node) {
   node._declarations = null;
   node.extendedRange = null;
-  node._scopeInfo = null;
-  node.tokens = null;
-  node.range = null;
-  node.start = null;
-  node.end = null;
-  node.loc = null;
-  node.raw = null;
+  node._scopeInfo    = null;
+  node._paths        = null;
+  node.tokens        = null;
+  node.range         = null;
+  node.start         = null;
+  node.end           = null;
+  node.loc           = null;
+  node.raw           = null;
 
   if (Array.isArray(node.trailingComments)) {
     clearComments(node.trailingComments);
@@ -57,11 +58,18 @@ function clearNode(node) {
   if (Array.isArray(node.leadingComments)) {
     clearComments(node.leadingComments);
   }
+
+  for (var key in node) {
+    var val = node[key];
+    if (Array.isArray(val)) {
+      delete val._paths;
+    }
+  }
 }
 
 var clearVisitor = {
   noScope: true,
-  enter: clearNode
+  exit: clearNode
 };
 
 function clearComments(comments) {
@@ -71,8 +79,8 @@ function clearComments(comments) {
 }
 
 traverse.removeProperties = function (tree) {
-  clearNode(tree);
   traverse(tree, clearVisitor);
+  clearNode(tree);
 
   return tree;
 };
@@ -84,7 +92,7 @@ traverse.explode = function (obj) {
     var aliases = t.FLIPPED_ALIAS_KEYS[type];
     if (aliases) {
       for (var i = 0; i < aliases.length; i++) {
-        obj[aliases[i]] = fns;
+        obj[aliases[i]] ||= fns;
       }
     }
   }

src/babel/traversal/path.js

@@ -4,23 +4,33 @@ import Scope from "./scope";
 import t from "../types";
 
 export default class TraversalPath {
-  constructor(context, parent, container, key) {
-    this.shouldRemove = false;
-    this.shouldSkip   = false;
-    this.shouldStop   = false;
-
-    this.parentPath = context.parentPath;
-    this.context    = context;
-    this.state      = this.context.state;
-    this.opts       = this.context.opts;
-
+  constructor(parent, container) {
     this.container = container;
-    this.key       = key;
+    this.parent    = parent;
+    this.data      = {};
+  }
 
-    this.parent = parent;
-    this.state  = context.state;
+  static get(parentPath, context, parent, container, key) {
+    var targetNode = container[key];
+    var paths = container._paths ||= [];
+    var path;
 
-    this.setScope();
+    for (var i = 0; i < paths.length; i++) {
+      var pathCheck = paths[i];
+      if (pathCheck.node === targetNode) {
+        path = pathCheck;
+        break;
+      }
+    }
+
+    if (!path) {
+      path = new TraversalPath(parent, container);
+      paths.push(path);
+    }
+
+    path.setContext(parentPath, context, key);
+
+    return path;
   }
 
   static getScope(node, parent, scope) {
@@ -34,10 +44,32 @@ export default class TraversalPath {
     return ourScope;
   }
 
+  setData(key, val) {
+    return this.data[key] = val;
+  }
+
+  getData(key) {
+    return this.data[key];
+  }
+
   setScope() {
     this.scope = TraversalPath.getScope(this.node, this.parent, this.context.scope);
   }
 
+  setContext(parentPath, context, key) {
+    this.shouldRemove = false;
+    this.shouldSkip   = false;
+    this.shouldStop   = false;
+
+    this.parentPath = parentPath;
+    this.context    = context;
+    this.state      = context.state;
+    this.opts       = context.opts;
+    this.key        = key;
+
+    this.setScope();
+  }
+
   remove() {
     this.shouldRemove = true;
     this.shouldSkip   = true;
@@ -114,14 +146,13 @@ export default class TraversalPath {
     }
   }
 
-  visit() {
-    var opts = this.opts;
-    var node = this.node;
+  isBlacklisted() {
+    var blacklist = this.opts.blacklist;
+    return blacklist && blacklist.indexOf(this.node.type) > -1;
+  }
 
-    // type is blacklisted
-    if (opts.blacklist && opts.blacklist.indexOf(node.type) > -1) {
-      return false;
-    }
+  visit() {
+    if (this.isBlacklisted()) return false;
 
     this.call("enter");
 
@@ -129,7 +160,8 @@ export default class TraversalPath {
       return this.shouldStop;
     }
 
-    node = this.node;
+    var node = this.node;
+    var opts = this.opts;
 
     if (Array.isArray(node)) {
       // traverse over these replacement nodes we purposely don't call exitNode
@@ -139,13 +171,38 @@ export default class TraversalPath {
       }
     } else {
       traverse.node(node, opts, this.scope, this.state, this);
+
       this.call("exit");
     }
 
     return this.shouldStop;
   }
 
-  isReferencedIdentifier() {
-    return t.isReferencedIdentifier(this.node);
+  get(key) {
+    return TraversalPath.get(this, this.context, this.node, this.node, key);
+  }
+
+  isReferencedIdentifier(opts) {
+    return t.isReferencedIdentifier(this.node, this.parent, opts);
+  }
+
+  isReferenced() {
+    return t.isReferenced(this.node, this.parent);
+  }
+
+  isScope() {
+    return t.isScope(this.node, this.parent);
+  }
+
+  getBindingIdentifiers() {
+    return t.getBindingIdentifiers(this.node);
   }
 }
+
+for (var i = 0; i < t.TYPES.length; i++) {
+  let type = t.TYPES[i];
+  let typeKey = `is${type}`;
+  TraversalPath.prototype[typeKey] = function (opts) {
+    return t[typeKey](this.node, opts);
+  };
+}