v1.12.26

CHANGELOG.md

@@ -1,3 +1,11 @@
+# 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.

doc/index.md

@@ -32,7 +32,7 @@ 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)
+ - [Async functions](features.md#async-functions)
  - [Arrow functions](features.md#arrow-functions)
  - [Classes](features.md#classes)
  - [Computed property names](features.md#computed-property-names)
@@ -40,7 +40,7 @@ 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)
+ - [Generators](features.md#generators)
  - [Generator comprehension](features.md#generator-comprehension)
  - [Let scoping](features.md#let-scoping)
  - [Modules](features.md#modules)

lib/6to5/file.js

@@ -147,7 +147,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 +196,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/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/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/array-comprehension.js

@@ -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

lib/6to5/transformation/transformers/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/destructuring.js

@@ -27,7 +27,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,7 +38,7 @@ 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
@@ -77,7 +77,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 +97,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 +125,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 +155,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/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/generators/visit.js

@@ -18,169 +18,172 @@ var runtimeAsyncMethod = runtimeProperty("async");
 var runtimeWrapMethod  = runtimeProperty("wrap");
 var runtimeMarkMethod  = runtimeProperty("mark");
 
-exports.transform = function transform(node) {
-  return types.visit(node, visitor);
+exports.transform = function transform(node, file) {
+  return types.visit(node, {
+    visitFunction: function (path) {
+      return visitor.call(this, path, file);
+    }
+  });
 };
 
-var visitor = types.PathVisitor.fromMethodsObject({
-  visitFunction: function (path) {
-    // Calling this.traverse(path) first makes for a post-order traversal.
-    this.traverse(path);
+var visitor = function (path, file) {
+  // Calling this.traverse(path) first makes for a post-order traversal.
+  this.traverse(path);
 
-    var node = path.value;
+  var node = path.value;
+  var scope; // we need to actually get the current scope
 
-    if (!node.generator && !node.async) {
+  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;
     }
 
-    node.generator = false;
+    // 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.
 
-    if (node.expression) {
-      // Transform expression lambdas into normal functions.
-      node.expression = false;
-      node.body = t.blockStatement([
-        t.returnStatement(node.body)
-      ]);
-    }
+    // Remove the FunctionDeclaration so that we can add it back as a
+    // FunctionExpression passed to runtime.mark.
+    path.replace();
 
-    if (node.async) {
-      awaitVisitor.visit(path.get("body"));
-    }
+    // 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 outerFnId = node.id || (
-      node.id = path.scope.parent.declareTemporary("callee$")
-    );
+    var varDecl = t.variableDeclaration("var", [
+      t.variableDeclarator(
+        node.id,
+        t.callExpression(runtimeMarkMethod, [node])
+      )
+    ]);
 
-    var innerFnId = t.identifier(node.id.name + "$");
-    var contextId = path.scope.declareTemporary("context$");
-    var vars = hoist(path);
+    // Copy any comments preceding the function declaration to the
+    // variable declaration, to avoid weird formatting consequences.
+    t.inheritsComments(varDecl, node);
+    t.removeComments(node);
 
-    var emitter = new Emitter(contextId);
-    emitter.explode(path.get("body"));
+    varDecl._blockHoist = true;
 
-    var outerBody = [];
+    var bodyPath = pp.get("body");
+    var bodyLen = bodyPath.value.length;
 
-    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) {
+    for (var i = 0; i < bodyLen; ++i) {
+      var firstStmtPath = bodyPath.get(i);
+      if (!shouldNotHoistAbove(firstStmtPath)) {
+        firstStmtPath.insertBefore(varDecl);
         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]);
     }
+
+    bodyPath.push(varDecl);
+  } else {
+    t.assertFunctionExpression(node);
+    return t.callExpression(runtimeMarkMethod, [node]);
   }
-});
+};
 
 function shouldNotHoistAbove(stmtPath) {
   var value = stmtPath.value;

lib/6to5/transformation/transformers/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/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

@@ -10,11 +10,11 @@ var FOR_KEYS = ["left", "init"];
  * This searches the current "scope" and collects all references/declarations
  * within.
  *
- * @param {Scope} [parent]
  * @param {Node} block
+ * @param {Scope} [parent]
  */
 
-function Scope(parent, block) {
+function Scope(block, parent) {
   this.parent = parent;
   this.block  = block;
 
@@ -23,10 +23,10 @@ function Scope(parent, block) {
 
 Scope.prototype.getReferences = function () {
   var block = this.block;
-  if (block._scope) return block._scope;
+  if (block._scopeReferences) return block._scopeReferences;
 
   var self       = this;
-  var references = block._scope = {};
+  var references = block._scopeReferences = {};
 
   var add = function (node) {
     self.add(node, references);

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) {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "6to5",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "1.12.24",
+  "version": "1.12.26",
   "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.20.3",
     "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"
+    "acorn-6to5": "0.9.1-3",
+    "estraverse": "1.8.0",
+    "private": "0.1.6"
   },
   "devDependencies": {
     "istanbul": "0.3.2",

test/fixtures/transformation/destructuring/assignment-expression-statement-only/actual.js

@@ -0,0 +1 @@
+console.log([x] = [1]);

test/fixtures/transformation/destructuring/assignment-expression-statement-only/options.json

@@ -0,0 +1,3 @@
+{
+  "throws": "AssignmentExpression destructuring outside of a ExpressionStatement is forbidden due to current 6to5 limitations"
+}

test/fixtures/transformation/react/display-name-variable-declaration/actual.js

@@ -1,5 +1,5 @@
 var Component = React.createClass({
   render: function () {
-  return null;
+    return null;
   }
 });

test/util.js

@@ -3,8 +3,6 @@ var util   = require("../lib/6to5/util");
 var t      = require("../lib/6to5/types");
 
 suite("util", function () {
-  test("duplicate mutator map");
-
   test("invalid template", function () {
     assert.throws(function () {
       util.template("invalid template");
@@ -45,6 +43,34 @@ suite("util", function () {
     assert.deepEqual(util.list("foo,bar"), ["foo", "bar"]);
   });
 
+  test("arrayify", function () {
+    assert.deepEqual(util.arrayify(undefined), []);
+    assert.deepEqual(util.arrayify(false), []);
+    assert.deepEqual(util.arrayify(null), []);
+    assert.deepEqual(util.arrayify(""), []);
+    assert.deepEqual(util.arrayify("foo"), ["foo"]);
+    assert.deepEqual(util.arrayify("foo,bar"), ["foo", "bar"]);
+    assert.deepEqual(util.arrayify(["foo", "bar"]), ["foo", "bar"]);
+
+    assert.throws(function () {
+      util.arrayify({});
+    }, /illegal type for arrayify/);
+  });
+
+  test("regexify", function () {
+    assert.deepEqual(util.regexify(undefined), /(?:)/);
+    assert.deepEqual(util.regexify(false), /(?:)/);
+    assert.deepEqual(util.regexify(null), /(?:)/);
+    assert.deepEqual(util.regexify(""), /(?:)/);
+    assert.deepEqual(util.regexify(["foo", "bar"]), /foo|bar/);
+    assert.deepEqual(util.regexify("foobar"), /foobar/);
+    assert.deepEqual(util.regexify(/foobar/), /foobar/);
+
+    assert.throws(function () {
+      util.regexify({});
+    }, /illegal type for regexify/);
+  });
+
   test("getIds");
 
   test("toStatement");