v1.13.4

Conflicts:
	lib/6to5/polyfill.js

.hound.yml

@@ -1,3 +0,0 @@
-java_script:
-  enabled: true
-  config_file: .jshintrc

CHANGELOG.md

@@ -1,3 +1,39 @@
+# 1.13.4
+
+ * Fix single spread element returning itself.
+
+# 1.13.3
+
+ * Upgrade `acorn-6to5`.
+ * Add experimental support for abstract references.
+
+# 1.13.2
+
+ * Optimise `Array.from` usage by adding a helper method.
+ * Upgrade `acorn-6to5`.
+
+# 1.13.1
+
+ * Fix constructor spread optimisation. Thanks [@zloirock](https://github.com/zloirock).
+
+# 1.13.0
+
+ * Put experimental ES7 features behind a flag `--experimental` and `experimental` option.
+ * Constructor spread performance increase. Thanks [@RReverser](https://github.com/RReverser).
+ * Use `self` instead of `window` in the optional 6to5 runtime. Thanks [@RReverser](https://github.com/RReverser).
+
+# 1.12.26
+
+ * Support computed property destructuring.
+
+# 1.12.25
+
+ * Update `acorn-6to5`, `ast-types`, `es6-shim`, `chokidar`, `estraverse` and `private`.
+
+# 1.12.24
+
+ * Collect references that haven't been declared in scope.
+
 # 1.12.23
 
  * Fix generator function export hoisting.

README.md

@@ -4,7 +4,7 @@
 
 <p align="center">
   <a href="https://travis-ci.org/6to5/6to5">
-    <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5.svg?branch=master&amp;style=flat&amp;label=travis">
+    <img alt="Travis Status" src="http://img.shields.io/travis/6to5/6to5/master.svg?style=flat&amp;label=travis">
   </a>
 
   <a href="https://ci.appveyor.com/project/sebmck/6to5">
@@ -26,4 +26,5 @@
 
 **6to5** turns ES6+ code into vanilla ES5, so you can use next generation features **today.**
 
-For more information view the [documentation](https://6to5.github.io).
+For more information view the [documentation](https://6to5.github.io). For
+support visit the [gitter room](https://gitter.im/6to5/6to5).

bin/6to5/index.js

@@ -11,6 +11,7 @@ commander.option("-s, --source-maps", "Save source map alongside the compiled co
 commander.option("-f, --filename [filename]", "Filename to use when reading from stdin - this will be used in source-maps, errors etc [stdin]", "stdin");
 commander.option("-w, --watch", "Recompile files on changes");
 commander.option("-r, --runtime", "Replace 6to5 declarations with references to a runtime");
+commander.option("-e, --experimental", "Enable experimental support for proposed ES7 features");
 
 commander.option("-m, --modules [modules]", "Module formatter type to use [common]", "common");
 commander.option("-w, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
@@ -87,11 +88,12 @@ if (errors.length) {
 
 exports.opts = {
   sourceMapName: commander.outFile,
+  amdModuleIds:  commander.amdModuleIds,
+  experimental:  commander.experimental,
   blacklist:     commander.blacklist,
   whitelist:     commander.whitelist,
   sourceMap:     commander.sourceMaps || commander.sourceMapsInline,
   comments:      !commander.removeComments,
-  amdModuleIds:   commander.amdModuleIds,
   runtime:       commander.runtime,
   modules:       commander.modules
 };

bin/_6to5-node

@@ -8,10 +8,11 @@ var util      = require("../lib/6to5/util");
 var vm        = require("vm");
 var _         = require("lodash");
 
-commander.option("-e, --eval [script]", "evaluate script");
-commander.option("-p, --print", "evaluate script and print result");
-commander.option("-i, --ignore [regex]", "ignore all files that match this regex when using the require hook");
-commander.option("-x, --extensions [extensions]", "list of extensions to hook into [.es6,.js]", util.list);
+commander.option("-e, --eval [script]", "Evaluate script");
+commander.option("-p, --print", "Evaluate script and print result");
+commander.option("-i, --ignore [regex]", "Ignore all files that match this regex when using the require hook");
+commander.option("-x, --extensions [extensions]", "List of extensions to hook into [.es6,.js]");
+commander.option("-r, --experimental", "Enable experimental support for proposed ES7 features");
 
 var pkg = require("../package.json");
 commander.version(pkg.version);
@@ -20,22 +21,20 @@ commander.parse(process.argv);
 
 //
 
-var registerOpts = {};
-
-if (commander.ignore) {
-  registerOpts.ignoreRegex = new RegExp(commander.ignore);
-}
-
-if (commander.extensions && commander.extensions.length) {
-  registerOpts.extensions = commander.extensions;
-}
-
-to5.register(registerOpts);
+to5.register({
+  experimental: commander.experimental,
+  extensions:   commander.extensions,
+  ignore:       commander.ignore
+});
 
 //
 
 var _eval = function (code, filename) {
-  code = to5.transform(code, { filename: filename, blacklist: ["useStrict"] }).code;
+  code = to5.transform(code, {
+    filename: filename,
+    blacklist: ["useStrict"],
+    experimental: commander.experimental
+  }).code;
   return vm.runInThisContext(code, filename);
 };
 

doc/caveats.md

@@ -1,9 +1,17 @@
 # Caveats
 
-## Async/Generators
+In order for certain features to work they require certain polyfills. You can
+satisfy **all** 6to5 feature requirements by using the included
+[polyfill](polyfill.md). You may alternatively selectively include what you need:
 
-The [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js)
-and an [ES6 polyfill](polyfill.md) are required in order for generators to work.
+| Feature                     | Requirements                                                                                                                        |
+| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| Abstract References         | `Symbol`                                                                                                                            |
+| Array destructuring         | `Array.isArray`, `Array.from`                                                                                                       |
+| Async functions, Generators | [experimental option](usage.md#experimental), [regenerator runtime](https://github.com/facebook/regenerator/blob/master/runtime.js) |
+| Comprehensions              | [experimental option](usage.md#experimental), `Array.isArray`, `Array.from`                                                         |
+| For..Of                     | `Symbol`, `prototype[Symbol.iterator]`                                                                                              |
+| Spread                      | `Array.isArray`, `Array.from`                                                                                                       |
 
 ## Classes
 
@@ -30,14 +38,3 @@ class Bar extends Foo {
   }
 }
 ```
-
-## For-of
-
-A polyfill is required for for-of functionality that implements `Symbol` and
-adds `prototype[Symbol.iterator]` behaviour to built-ins. Using the polyfills
-specified in [polyfill](polyfill.md) suffices.
-
-### Array destructuring / Spread
-
-An [ES6 polyfill](polyfill.md) is required for spread and array destructuring.
-More specifically a polyfill for `Array.from`.

doc/differences.md

@@ -62,13 +62,14 @@ better suited if you'd like a full ES6 environment with polyfills and all.
 | ---------------------------- | ---- | ------- | -------------- | ------ | ------ | ----------- |
 | Source maps                  | ✓    | ✓       | ✓              | ✓      |        | ✓           |
 | No compiler global pollution | ✓    |         | ✓              | ✓      |        | ✓           |
-| No runtime                   | ✓    |         | ✓              |        |        | ✓           |
+| Optional runtime             | ✓    |         | ✓              |        |        | ✓           |
 | Browser support              | ✓    | ✓       |                | ✓      |        |             |
 
 ### Language Support
 
 |                              | 6to5  | Traceur | es6-transpiler | esnext | es6now | jstransform |
 | ---------------------------- | ----- | ------- | -------------- | ------ | ------ | ----------- |
+| Abstract references          | ✓     |         |                |        |        |             |
 | Array comprehension          | ✓     | ✓       | ✓              |        |        |             |
 | Arrow functions              | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
 | Async functions              | ✓     | ✓       |                | ✓      |        |             |
@@ -89,10 +90,6 @@ better suited if you'd like a full ES6 environment with polyfills and all.
 | Template literals            | ✓     | ✓       | ✓              | ✓      | ✓      | ✓           |
 | Unicode regex                | ✓     | ✓       | ✓              |        |        |             |
 
-
-
-
-
 ### [Traceur](https://github.com/google/traceur-compiler)
 
 Traceur requires quite a bulky runtime (~75KB) and produces quite verbose code.

doc/features.md

@@ -1,6 +1,14 @@
 # Features
 
-## Array comprehension
+## Abstract references ([experimental](usage.md#experimental)) ([spec](https://github.com/zenparsing/es-abstract-refs))
+
+```javascript
+foo::bar;
+foo::bar = baz;
+delete foo::bar;
+```
+
+## Array comprehension ([experimental](usage.md#experimental))
 
 ```javascript
 var results = [for (c of customers) if (c.city == "Seattle") { name: c.name, age: c.age }]
@@ -31,7 +39,7 @@ var bob = {
 };
 ```
 
-## Async functions
+## Async functions ([experimental](usage.md#experimental)) ([spec](https://github.com/lukehoban/ecmascript-asyncawait))
 
 ```javascript
 async function chainAnimationsAsync(elem, animations) {
@@ -150,7 +158,7 @@ for (var n of fibonacci()) {
 }
 ```
 
-## Generator comprehension
+## Generator comprehension ([experimental](usage.md#experimental))
 
 ```javascript
 var nums = [1, 2, 3, 4, 5, 6];

doc/index.md

@@ -3,7 +3,7 @@
  - **Readable** - formatting is retained if possible so your generated code is as similar as possible.
  - **Extensible** - with a large range of [plugins](plugins.md) and **browser support**.
  - **Lossless** - **source map support** so you can debug your compiled code with ease.
- - **Compact** - maps directly to the equivalent ES5 with **no runtime**[\*](caveats.md#generators).
+ - **Compact** - maps directly to the equivalent ES5 with **no runtime**[\*](caveats.md).
 
 ## Installation
 
@@ -31,8 +31,9 @@ And it doesn't end here! To see all the ways you can use 6to5, check out the
 
 ## [Features](features.md)
 
- - [Array comprehension](features.md#array-comprehension)
- - [Async functions](features.md#async-functions) via [regenerator](https://github.com/facebook/regenerator)
+ - [Abstract references](features.md#abstract-references) ([experimental](usage.md#experimental))
+ - [Array comprehension](features.md#array-comprehension) ([experimental](usage.md#experimental))
+ - [Async functions](features.md#async-functions) ([experimental](usage.md#experimental))
  - [Arrow functions](features.md#arrow-functions)
  - [Classes](features.md#classes)
  - [Computed property names](features.md#computed-property-names)
@@ -40,8 +41,8 @@ And it doesn't end here! To see all the ways you can use 6to5, check out the
  - [Default parameters](features.md#default-parameters)
  - [Destructuring](features.md#destructuring)
  - [For-of](features.md#for-of)
- - [Generators](features.md#generators) via [regenerator](https://github.com/facebook/regenerator)
- - [Generator comprehension](features.md#generator-comprehension)
+ - [Generators](features.md#generators)
+ - [Generator comprehension](features.md#generator-comprehension) ([experimental](usage.md#experimental))
  - [Let scoping](features.md#let-scoping)
  - [Modules](features.md#modules)
  - [Numeric literals](features.md#numeric-literals)

doc/polyfill.md

@@ -5,13 +5,23 @@
 [es6-shim](https://github.com/paulmillr/es6-shim) and
 [es6-symbol](https://github.com/medikoo/es6-symbol) polyfills.
 
-## Node
+This will emulate a full ES6 environment. This polyfill is automatically loaded
+when using [6to5-node](usage.md#node).
+
+## Usage
+
+### Node
+
+You need to include the polyfill require at the top the **entry point** to your
+application.
 
 ```javascript
 require("6to5/polyfill");
 ```
 
-## Browser
+### Browser
 
 Available from the `browser-polyfill.js` file within the 6to5 directory of an
-npm release.
+npm release. This needs to be included **before** all your compiled 6to5 code.
+You can either prepend it to your compiled code or include it in a `<script>`
+before it.

doc/usage.md

@@ -135,7 +135,11 @@ to5.transformFile("filename.js", options, function (err, result) {
 
   // Output comments in generated output
   // Default: true
-  comments: false
+  comments: false,
+
+  // Enable support for experimental ES7 features
+  // Default: false
+  experimental: true
 }
 ```
 
@@ -181,3 +185,12 @@ require("6to5/register")({
   extensions: [".js", ".es6"]
 });
 ```
+
+## Experimental
+
+6to5 also has experimental support for ES7 proposals. You can enable this with
+the `experimental: true` option when using the [Node API](#node) or
+`--experimental` when using the [CLI](#cli).
+
+**WARNING:** These proposals are subject to change so use with
+**extreme caution**.

lib/6to5/file.js

@@ -19,21 +19,22 @@ function File(opts) {
 }
 
 File.declarations = ["extends", "class-props", "slice", "apply-constructor",
-                     "tagged-template-literal", "interop-require"];
+                     "tagged-template-literal", "interop-require", "to-array"];
 
 File.normaliseOptions = function (opts) {
   opts = _.cloneDeep(opts || {});
 
   _.defaults(opts, {
-    whitespace: true,
-    blacklist:  [],
-    whitelist:  [],
-    sourceMap:  false,
-    comments:   true,
-    filename:   "unknown",
-    modules:    "common",
-    runtime:    false,
-    code:       true
+    experimental: false,
+    whitespace:   true,
+    blacklist:    [],
+    whitelist:    [],
+    sourceMap:    false,
+    comments:     true,
+    filename:     "unknown",
+    modules:      "common",
+    runtime:      false,
+    code:         true
   });
 
   // normalise windows path separators to unix
@@ -69,6 +70,16 @@ File.normaliseOptions = function (opts) {
   return opts;
 };
 
+File.prototype.toArray = function (node) {
+  if (t.isArrayExpression(node)) {
+    return node;
+  } else if (t.isIdentifier(node) && node.name === "arguments") {
+    return t.callExpression(t.memberExpression(this.addDeclaration("slice"), t.identifier("call")), [node]);
+  } else {
+    return t.callExpression(this.addDeclaration("to-array"), [node]);
+  }
+};
+
 File.prototype.getModuleFormatter = function (type) {
   var ModuleFormatter = _.isFunction(type) ? type : transform.moduleFormatters[type];
 
@@ -147,7 +158,7 @@ File.prototype.parse = function (code) {
 
 File.prototype.transform = function (ast) {
   this.ast = ast;
-  this.scope = new Scope(null, ast.program);
+  this.scope = new Scope(ast.program);
 
   var self = this;
 
@@ -196,6 +207,10 @@ File.prototype.generateUid = function (name, scope) {
   return uid;
 };
 
+File.prototype.generateUidIdentifier = function (name, scope) {
+  return t.identifier(this.generateUid(name, scope));
+};
+
 File.prototype._generateUid = function (name) {
   var uids = this.uids;
   var i = uids[name] || 1;

lib/6to5/generation/generators/types.js

@@ -9,6 +9,12 @@ exports.SpreadElement = function (node, print) {
   print(node.argument);
 };
 
+exports.VirtualPropertyExpression = function (node, print) {
+  print(node.object);
+  this.push("::");
+  print(node.property);
+};
+
 exports.ObjectExpression =
 exports.ObjectPattern = function (node, print) {
   var props = node.properties;

lib/6to5/generation/node/index.js

@@ -24,15 +24,7 @@ function Node(node, parent) {
 }
 
 Node.prototype.isUserWhitespacable = function () {
-  var parent = this.parent;
-  var node = this.node;
-
-  if (t.isUserWhitespacable(node) ||
-      t.isSequenceExpression(parent)) {
-    return true;
-  }
-
-  return false;
+  return t.isUserWhitespacable(this.node);
 };
 
 Node.prototype.needsWhitespace = function (type) {

lib/6to5/polyfill.js

@@ -1,6 +1,37 @@
+/* jshint newcap: false */
+
+var ensureSymbol = function (key) {
+  Symbol[key] = Symbol[key] || Symbol();
+};
+
+var ensureProto = function (Constructor, key, val) {
+  var proto = Constructor.prototype;
+  proto[key] = proto[key] || val;
+};
+
+//
+
 if (typeof Symbol === "undefined") {
   require("es6-symbol/implement");
 }
 
 require("es6-shim");
-require("./transformation/transformers/generators/runtime");
+require("./transformation/transformers/es6-generators/runtime");
+
+// Abstract references
+
+ensureSymbol("referenceGet");
+ensureSymbol("referenceSet");
+ensureSymbol("referenceDelete");
+
+ensureProto(Function, Symbol.referenceGet, function () { return this; });
+
+ensureProto(Map, Symbol.referenceGet, Map.prototype.get);
+ensureProto(Map, Symbol.referenceSet, Map.prototype.set);
+ensureProto(Map, Symbol.referenceDelete, Map.prototype.delete);
+
+if (global.WeakMap) {
+  ensureProto(WeakMap, Symbol.referenceGet, WeakMap.prototype.get);
+  ensureProto(WeakMap, Symbol.referenceSet, WeakMap.prototype.set);
+  ensureProto(WeakMap, Symbol.referenceDelete, WeakMap.prototype.delete);
+}

lib/6to5/register.js

@@ -57,24 +57,25 @@ blacklistTest("unicodeRegex", function () { new RegExp("foo", "u"); });
 
 //
 
-var ignoreRegex = /node_modules/;
+var transformOpts = {};
+var ignoreRegex   = /node_modules/;
 var onlyRegex;
-var whitelist   = [];
-var exts        = {};
-var maps        = {};
-var old         = require.extensions[".js"];
+var whitelist     = [];
+var exts          = {};
+var maps          = {};
+var old           = require.extensions[".js"];
 
 var loader = function (m, filename) {
   if ((ignoreRegex && ignoreRegex.test(filename)) || (onlyRegex && !onlyRegex.test(filename))) {
     return old.apply(this, arguments);
   }
 
-  var result = to5.transformFileSync(filename, {
+  var result = to5.transformFileSync(filename, _.extend({
     whitelist: whitelist,
     blacklist: blacklist,
     sourceMap: true,
     modules:   "commonInterop"
-  });
+  }, transformOpts));
 
   maps[filename] = result.map;
 
@@ -107,6 +108,5 @@ module.exports = function (opts) {
 
   if (opts.extensions) hookExtensions(util.arrayify(opts.extensions));
 
-  if (opts.blacklist) blacklist = util.arrayify(opts.blacklist);
-  if (opts.whitelist) whitelist = util.arrayify(opts.whitelist);
+  _.extend(transformOpts, opts);
 };

lib/6to5/runtime.js

@@ -8,15 +8,13 @@ module.exports = function (namespace) {
   namespace = t.identifier(t.toIdentifier(namespace || "to5Runtime"));
 
   var body      = [];
-  var container = t.functionExpression(null, [], t.blockStatement(body));
-  var tree      = t.program([t.expressionStatement(t.callExpression(container, []))]);
-
-  body.push(util.template("self-global", true));
+  var container = t.functionExpression(null, [t.identifier("global")], t.blockStatement(body));
+  var tree      = t.program([t.expressionStatement(t.callExpression(container, [util.template("self-global")]))]);
 
   body.push(t.variableDeclaration("var", [
     t.variableDeclarator(
       namespace,
-      t.assignmentExpression("=", t.memberExpression(t.identifier("self"), namespace), t.objectExpression([]))
+      t.assignmentExpression("=", t.memberExpression(t.identifier("global"), namespace), t.objectExpression([]))
     )
   ]));
 

lib/6to5/templates/abstract-expression-call.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceGet](OBJECT).call(OBJECT)

lib/6to5/templates/abstract-expression-delete.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceDelete](OBJECT)

lib/6to5/templates/abstract-expression-get.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceGet](OBJECT)

lib/6to5/templates/abstract-expression-set.js

@@ -0,0 +1 @@
+PROPERTY[Symbol.referenceSet](OBJECT, VALUE)

lib/6to5/templates/apply-constructor.js

@@ -1,5 +1,5 @@
 (function (Constructor, args) {
-  var bindArgs = [null].concat(args);
-  var Factory = Constructor.bind.apply(Constructor, bindArgs);
-  return new Factory;
+  var instance = Object.create(Constructor.prototype);
+  var result = Constructor.apply(instance, args);
+  return result != null && (typeof result == "object" || typeof result == "function") ? result : instance;
 });

lib/6to5/templates/self-global.js

@@ -1 +1 @@
-var self = typeof global === "undefined" ? window : global;
+typeof global === "undefined" ? self : global

lib/6to5/templates/to-array.js

@@ -0,0 +1,3 @@
+(function (arr) {
+  return Array.isArray(arr) ? arr : Array.from(arr);
+});

lib/6to5/transformation/modules/amd.js

@@ -78,7 +78,7 @@ AMDFormatter.prototype._push = function (node) {
   if (ids[id]) {
     return ids[id];
   } else {
-    return this.ids[id] = t.identifier(this.file.generateUid(id));
+    return this.ids[id] = this.file.generateUidIdentifier(id);
   }
 };
 

lib/6to5/transformation/transform.js

@@ -28,30 +28,31 @@ transform.moduleFormatters = {
 };
 
 _.each({
-  modules:                   require("./transformers/modules"),
-  propertyNameShorthand:     require("./transformers/property-name-shorthand"),
-  arrayComprehension:        require("./transformers/array-comprehension"),
-  generatorComprehension:    require("./transformers/generator-comprehension"),
-  arrowFunctions:            require("./transformers/arrow-functions"),
-  classes:                   require("./transformers/classes"),
+  modules:                   require("./transformers/es6-modules"),
+  propertyNameShorthand:     require("./transformers/es6-property-name-shorthand"),
+  arrayComprehension:        require("./transformers/es7-array-comprehension"),
+  generatorComprehension:    require("./transformers/es7-generator-comprehension"),
+  arrowFunctions:            require("./transformers/es6-arrow-functions"),
+  classes:                   require("./transformers/es6-classes"),
 
   _propertyLiterals:         require("./transformers/_property-literals"),
-  computedPropertyNames:     require("./transformers/computed-property-names"),
+  computedPropertyNames:     require("./transformers/es6-computed-property-names"),
 
-  spread:                    require("./transformers/spread"),
-  templateLiterals:          require("./transformers/template-literals"),
-  propertyMethodAssignment:  require("./transformers/property-method-assignment"),
-  defaultParameters:         require("./transformers/default-parameters"),
-  restParameters:            require("./transformers/rest-parameters"),
-  destructuring:             require("./transformers/destructuring"),
-  forOf:                     require("./transformers/for-of"),
-  unicodeRegex:              require("./transformers/unicode-regex"),
+  spread:                    require("./transformers/es6-spread"),
+  templateLiterals:          require("./transformers/es6-template-literals"),
+  propertyMethodAssignment:  require("./transformers/es5-property-method-assignment"),
+  defaultParameters:         require("./transformers/es6-default-parameters"),
+  restParameters:            require("./transformers/es6-rest-parameters"),
+  destructuring:             require("./transformers/es6-destructuring"),
+  forOf:                     require("./transformers/es6-for-of"),
+  unicodeRegex:              require("./transformers/es6-unicode-regex"),
+  abstractReferences:        require("./transformers/es7-abstract-references"),
   react:                     require("./transformers/react"),
 
-  constants:                 require("./transformers/constants"),
-  letScoping:                require("./transformers/let-scoping"),
+  constants:                 require("./transformers/es6-constants"),
+  letScoping:                require("./transformers/es6-let-scoping"),
 
-  generators:                require("./transformers/generators"),
+  generators:                require("./transformers/es6-generators"),
 
   _blockHoist:               require("./transformers/_block-hoist"),
   _declarations:             require("./transformers/_declarations"),

lib/6to5/transformation/transformers/_alias-functions.js

@@ -6,11 +6,11 @@ var go = function (getBody, node, file, scope) {
   var thisId;
 
   var getArgumentsId = function () {
-    return argumentsId = argumentsId || t.identifier(file.generateUid("arguments", scope));
+    return argumentsId = argumentsId || file.generateUidIdentifier("arguments", scope);
   };
 
   var getThisId = function () {
-    return thisId = thisId || t.identifier(file.generateUid("this", scope));
+    return thisId = thisId || file.generateUidIdentifier("this", scope);
   };
 
   // traverse the function and find all alias functions so we can alias

lib/6to5/transformation/transformers/es6-classes.js

@@ -36,7 +36,7 @@ function Class(node, file, scope) {
   this.instanceMutatorMap = {};
   this.staticMutatorMap   = {};
   this.hasConstructor     = false;
-  this.className          = node.id || t.identifier(file.generateUid("class", scope));
+  this.className          = node.id || file.generateUidIdentifier("class", scope);
   this.superName          = node.superClass;
 }
 
@@ -58,7 +58,7 @@ Class.prototype.run = function () {
       superClassArgument = superClassCallee = getMemberExpressionObject(superName);
     } else if (!t.isIdentifier(superName)) {
       superClassArgument = superName;
-      superClassCallee   = superName = t.identifier(file.generateUid("ref", this.scope));
+      superClassCallee   = superName = file.generateUidIdentifier("ref", this.scope);
     }
   }
 

lib/6to5/transformation/transformers/es6-destructuring.js

@@ -1,6 +1,5 @@
-var util = require("../../util");
-var t    = require("../../types");
-var _    = require("lodash");
+var t = require("../../types");
+var _ = require("lodash");
 
 var buildVariableAssign = function (kind, id, init) {
   if (kind === false) {
@@ -27,7 +26,7 @@ var push = function (opts, nodes, elem, parentId) {
 var pushObjectPattern = function (opts, nodes, pattern, parentId) {
   _.each(pattern.properties, function (prop) {
     var pattern2   = prop.value;
-    var patternId2 = t.memberExpression(parentId, prop.key);
+    var patternId2 = t.memberExpression(parentId, prop.key, prop.computed);
 
     if (t.isPattern(pattern2)) {
       push(opts, nodes, pattern2, patternId2);
@@ -38,11 +37,9 @@ var pushObjectPattern = function (opts, nodes, pattern, parentId) {
 };
 
 var pushArrayPattern = function (opts, nodes, pattern, parentId) {
-  var _parentId = t.identifier(opts.file.generateUid("ref", opts.scope));
+  var _parentId = opts.file.generateUidIdentifier("ref", opts.scope);
   nodes.push(t.variableDeclaration("var", [
-    t.variableDeclarator(_parentId, util.template("array-from", {
-      VALUE: parentId
-    }))
+    t.variableDeclarator(_parentId, opts.file.toArray(parentId))
   ]));
   parentId = _parentId;
 
@@ -52,9 +49,7 @@ var pushArrayPattern = function (opts, nodes, pattern, parentId) {
     var newPatternId;
 
     if (t.isSpreadElement(elem)) {
-      newPatternId = util.template("array-from", {
-        VALUE: parentId
-      });
+      newPatternId = opts.file.toArray(parentId);
 
       if (+i > 0) {
         newPatternId = t.callExpression(t.memberExpression(newPatternId, t.identifier("slice")), [t.literal(i)]);
@@ -77,7 +72,7 @@ var pushPattern = function (opts) {
   var scope = opts.scope;
 
   if (!t.isMemberExpression(parentId) && !t.isIdentifier(parentId)) {
-    var key = t.identifier(file.generateUid("ref", scope));
+    var key = file.generateUidIdentifier("ref", scope);
 
     nodes.push(t.variableDeclaration("var", [
       t.variableDeclarator(key, parentId)
@@ -97,7 +92,7 @@ exports.ForOfStatement = function (node, parent, file, scope) {
   var pattern = declar.declarations[0].id;
   if (!t.isPattern(pattern)) return;
 
-  var key = t.identifier(file.generateUid("ref", scope));
+  var key = file.generateUidIdentifier("ref", scope);
   node.left = t.variableDeclaration(declar.kind, [
     t.variableDeclarator(key, null)
   ]);
@@ -125,7 +120,7 @@ exports.Function = function (node, parent, file, scope) {
     if (!t.isPattern(pattern)) return pattern;
 
     hasDestructuring = true;
-    var parentId = t.identifier(file.generateUid("ref", scope));
+    var parentId = file.generateUidIdentifier("ref", scope);
 
     pushPattern({
       kind:    "var",
@@ -155,7 +150,7 @@ exports.ExpressionStatement = function (node, parent, file, scope) {
 
   var nodes = [];
 
-  var ref = t.identifier(file.generateUid("ref", scope));
+  var ref = file.generateUidIdentifier("ref", scope);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(ref, expr.right)
   ]));

lib/6to5/transformation/transformers/es6-for-of.js

@@ -5,7 +5,7 @@ exports.ForOfStatement = function (node, parent, file, scope) {
   var left = node.left;
   var declar;
 
-  var stepKey   = t.identifier(file.generateUid("step", scope));
+  var stepKey   = file.generateUidIdentifier("step", scope);
   var stepValue = t.memberExpression(stepKey, t.identifier("value"));
 
   if (t.isIdentifier(left)) {
@@ -19,7 +19,7 @@ exports.ForOfStatement = function (node, parent, file, scope) {
   }
 
   var node2 = util.template("for-of", {
-    ITERATOR_KEY: file.generateUid("iterator", scope),
+    ITERATOR_KEY: file.generateUidIdentifier("iterator", scope),
     STEP_KEY:     stepKey,
     OBJECT:       node.right
   });

lib/6to5/transformation/transformers/es6-generators/visit.js

@@ -0,0 +1,221 @@
+/**
+ * Copyright (c) 2014, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * https://raw.githut.com/facebook/regenerator/master/LICENSE file. An
+ * additional grant of patent rights can be found in the PATENTS file in
+ * the same directory.
+ */
+
+var runtimeProperty = require("./util").runtimeProperty;
+var Emitter         = require("./emit").Emitter;
+var hoist           = require("./hoist").hoist;
+var types           = require("ast-types");
+var t               = require("../../../types");
+
+var runtimeAsyncMethod = runtimeProperty("async");
+var runtimeWrapMethod  = runtimeProperty("wrap");
+var runtimeMarkMethod  = runtimeProperty("mark");
+
+exports.transform = function transform(node, file) {
+  return types.visit(node, {
+    visitFunction: function (path) {
+      return visitor.call(this, path, file);
+    }
+  });
+};
+
+var visitor = function (path, file) {
+  // Calling this.traverse(path) first makes for a post-order traversal.
+  this.traverse(path);
+
+  var node = path.value;
+  var scope; // we need to actually get the current scope
+
+  if (!node.generator && !node.async) {
+    return;
+  }
+
+  node.generator = false;
+
+  if (node.expression) {
+    // Transform expression lambdas into normal functions.
+    node.expression = false;
+    node.body = t.blockStatement([
+      t.returnStatement(node.body)
+    ]);
+  }
+
+  if (node.async) {
+    awaitVisitor.visit(path.get("body"));
+  }
+
+  var outerFnId = node.id || (
+    node.id = file.generateUidIdentifier("callee", scope)
+  );
+
+  var innerFnId = t.identifier(node.id.name + "$");
+  var contextId = file.generateUidIdentifier("context$", scope);
+  var vars = hoist(path);
+
+  var emitter = new Emitter(contextId);
+  emitter.explode(path.get("body"));
+
+  var outerBody = [];
+
+  if (vars && vars.declarations.length > 0) {
+    outerBody.push(vars);
+  }
+
+  var wrapArgs = [
+    emitter.getContextFunction(innerFnId),
+    // Async functions don't care about the outer function because they
+    // don't need it to be marked and don't inherit from its .prototype.
+    node.async ? t.literal(null) : outerFnId,
+    t.thisExpression()
+  ];
+
+  var tryEntryList = emitter.getTryEntryList();
+  if (tryEntryList) {
+    wrapArgs.push(tryEntryList);
+  }
+
+  var wrapCall = t.callExpression(
+    node.async ? runtimeAsyncMethod : runtimeWrapMethod,
+    wrapArgs
+  );
+
+  outerBody.push(t.returnStatement(wrapCall));
+  node.body = t.blockStatement(outerBody);
+
+  if (node.async) {
+    node.async = false;
+    return;
+  }
+
+  if (t.isFunctionDeclaration(node)) {
+    var pp = path.parent;
+
+    while (pp && !(t.isBlockStatement(pp.value) || t.isProgram(pp.value))) {
+      pp = pp.parent;
+    }
+
+    if (!pp) {
+      return;
+    }
+
+    // Here we turn the FunctionDeclaration into a named
+    // FunctionExpression that will be assigned to a variable of the
+    // same name at the top of the enclosing block. This is important
+    // for a very subtle reason: named function expressions can refer to
+    // themselves by name without fear that the binding may change due
+    // to code executing outside the function, whereas function
+    // declarations are vulnerable to the following rebinding:
+    //
+    //   function f() { return f }
+    //   var g = f;
+    //   f = "asdf";
+    //   g(); // "asdf"
+    //
+    // One way to prevent the problem illustrated above is to transform
+    // the function declaration thus:
+    //
+    //   var f = function f() { return f };
+    //   var g = f;
+    //   f = "asdf";
+    //   g(); // f
+    //   g()()()()(); // f
+    //
+    // In the code below, we transform generator function declarations
+    // in the following way:
+    //
+    //   gen().next(); // { value: gen, done: true }
+    //   function *gen() {
+    //     return gen;
+    //   }
+    //
+    // becomes something like
+    //
+    //   var gen = runtime.mark(function *gen() {
+    //     return gen;
+    //   });
+    //   gen().next(); // { value: gen, done: true }
+    //
+    // which ensures that the generator body can always reliably refer
+    // to gen by name.
+
+    // Remove the FunctionDeclaration so that we can add it back as a
+    // FunctionExpression passed to runtime.mark.
+    path.replace();
+
+    // Change the type of the function to be an expression instead of a
+    // declaration. Note that all the other fields are the same.
+    node.type = "FunctionExpression";
+
+    var varDecl = t.variableDeclaration("var", [
+      t.variableDeclarator(
+        node.id,
+        t.callExpression(runtimeMarkMethod, [node])
+      )
+    ]);
+
+    // Copy any comments preceding the function declaration to the
+    // variable declaration, to avoid weird formatting consequences.
+    t.inheritsComments(varDecl, node);
+    t.removeComments(node);
+
+    varDecl._blockHoist = true;
+
+    var bodyPath = pp.get("body");
+    var bodyLen = bodyPath.value.length;
+
+    for (var i = 0; i < bodyLen; ++i) {
+      var firstStmtPath = bodyPath.get(i);
+      if (!shouldNotHoistAbove(firstStmtPath)) {
+        firstStmtPath.insertBefore(varDecl);
+        return;
+      }
+    }
+
+    bodyPath.push(varDecl);
+  } else {
+    t.assertFunctionExpression(node);
+    return t.callExpression(runtimeMarkMethod, [node]);
+  }
+};
+
+function shouldNotHoistAbove(stmtPath) {
+  var value = stmtPath.value;
+  t.assertStatement(value);
+
+  // If the first statement is a "use strict" declaration, make sure to
+  // insert hoisted declarations afterwards.
+  if (t.isExpressionStatement(value) &&
+      t.isLiteral(value.expression) &&
+      value.expression.value === "use strict") {
+    return true;
+  }
+
+  if (t.isVariableDeclaration(value)) {
+    for (var i = 0; i < value.declarations.length; ++i) {
+      var decl = value.declarations[i];
+      if (t.isCallExpression(decl.init) && types.astNodesAreEquivalent(decl.init.callee, runtimeMarkMethod)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+var awaitVisitor = types.PathVisitor.fromMethodsObject({
+  visitFunction: function () {
+    return false; // Don't descend into nested function scopes.
+  },
+
+  visitAwaitExpression: function (path) {
+    // Convert await expressions to yield expressions.
+    return t.yieldExpression(path.value.argument, false);
+  }
+});

lib/6to5/transformation/transformers/es6-let-scoping.js

@@ -129,7 +129,7 @@ LetScoping.prototype.run = function () {
 
   // build a call and a unique id that we can assign the return value to
   var call = t.callExpression(fn, params);
-  var ret  = t.identifier(this.file.generateUid("ret", this.scope));
+  var ret  = this.file.generateUidIdentifier("ret", this.scope);
 
   var hasYield = traverse.hasType(fn.body, "YieldExpression", t.FUNCTION_TYPES);
   if (hasYield) {
@@ -445,7 +445,7 @@ LetScoping.prototype.buildHas = function (ret, call) {
   if (has.hasBreak || has.hasContinue) {
     // ensure that the parent has a label as we're building a switch and we
     // need to be able to access it
-    var label = forParent.label = forParent.label || t.identifier(this.file.generateUid("loop", this.scope));
+    var label = forParent.label = forParent.label || this.file.generateUidIdentifier("loop", this.scope);
 
     if (has.hasBreak) {
       cases.push(t.switchCase(t.literal("break"), [t.breakStatement(label)]));

lib/6to5/transformation/transformers/es6-spread.js

@@ -1,15 +1,8 @@
-var util = require("../../util");
-var t    = require("../../types");
-var _    = require("lodash");
+var t = require("../../types");
+var _ = require("lodash");
 
-var getSpreadLiteral = function (spread) {
-  var literal = spread.argument;
-  if (!t.isArrayExpression(literal)) {
-    literal = util.template("array-from", {
-      VALUE: literal
-    });
-  }
-  return literal;
+var getSpreadLiteral = function (spread, file) {
+  return file.toArray(spread.argument);
 };
 
 var hasSpread = function (nodes) {
@@ -23,7 +16,7 @@ var hasSpread = function (nodes) {
   return has;
 };
 
-var build = function (props) {
+var build = function (props, file) {
   var nodes = [];
 
   var _props = [];
@@ -37,7 +30,7 @@ var build = function (props) {
   _.each(props, function (prop) {
     if (t.isSpreadElement(prop)) {
       push();
-      nodes.push(getSpreadLiteral(prop));
+      nodes.push(getSpreadLiteral(prop, file));
     } else {
       _props.push(prop);
     }
@@ -48,19 +41,22 @@ var build = function (props) {
   return nodes;
 };
 
-exports.ArrayExpression = function (node) {
+exports.ArrayExpression = function (node, parent, file) {
   var elements = node.elements;
   if (!hasSpread(elements)) return;
 
-  var nodes = build(elements);
+  var nodes = build(elements, file);
   var first = nodes.shift();
 
-  if (!nodes.length) return first;
+  if (!t.isArrayExpression(first)) {
+    nodes.unshift(first);
+    first = t.arrayExpression([]);
+  }
 
   return t.callExpression(t.memberExpression(first, t.identifier("concat")), nodes);
 };
 
-exports.CallExpression = function (node) {
+exports.CallExpression = function (node, parent, file) {
   var args = node.arguments;
   if (!hasSpread(args)) return;
 
@@ -68,7 +64,7 @@ exports.CallExpression = function (node) {
 
   node.arguments = [];
 
-  var nodes = build(args);
+  var nodes = build(args, file);
   var first = nodes.shift();
 
   if (nodes.length) {
@@ -100,7 +96,7 @@ exports.NewExpression = function (node, parent, file) {
   var args = node.arguments;
   if (!hasSpread(args)) return;
 
-  var nodes = build(args);
+  var nodes = build(args, file);
   var first = nodes.shift();
 
   if (nodes.length) {

lib/6to5/transformation/transformers/es7-abstract-references.js

@@ -0,0 +1,60 @@
+// https://github.com/zenparsing/es-abstract-refs
+
+var util = require("../../util");
+var t    = require("../../types");
+
+var container = function (parent, call, ret) {
+  if (t.isExpressionStatement(parent)) {
+    // we don't need to worry about return values
+    return call;
+  } else {
+    return t.sequenceExpression([call, ret]);
+  }
+};
+
+exports.AssignmentExpression = function (node, parent) {
+  var left = node.left;
+  if (!t.isVirtualPropertyExpression(left)) return;
+
+  var right = node.right;
+
+  var call = util.template("abstract-expression-set", {
+    PROPERTY: left.property,
+    OBJECT:   left.object,
+    VALUE:    right
+  });
+
+  return container(parent, call, right);
+};
+
+exports.UnaryExpression = function (node, parent) {
+  var arg = node.argument;
+  if (!t.isVirtualPropertyExpression(arg)) return;
+  if (node.operator !== "delete") return;
+
+  var call = util.template("abstract-expression-delete", {
+    PROPERTY: arg.property,
+    OBJECT:   arg.object
+  });
+
+  return container(parent, call, t.literal(true));
+};
+
+exports.CallExpression = function (node) {
+  var callee = node.callee;
+  if (!t.isVirtualPropertyExpression(callee)) return;
+
+  var call = util.template("abstract-expression-call", {
+    PROPERTY: callee.property,
+    OBJECT:   callee.object
+  });
+  call.arguments = call.arguments.concat(node.arguments);
+  return call;
+};
+
+exports.VirtualPropertyExpression = function (node) {
+  return util.template("abstract-expression-get", {
+    PROPERTY: node.property,
+    OBJECT:   node.object
+  });
+};

lib/6to5/transformation/transformers/es7-array-comprehension.js

@@ -2,7 +2,7 @@ var util = require("../../util");
 var t    = require("../../types");
 var _    = require("lodash");
 
-var singleArrayExpression = function (node) {
+var single = function (node, file) {
   var block = node.blocks[0];
 
   var templateName = "array-expression-comprehension-map";
@@ -11,7 +11,7 @@ var singleArrayExpression = function (node) {
   var result = util.template(templateName, {
     STATEMENT: node.body,
     FILTER:    node.filter,
-    ARRAY:     block.right,
+    ARRAY:     file.toArray(block.right),
     KEY:       block.left
   });
 
@@ -25,7 +25,7 @@ var singleArrayExpression = function (node) {
 };
 
 var multiple = function (node, file) {
-  var uid = file.generateUid("arr");
+  var uid = file.generateUidIdentifier("arr");
 
   var container = util.template("array-comprehension-container", {
     KEY: uid
@@ -73,8 +73,8 @@ exports._build = function (node, buildBody) {
 exports.ComprehensionExpression = function (node, parent, file) {
   if (node.generator) return;
 
-  if (node.blocks.length === 1 && t.isArrayExpression(node.blocks[0].right)) {
-    return singleArrayExpression(node);
+  if (node.blocks.length === 1) {
+    return single(node, file);
   } else {
     return multiple(node, file);
   }

lib/6to5/transformation/transformers/es7-generator-comprehension.js

@@ -1,4 +1,4 @@
-var arrayComprehension = require("./array-comprehension");
+var arrayComprehension = require("./es7-array-comprehension");
 var t                  = require("../../types");
 
 exports.ComprehensionExpression = function (node) {

lib/6to5/transformation/transformers/generators/visit.js

@@ -1,218 +0,0 @@
-/**
- * Copyright (c) 2014, Facebook, Inc.
- * All rights reserved.
- *
- * This source code is licensed under the BSD-style license found in the
- * https://raw.githut.com/facebook/regenerator/master/LICENSE file. An
- * additional grant of patent rights can be found in the PATENTS file in
- * the same directory.
- */
-
-var runtimeProperty = require("./util").runtimeProperty;
-var Emitter         = require("./emit").Emitter;
-var hoist           = require("./hoist").hoist;
-var types           = require("ast-types");
-var t               = require("../../../types");
-
-var runtimeAsyncMethod = runtimeProperty("async");
-var runtimeWrapMethod  = runtimeProperty("wrap");
-var runtimeMarkMethod  = runtimeProperty("mark");
-
-exports.transform = function transform(node) {
-  return types.visit(node, visitor);
-};
-
-var visitor = types.PathVisitor.fromMethodsObject({
-  visitFunction: function (path) {
-    // Calling this.traverse(path) first makes for a post-order traversal.
-    this.traverse(path);
-
-    var node = path.value;
-
-    if (!node.generator && !node.async) {
-      return;
-    }
-
-    node.generator = false;
-
-    if (node.expression) {
-      // Transform expression lambdas into normal functions.
-      node.expression = false;
-      node.body = t.blockStatement([
-        t.returnStatement(node.body)
-      ]);
-    }
-
-    if (node.async) {
-      awaitVisitor.visit(path.get("body"));
-    }
-
-    var outerFnId = node.id || (
-      node.id = path.scope.parent.declareTemporary("callee$")
-    );
-
-    var innerFnId = t.identifier(node.id.name + "$");
-    var contextId = path.scope.declareTemporary("context$");
-    var vars = hoist(path);
-
-    var emitter = new Emitter(contextId);
-    emitter.explode(path.get("body"));
-
-    var outerBody = [];
-
-    if (vars && vars.declarations.length > 0) {
-      outerBody.push(vars);
-    }
-
-    var wrapArgs = [
-      emitter.getContextFunction(innerFnId),
-      // Async functions don't care about the outer function because they
-      // don't need it to be marked and don't inherit from its .prototype.
-      node.async ? t.literal(null) : outerFnId,
-      t.thisExpression()
-    ];
-
-    var tryEntryList = emitter.getTryEntryList();
-    if (tryEntryList) {
-      wrapArgs.push(tryEntryList);
-    }
-
-    var wrapCall = t.callExpression(
-      node.async ? runtimeAsyncMethod : runtimeWrapMethod,
-      wrapArgs
-    );
-
-    outerBody.push(t.returnStatement(wrapCall));
-    node.body = t.blockStatement(outerBody);
-
-    if (node.async) {
-      node.async = false;
-      return;
-    }
-
-    if (t.isFunctionDeclaration(node)) {
-      var pp = path.parent;
-
-      while (pp && !(t.isBlockStatement(pp.value) || t.isProgram(pp.value))) {
-        pp = pp.parent;
-      }
-
-      if (!pp) {
-        return;
-      }
-
-      // Here we turn the FunctionDeclaration into a named
-      // FunctionExpression that will be assigned to a variable of the
-      // same name at the top of the enclosing block. This is important
-      // for a very subtle reason: named function expressions can refer to
-      // themselves by name without fear that the binding may change due
-      // to code executing outside the function, whereas function
-      // declarations are vulnerable to the following rebinding:
-      //
-      //   function f() { return f }
-      //   var g = f;
-      //   f = "asdf";
-      //   g(); // "asdf"
-      //
-      // One way to prevent the problem illustrated above is to transform
-      // the function declaration thus:
-      //
-      //   var f = function f() { return f };
-      //   var g = f;
-      //   f = "asdf";
-      //   g(); // f
-      //   g()()()()(); // f
-      //
-      // In the code below, we transform generator function declarations
-      // in the following way:
-      //
-      //   gen().next(); // { value: gen, done: true }
-      //   function *gen() {
-      //     return gen;
-      //   }
-      //
-      // becomes something like
-      //
-      //   var gen = runtime.mark(function *gen() {
-      //     return gen;
-      //   });
-      //   gen().next(); // { value: gen, done: true }
-      //
-      // which ensures that the generator body can always reliably refer
-      // to gen by name.
-
-      // Remove the FunctionDeclaration so that we can add it back as a
-      // FunctionExpression passed to runtime.mark.
-      path.replace();
-
-      // Change the type of the function to be an expression instead of a
-      // declaration. Note that all the other fields are the same.
-      node.type = "FunctionExpression";
-
-      var varDecl = t.variableDeclaration("var", [
-        t.variableDeclarator(
-          node.id,
-          t.callExpression(runtimeMarkMethod, [node])
-        )
-      ]);
-
-      // Copy any comments preceding the function declaration to the
-      // variable declaration, to avoid weird formatting consequences.
-      t.inheritsComments(varDecl, node);
-      t.removeComments(node);
-
-      varDecl._blockHoist = true;
-
-      var bodyPath = pp.get("body");
-      var bodyLen = bodyPath.value.length;
-
-      for (var i = 0; i < bodyLen; ++i) {
-        var firstStmtPath = bodyPath.get(i);
-        if (!shouldNotHoistAbove(firstStmtPath)) {
-          firstStmtPath.insertBefore(varDecl);
-          return;
-        }
-      }
-
-      bodyPath.push(varDecl);
-    } else {
-      t.assertFunctionExpression(node);
-      return t.callExpression(runtimeMarkMethod, [node]);
-    }
-  }
-});
-
-function shouldNotHoistAbove(stmtPath) {
-  var value = stmtPath.value;
-  t.assertStatement(value);
-
-  // If the first statement is a "use strict" declaration, make sure to
-  // insert hoisted declarations afterwards.
-  if (t.isExpressionStatement(value) &&
-      t.isLiteral(value.expression) &&
-      value.expression.value === "use strict") {
-    return true;
-  }
-
-  if (t.isVariableDeclaration(value)) {
-    for (var i = 0; i < value.declarations.length; ++i) {
-      var decl = value.declarations[i];
-      if (t.isCallExpression(decl.init) && types.astNodesAreEquivalent(decl.init.callee, runtimeMarkMethod)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-var awaitVisitor = types.PathVisitor.fromMethodsObject({
-  visitFunction: function () {
-    return false; // Don't descend into nested function scopes.
-  },
-
-  visitAwaitExpression: function (path) {
-    // Convert await expressions to yield expressions.
-    return t.yieldExpression(path.value.argument, false);
-  }
-});

lib/6to5/traverse/index.js

@@ -55,7 +55,7 @@ function traverse(parent, callbacks, opts) {
 
       //
       var opts2 = { scope: opts.scope, blacklist: opts.blacklist };
-      if (t.isScope(node)) opts2.scope = new Scope(opts.scope, node);
+      if (t.isScope(node)) opts2.scope = new Scope(node, opts.scope);
 
       // enter
       if (callbacks.enter) {
@@ -89,9 +89,10 @@ function traverse(parent, callbacks, opts) {
 
 traverse.removeProperties = function (tree) {
   var clear = function (node) {
+    delete node._scopeReferences;
     delete node.extendedRange;
-    delete node._scopeIds;
     delete node._parent;
+    delete node._scope;
     delete node.tokens;
     delete node.range;
     delete node.start;

lib/6to5/traverse/scope.js

@@ -6,25 +6,30 @@ var _        = require("lodash");
 
 var FOR_KEYS = ["left", "init"];
 
-function Scope(parent, block) {
+/**
+ * This searches the current "scope" and collects all references/declarations
+ * within.
+ *
+ * @param {Node} block
+ * @param {Scope} [parent]
+ */
+
+function Scope(block, parent) {
   this.parent = parent;
   this.block  = block;
 
-  this.info         = this.getInfo();
-  this.declarations = this.info.declarations;
+  this.references = this.getReferences();
 }
 
-Scope.prototype.getInfo = function () {
+Scope.prototype.getReferences = function () {
   var block = this.block;
-  if (block._scope) return block._scope;
+  if (block._scopeReferences) return block._scopeReferences;
 
-  var self = this;
-  var info = block._scope = {
-    declarations: {}
-  };
+  var self       = this;
+  var references = block._scopeReferences = {};
 
   var add = function (node) {
-    self.addDeclaration(node, info.declarations);
+    self.add(node, references);
   };
 
   // ForStatement - left, init
@@ -56,7 +61,7 @@ Scope.prototype.getInfo = function () {
   // Program, Function - var variables
 
   if (t.isProgram(block) || t.isFunction(block)) {
-    traverse(block, function (node) {
+    traverse(block, function (node, parent, scope) {
       if (t.isFor(node)) {
         _.each(FOR_KEYS, function (key) {
           var declar = node[key];
@@ -68,12 +73,16 @@ Scope.prototype.getInfo = function () {
       // declared within are accessible
       if (t.isFunction(node)) return false;
 
+      if (t.isIdentifier(node) && t.isReferenced(node, parent) && !scope.has(node.name)) {
+        add(node);
+      }
+
       // we've ran into a declaration!
       // we'll let the BlockStatement scope deal with `let` declarations
       if (t.isDeclaration(node) && !t.isLet(node)) {
         add(node);
       }
-    });
+    }, { scope: this });
   }
 
   // Function - params, rest
@@ -85,12 +94,12 @@ Scope.prototype.getInfo = function () {
     });
   }
 
-  return info;
+  return references;
 };
 
-Scope.prototype.addDeclaration = function (node, declarations) {
+Scope.prototype.add = function (node, references) {
   if (!node) return;
-  _.merge(declarations || this.declarations, t.getIds(node, true));
+  _.merge(references || this.references, t.getIds(node, true));
 };
 
 Scope.prototype.get = function (id) {
@@ -98,7 +107,7 @@ Scope.prototype.get = function (id) {
 };
 
 Scope.prototype.getOwn = function (id) {
-  return _.has(this.declarations, id) && this.declarations[id];
+  return _.has(this.references, id) && this.references[id];
 };
 
 Scope.prototype.parentGet = function (id) {

lib/6to5/types/visitor-keys.json

@@ -1,76 +1,77 @@
 {
-  "ArrayExpression":          ["elements"],
-  "ArrayPattern":             ["elements"],
-  "ArrowFunctionExpression":  ["params", "defaults", "rest", "body"],
-  "AssignmentExpression":     ["left", "right"],
-  "AwaitExpression":          ["argument"],
-  "BinaryExpression":         ["left", "right"],
-  "BlockStatement":           ["body"],
-  "BreakStatement":           ["label"],
-  "CallExpression":           ["callee", "arguments"],
-  "CatchClause":              ["param", "body"],
-  "ClassBody":                ["body"],
-  "ClassDeclaration":         ["id", "body", "superClass"],
-  "ClassExpression":          ["id", "body", "superClass"],
-  "ComprehensionBlock":       ["left", "right", "body"],
-  "ComprehensionExpression":  ["filter", "blocks", "body"],
-  "ConditionalExpression":    ["test", "consequent", "alternate"],
-  "ContinueStatement":        ["label"],
-  "DebuggerStatement":        [],
-  "DoWhileStatement":         ["body", "test"],
-  "EmptyStatement":           [],
-  "ExportBatchSpecifier":     [],
-  "ExportDeclaration":        ["declaration", "specifiers", "source"],
-  "ExportSpecifier":          ["id", "name"],
-  "ExpressionStatement":      ["expression"],
-  "File":                     ["program"],
-  "ForInStatement":           ["left", "right", "body"],
-  "ForOfStatement":           ["left", "right", "body"],
-  "ForStatement":             ["init", "test", "update", "body"],
-  "FunctionDeclaration":      ["id", "params", "defaults", "rest", "body"],
-  "FunctionExpression":       ["id", "params", "defaults", "rest", "body"],
-  "Identifier":               [],
-  "IfStatement":              ["test", "consequent", "alternate"],
-  "ImportBatchSpecifier":     ["id"],
-  "ImportDeclaration":        ["specifiers", "source"],
-  "ImportSpecifier":          ["id", "name"],
-  "LabeledStatement":         ["label", "body"],
-  "Literal":                  [],
-  "LogicalExpression":        ["left", "right"],
-  "MemberExpression":         ["object", "property"],
-  "MethodDefinition":         ["key", "value"],
-  "NewExpression":            ["callee", "arguments"],
-  "ObjectExpression":         ["properties"],
-  "ObjectPattern":            ["properties"],
-  "ParenthesizedExpression":  ["expression"],
-  "Program":                  ["body"],
-  "Property":                 ["key", "value"],
-  "ReturnStatement":          ["argument"],
-  "SequenceExpression":       ["expressions"],
-  "SpreadElement":            ["argument"],
-  "SwitchCase":               ["test", "consequent"],
-  "SwitchStatement":          ["discriminant", "cases"],
-  "TaggedTemplateExpression": ["tag", "quasi"],
-  "TemplateElement":          [],
-  "TemplateLiteral":          ["quasis", "expressions"],
-  "ThisExpression":           [],
-  "ThrowStatement":           ["argument"],
-  "TryStatement":             ["block", "handlers", "handler", "guardedHandlers", "finalizer"],
-  "UnaryExpression":          ["argument"],
-  "UpdateExpression":         ["argument"],
-  "VariableDeclaration":      ["declarations"],
-  "VariableDeclarator":       ["id", "init"],
-  "WhileStatement":           ["test", "body"],
-  "WithStatement":            ["object", "body"],
-  "XJSAttribute":             ["name", "value"],
-  "XJSClosingElement":        ["name"],
-  "XJSElement":               ["openingElement", "closingElement", "children"],
-  "XJSEmptyExpression":       [],
-  "XJSExpressionContainer":   ["expression"],
-  "XJSIdentifier":            [],
-  "XJSMemberExpression":      ["object", "property"],
-  "XJSNamespacedName":        ["namespace", "name"],
-  "XJSOpeningElement":        ["name", "attributes"],
-  "XJSSpreadAttribute":       ["argument"],
-  "YieldExpression":          ["argument"]
+  "ArrayExpression":           ["elements"],
+  "ArrayPattern":              ["elements"],
+  "ArrowFunctionExpression":   ["params", "defaults", "rest", "body"],
+  "AssignmentExpression":      ["left", "right"],
+  "AwaitExpression":           ["argument"],
+  "BinaryExpression":          ["left", "right"],
+  "BlockStatement":            ["body"],
+  "BreakStatement":            ["label"],
+  "CallExpression":            ["callee", "arguments"],
+  "CatchClause":               ["param", "body"],
+  "ClassBody":                 ["body"],
+  "ClassDeclaration":          ["id", "body", "superClass"],
+  "ClassExpression":           ["id", "body", "superClass"],
+  "ComprehensionBlock":        ["left", "right", "body"],
+  "ComprehensionExpression":   ["filter", "blocks", "body"],
+  "ConditionalExpression":     ["test", "consequent", "alternate"],
+  "ContinueStatement":         ["label"],
+  "DebuggerStatement":         [],
+  "DoWhileStatement":          ["body", "test"],
+  "EmptyStatement":            [],
+  "ExportBatchSpecifier":      [],
+  "ExportDeclaration":         ["declaration", "specifiers", "source"],
+  "ExportSpecifier":           ["id", "name"],
+  "ExpressionStatement":       ["expression"],
+  "File":                      ["program"],
+  "ForInStatement":            ["left", "right", "body"],
+  "ForOfStatement":            ["left", "right", "body"],
+  "ForStatement":              ["init", "test", "update", "body"],
+  "FunctionDeclaration":       ["id", "params", "defaults", "rest", "body"],
+  "FunctionExpression":        ["id", "params", "defaults", "rest", "body"],
+  "Identifier":                [],
+  "IfStatement":               ["test", "consequent", "alternate"],
+  "ImportBatchSpecifier":      ["id"],
+  "ImportDeclaration":         ["specifiers", "source"],
+  "ImportSpecifier":           ["id", "name"],
+  "LabeledStatement":          ["label", "body"],
+  "Literal":                   [],
+  "LogicalExpression":         ["left", "right"],
+  "MemberExpression":          ["object", "property"],
+  "MethodDefinition":          ["key", "value"],
+  "NewExpression":             ["callee", "arguments"],
+  "ObjectExpression":          ["properties"],
+  "ObjectPattern":             ["properties"],
+  "ParenthesizedExpression":   ["expression"],
+  "Program":                   ["body"],
+  "Property":                  ["key", "value"],
+  "ReturnStatement":           ["argument"],
+  "SequenceExpression":        ["expressions"],
+  "SpreadElement":             ["argument"],
+  "SwitchCase":                ["test", "consequent"],
+  "SwitchStatement":           ["discriminant", "cases"],
+  "TaggedTemplateExpression":  ["tag", "quasi"],
+  "TemplateElement":           [],
+  "TemplateLiteral":           ["quasis", "expressions"],
+  "ThisExpression":            [],
+  "ThrowStatement":            ["argument"],
+  "TryStatement":              ["block", "handlers", "handler", "guardedHandlers", "finalizer"],
+  "UnaryExpression":           ["argument"],
+  "UpdateExpression":          ["argument"],
+  "VariableDeclaration":       ["declarations"],
+  "VariableDeclarator":        ["id", "init"],
+  "VirtualPropertyExpression": ["left", "right"],
+  "WhileStatement":            ["test", "body"],
+  "WithStatement":             ["object", "body"],
+  "XJSAttribute":              ["name", "value"],
+  "XJSClosingElement":         ["name"],
+  "XJSElement":                ["openingElement", "closingElement", "children"],
+  "XJSEmptyExpression":        [],
+  "XJSExpressionContainer":    ["expression"],
+  "XJSIdentifier":             [],
+  "XJSMemberExpression":       ["object", "property"],
+  "XJSNamespacedName":         ["namespace", "name"],
+  "XJSOpeningElement":         ["name", "attributes"],
+  "XJSSpreadAttribute":        ["argument"],
+  "YieldExpression":           ["argument"]
 }

lib/6to5/util.js

@@ -65,7 +65,7 @@ exports.getUid = function (parent, file) {
 
   if (t.isIdentifier(node)) id = node.name;
 
-  return t.identifier(file.generateUid(id));
+  return file.generateUidIdentifier(id);
 };
 
 exports.isAbsolute = function (loc) {
@@ -218,7 +218,7 @@ exports.parse = function (opts, code, callback) {
     var ast = acorn.parse(code, {
       allowReturnOutsideFunction: true,
       preserveParens:             true,
-      ecmaVersion:                Infinity,
+      ecmaVersion:                opts.experimental ? 7 : 6,
       strictMode:                 true,
       onComment:                  comments,
       locations:                  true,

package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "1.12.23",
+  "version": "1.13.4",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://github.com/6to5/6to5",
   "repository": {
@@ -35,21 +35,21 @@
     "test": "make test"
   },
   "dependencies": {
-    "ast-types": "~0.6.0",
+    "ast-types": "0.6.5",
     "commander": "2.5.0",
     "fs-readdir-recursive": "0.1.0",
     "lodash": "2.4.1",
     "mkdirp": "0.5.0",
-    "es6-shim": "0.20.2",
+    "es6-shim": "0.21.0",
     "es6-symbol": "0.1.1",
     "regexpu": "0.3.0",
     "source-map": "0.1.40",
-    "chokidar": "0.11.0",
+    "chokidar": "0.11.1",
     "source-map-support": "0.2.8",
-    "esutils": "1.1.4",
-    "acorn-6to5": "0.9.1-2",
-    "estraverse": "^1.7.0",
-    "private": "^0.1.6"
+    "esutils": "1.1.6",
+    "acorn-6to5": "0.9.1-5",
+    "estraverse": "1.8.0",
+    "private": "0.1.6"
   },
   "devDependencies": {
     "istanbul": "0.3.2",

test/fixtures/generation/types/SequenceExpression/expected.js

@@ -1,4 +1,3 @@
 foo, bar;
 
-foo,
-bar;
+foo, bar;

test/fixtures/transformation/async/options.json

@@ -1,3 +0,0 @@
-{
-  "asyncExec": true
-}

test/fixtures/transformation/destructuring/array/expected.js

@@ -1,14 +0,0 @@
-"use strict";
-
-var _ref = ["hello", [", ", "junk"], ["world"]];
-
-var _ref2 = Array.from(_ref);
-
-var a = _ref2[0];
-var _ref3 = Array.from(_ref2[1]);
-
-var b = _ref3[0];
-var _ref4 = Array.from(_ref2[2]);
-
-var c = _ref4[0];
-var d = _ref2[3];

test/fixtures/transformation/destructuring/assignment-statement/expected.js

@@ -1,8 +0,0 @@
-"use strict";
-
-var _ref = f();
-
-var _ref2 = Array.from(_ref);
-
-a = _ref2[0];
-b = _ref2[1];

test/fixtures/transformation/destructuring/empty/expected.js

@@ -1,14 +0,0 @@
-"use strict";
-
-var _ref = ["foo", "hello", [", ", "junk"], ["world"]];
-
-var _ref2 = Array.from(_ref);
-
-var a = _ref2[1];
-var _ref3 = Array.from(_ref2[2]);
-
-var b = _ref3[0];
-var _ref4 = Array.from(_ref2[3]);
-
-var c = _ref4[0];
-var d = _ref2[4];

test/fixtures/transformation/destructuring/member-expression/expected.js

@@ -1,8 +0,0 @@
-"use strict";
-
-var _ref = [1, 2];
-
-var _ref2 = Array.from(_ref);
-
-this.foo = _ref2[0];
-this.bar = _ref2[1];

test/fixtures/transformation/destructuring/mixed/expected.js

@@ -1,10 +0,0 @@
-"use strict";
-
-var _ref = Array.from(rect.topLeft);
-
-var x1 = _ref[0];
-var y1 = _ref[1];
-var _ref2 = Array.from(rect.bottomRight);
-
-var x2 = _ref2[0];
-var y2 = _ref2[1];