@babel/traverse 7.0.0-beta.5 → 7.0.0-beta.53

package/lib/path/modification.js

@@ -1,6 +1,8 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.insertBefore = insertBefore;
 exports._containerInsert = _containerInsert;
 exports._containerInsertBefore = _containerInsertBefore;
@@ -18,29 +20,38 @@ var _hoister = _interopRequireDefault(require("./lib/hoister"));
 
 var _index = _interopRequireDefault(require("./index"));
 
-var t = _interopRequireWildcard(require("@babel/types"));
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+  t = function () {
+    return data;
+  };
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+  return data;
+}
 
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function insertBefore(nodes) {
   this._assertUnremoved();
 
   nodes = this._verifyNodeList(nodes);
+  const {
+    parentPath
+  } = this;
 
-  if (this.parentPath.isExpressionStatement() || this.parentPath.isLabeledStatement()) {
-    return this.parentPath.insertBefore(nodes);
-  } else if (this.isNodeType("Expression") && this.listKey !== "params" && this.listKey !== "arguments" || this.parentPath.isForStatement() && this.key === "init") {
+  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+    return parentPath.insertBefore(nodes);
+  } else if (this.isNodeType("Expression") && this.listKey !== "params" && this.listKey !== "arguments" || parentPath.isForStatement() && this.key === "init") {
     if (this.node) nodes.push(this.node);
     return this.replaceExpressionWithStatements(nodes);
   } else if (Array.isArray(this.container)) {
     return this._containerInsertBefore(nodes);
   } else if (this.isStatementOrBlock()) {
-    var shouldInsertCurrentNode = this.node && (!this.isExpressionStatement() || this.node.expression != null);
-    this.replaceWith(t.blockStatement(shouldInsertCurrentNode ? [this.node] : []));
+    const shouldInsertCurrentNode = this.node && (!this.isExpressionStatement() || this.node.expression != null);
+    this.replaceWith(t().blockStatement(shouldInsertCurrentNode ? [this.node] : []));
     return this.unshiftContainer("body", nodes);
   } else {
     throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
@@ -48,16 +59,13 @@ function insertBefore(nodes) {
 }
 
 function _containerInsert(from, nodes) {
-  var _container;
-
   this.updateSiblingKeys(from, nodes.length);
-  var paths = [];
-
-  (_container = this.container).splice.apply(_container, [from, 0].concat(nodes));
+  const paths = [];
+  this.container.splice(from, 0, ...nodes);
 
-  for (var i = 0; i < nodes.length; i++) {
-    var to = from + i;
-    var path = this.getSibling("" + to);
+  for (let i = 0; i < nodes.length; i++) {
+    const to = from + i;
+    const path = this.getSibling(to);
     paths.push(path);
 
     if (this.context && this.context.queue) {
@@ -65,30 +73,14 @@ function _containerInsert(from, nodes) {
     }
   }
 
-  var contexts = this._getQueueContexts();
-
-  for (var _i = 0; _i < paths.length; _i++) {
-    var _path = paths[_i];
-
-    _path.setScope();
+  const contexts = this._getQueueContexts();
 
-    _path.debug("Inserted.");
+  for (const path of paths) {
+    path.setScope();
+    path.debug("Inserted.");
 
-    for (var _iterator = contexts, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-      var _ref;
-
-      if (_isArray) {
-        if (_i2 >= _iterator.length) break;
-        _ref = _iterator[_i2++];
-      } else {
-        _i2 = _iterator.next();
-        if (_i2.done) break;
-        _ref = _i2.value;
-      }
-
-      var _context = _ref;
-
-      _context.maybeQueue(_path, true);
+    for (const context of contexts) {
+      context.maybeQueue(path, true);
     }
   }
 
@@ -107,22 +99,36 @@ function insertAfter(nodes) {
   this._assertUnremoved();
 
   nodes = this._verifyNodeList(nodes);
+  const {
+    parentPath
+  } = this;
 
-  if (this.parentPath.isExpressionStatement() || this.parentPath.isLabeledStatement()) {
-    return this.parentPath.insertAfter(nodes);
-  } else if (this.isNodeType("Expression") || this.parentPath.isForStatement() && this.key === "init") {
+  if (parentPath.isExpressionStatement() || parentPath.isLabeledStatement() || parentPath.isExportNamedDeclaration() || parentPath.isExportDefaultDeclaration() && this.isDeclaration()) {
+    return parentPath.insertAfter(nodes);
+  } else if (this.isNodeType("Expression") || parentPath.isForStatement() && this.key === "init") {
     if (this.node) {
-      var temp = this.scope.generateDeclaredUidIdentifier();
-      nodes.unshift(t.expressionStatement(t.assignmentExpression("=", temp, this.node)));
-      nodes.push(t.expressionStatement(temp));
+      let {
+        scope
+      } = this;
+
+      if (parentPath.isMethod({
+        computed: true,
+        key: this.node
+      })) {
+        scope = scope.parent;
+      }
+
+      const temp = scope.generateDeclaredUidIdentifier();
+      nodes.unshift(t().expressionStatement(t().assignmentExpression("=", t().cloneNode(temp), this.node)));
+      nodes.push(t().expressionStatement(t().cloneNode(temp)));
     }
 
     return this.replaceExpressionWithStatements(nodes);
   } else if (Array.isArray(this.container)) {
     return this._containerInsertAfter(nodes);
   } else if (this.isStatementOrBlock()) {
-    var shouldInsertCurrentNode = this.node && (!this.isExpressionStatement() || this.node.expression != null);
-    this.replaceWith(t.blockStatement(shouldInsertCurrentNode ? [this.node] : []));
+    const shouldInsertCurrentNode = this.node && (!this.isExpressionStatement() || this.node.expression != null);
+    this.replaceWith(t().blockStatement(shouldInsertCurrentNode ? [this.node] : []));
     return this.pushContainer("body", nodes);
   } else {
     throw new Error("We don't know what to do with this node type. " + "We were previously a Statement but we can't fit in here?");
@@ -132,10 +138,10 @@ function insertAfter(nodes) {
 function updateSiblingKeys(fromIndex, incrementBy) {
   if (!this.parent) return;
 
-  var paths = _cache.path.get(this.parent);
+  const paths = _cache.path.get(this.parent);
 
-  for (var i = 0; i < paths.length; i++) {
-    var path = paths[i];
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
 
     if (path.key >= fromIndex) {
       path.key += incrementBy;
@@ -152,13 +158,13 @@ function _verifyNodeList(nodes) {
     nodes = [nodes];
   }
 
-  for (var i = 0; i < nodes.length; i++) {
-    var node = nodes[i];
-    var msg = void 0;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    let msg;
 
     if (!node) {
       msg = "has falsy node";
-    } else if (_typeof(node) !== "object") {
+    } else if (typeof node !== "object") {
       msg = "contains a non-object node";
     } else if (!node.type) {
       msg = "without a type";
@@ -167,8 +173,8 @@ function _verifyNodeList(nodes) {
     }
 
     if (msg) {
-      var type = Array.isArray(node) ? "array" : _typeof(node);
-      throw new Error("Node list " + msg + " with the index of " + i + " and type of " + type);
+      const type = Array.isArray(node) ? "array" : typeof node;
+      throw new Error(`Node list ${msg} with the index of ${i} and type of ${type}`);
     }
   }
 
@@ -180,11 +186,11 @@ function unshiftContainer(listKey, nodes) {
 
   nodes = this._verifyNodeList(nodes);
 
-  var path = _index.default.get({
+  const path = _index.default.get({
     parentPath: this,
     parent: this.node,
     container: this.node[listKey],
-    listKey: listKey,
+    listKey,
     key: 0
   });
 
@@ -195,24 +201,20 @@ function pushContainer(listKey, nodes) {
   this._assertUnremoved();
 
   nodes = this._verifyNodeList(nodes);
-  var container = this.node[listKey];
+  const container = this.node[listKey];
 
-  var path = _index.default.get({
+  const path = _index.default.get({
     parentPath: this,
     parent: this.node,
     container: container,
-    listKey: listKey,
+    listKey,
     key: container.length
   });
 
   return path.replaceWithMultiple(nodes);
 }
 
-function hoist(scope) {
-  if (scope === void 0) {
-    scope = this.scope;
-  }
-
-  var hoister = new _hoister.default(this, scope);
+function hoist(scope = this.scope) {
+  const hoister = new _hoister.default(this, scope);
   return hoister.run();
 }

package/lib/path/removal.js

@@ -1,7 +1,10 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.remove = remove;
+exports._removeFromScope = _removeFromScope;
 exports._callRemovalHooks = _callRemovalHooks;
 exports._remove = _remove;
 exports._markRemoved = _markRemoved;
@@ -14,6 +17,8 @@ function remove() {
 
   this.resync();
 
+  this._removeFromScope();
+
   if (this._callRemovalHooks()) {
     this._markRemoved();
 
@@ -27,11 +32,13 @@ function remove() {
   this._markRemoved();
 }
 
-function _callRemovalHooks() {
-  var _arr = _removalHooks.hooks;
+function _removeFromScope() {
+  const bindings = this.getBindingIdentifiers();
+  Object.keys(bindings).forEach(name => this.scope.removeBinding(name));
+}
 
-  for (var _i = 0; _i < _arr.length; _i++) {
-    var fn = _arr[_i];
+function _callRemovalHooks() {
+  for (const fn of _removalHooks.hooks) {
     if (fn(this, this.parentPath)) return true;
   }
 }

package/lib/path/replacement.js

@@ -1,6 +1,8 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.replaceWithMultiple = replaceWithMultiple;
 exports.replaceWithSourceString = replaceWithSourceString;
 exports.replaceWith = replaceWith;
@@ -8,56 +10,79 @@ exports._replaceWith = _replaceWith;
 exports.replaceExpressionWithStatements = replaceExpressionWithStatements;
 exports.replaceInline = replaceInline;
 
-var _codeFrame = require("@babel/code-frame");
+function _codeFrame() {
+  const data = require("@babel/code-frame");
+
+  _codeFrame = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _index = _interopRequireDefault(require("../index"));
 
 var _index2 = _interopRequireDefault(require("./index"));
 
-var _babylon = require("babylon");
+function _parser() {
+  const data = require("@babel/parser");
+
+  _parser = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
 
-var t = _interopRequireWildcard(require("@babel/types"));
+  t = function () {
+    return data;
+  };
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+  return data;
+}
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var hoistVariablesVisitor = {
-  Function: function Function(path) {
+const hoistVariablesVisitor = {
+  Function(path) {
     path.skip();
   },
-  VariableDeclaration: function VariableDeclaration(path) {
+
+  VariableDeclaration(path) {
     if (path.node.kind !== "var") return;
-    var bindings = path.getBindingIdentifiers();
+    const bindings = path.getBindingIdentifiers();
 
-    for (var key in bindings) {
+    for (const key in bindings) {
       path.scope.push({
         id: bindings[key]
       });
     }
 
-    var exprs = [];
-    var _arr = path.node.declarations;
-
-    for (var _i = 0; _i < _arr.length; _i++) {
-      var declar = _arr[_i];
+    const exprs = [];
 
+    for (const declar of path.node.declarations) {
       if (declar.init) {
-        exprs.push(t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init)));
+        exprs.push(t().expressionStatement(t().assignmentExpression("=", declar.id, declar.init)));
       }
     }
 
     path.replaceWithMultiple(exprs);
   }
+
 };
 
 function replaceWithMultiple(nodes) {
   this.resync();
   nodes = this._verifyNodeList(nodes);
-  t.inheritLeadingComments(nodes[0], this.node);
-  t.inheritTrailingComments(nodes[nodes.length - 1], this.node);
+  t().inheritLeadingComments(nodes[0], this.node);
+  t().inheritTrailingComments(nodes[nodes.length - 1], this.node);
   this.node = this.container[this.key] = null;
-  var paths = this.insertAfter(nodes);
+  const paths = this.insertAfter(nodes);
 
   if (this.node) {
     this.requeue();
@@ -72,19 +97,19 @@ function replaceWithSourceString(replacement) {
   this.resync();
 
   try {
-    replacement = "(" + replacement + ")";
-    replacement = (0, _babylon.parse)(replacement);
+    replacement = `(${replacement})`;
+    replacement = (0, _parser().parse)(replacement);
   } catch (err) {
-    var loc = err.loc;
+    const loc = err.loc;
 
     if (loc) {
-      err.loc = null;
-      err.message += " - make sure this is an expression.\n" + (0, _codeFrame.codeFrameColumns)(replacement, {
+      err.message += " - make sure this is an expression.\n" + (0, _codeFrame().codeFrameColumns)(replacement, {
         start: {
           line: loc.line,
           column: loc.column + 1
         }
       });
+      err.code = "BABEL_REPLACE_SOURCE_ERROR";
     }
 
     throw err;
@@ -116,7 +141,7 @@ function replaceWith(replacement) {
     return [this];
   }
 
-  if (this.isProgram() && !t.isProgram(replacement)) {
+  if (this.isProgram() && !t().isProgram(replacement)) {
     throw new Error("You can only replace a Program root node with another Program node");
   }
 
@@ -128,26 +153,26 @@ function replaceWith(replacement) {
     throw new Error("Don't use `path.replaceWith()` with a source string, use `path.replaceWithSourceString()`");
   }
 
-  var nodePath = "";
+  let nodePath = "";
 
-  if (this.isNodeType("Statement") && t.isExpression(replacement)) {
+  if (this.isNodeType("Statement") && t().isExpression(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement) && !this.parentPath.isExportDefaultDeclaration()) {
-      replacement = t.expressionStatement(replacement);
+      replacement = t().expressionStatement(replacement);
       nodePath = "expression";
     }
   }
 
-  if (this.isNodeType("Expression") && t.isStatement(replacement)) {
+  if (this.isNodeType("Expression") && t().isStatement(replacement)) {
     if (!this.canHaveVariableDeclarationOrExpression() && !this.canSwapBetweenExpressionAndStatement(replacement)) {
       return this.replaceExpressionWithStatements([replacement]);
     }
   }
 
-  var oldNode = this.node;
+  const oldNode = this.node;
 
   if (oldNode) {
-    t.inheritsComments(replacement, oldNode);
-    t.removeComments(oldNode);
+    t().inheritsComments(replacement, oldNode);
+    t().removeComments(oldNode);
   }
 
   this._replaceWith(replacement);
@@ -164,69 +189,51 @@ function _replaceWith(node) {
   }
 
   if (this.inList) {
-    t.validate(this.parent, this.key, [node]);
+    t().validate(this.parent, this.key, [node]);
   } else {
-    t.validate(this.parent, this.key, node);
+    t().validate(this.parent, this.key, node);
   }
 
-  this.debug("Replace with " + (node && node.type));
+  this.debug(`Replace with ${node && node.type}`);
   this.node = this.container[this.key] = node;
 }
 
 function replaceExpressionWithStatements(nodes) {
   this.resync();
-  var toSequenceExpression = t.toSequenceExpression(nodes, this.scope);
+  const toSequenceExpression = t().toSequenceExpression(nodes, this.scope);
 
   if (toSequenceExpression) {
     return this.replaceWith(toSequenceExpression)[0].get("expressions");
   }
 
-  var container = t.arrowFunctionExpression([], t.blockStatement(nodes));
-  this.replaceWith(t.callExpression(container, []));
+  const container = t().arrowFunctionExpression([], t().blockStatement(nodes));
+  this.replaceWith(t().callExpression(container, []));
   this.traverse(hoistVariablesVisitor);
-  var completionRecords = this.get("callee").getCompletionRecords();
-
-  for (var _iterator = completionRecords, _isArray = Array.isArray(_iterator), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-    var _ref;
-
-    if (_isArray) {
-      if (_i2 >= _iterator.length) break;
-      _ref = _iterator[_i2++];
-    } else {
-      _i2 = _iterator.next();
-      if (_i2.done) break;
-      _ref = _i2.value;
-    }
-
-    var _path = _ref;
-    if (!_path.isExpressionStatement()) continue;
+  const completionRecords = this.get("callee").getCompletionRecords();
 
-    var loop = _path.findParent(function (path) {
-      return path.isLoop();
-    });
+  for (const path of completionRecords) {
+    if (!path.isExpressionStatement()) continue;
+    const loop = path.findParent(path => path.isLoop());
 
     if (loop) {
-      var uid = loop.getData("expressionReplacementReturnUid");
+      let uid = loop.getData("expressionReplacementReturnUid");
 
       if (!uid) {
-        var _callee = this.get("callee");
-
-        uid = _callee.scope.generateDeclaredUidIdentifier("ret");
-
-        _callee.get("body").pushContainer("body", t.returnStatement(uid));
-
+        const callee = this.get("callee");
+        uid = callee.scope.generateDeclaredUidIdentifier("ret");
+        callee.get("body").pushContainer("body", t().returnStatement(t().cloneNode(uid)));
         loop.setData("expressionReplacementReturnUid", uid);
       } else {
-        uid = t.identifier(uid.name);
+        uid = t().identifier(uid.name);
       }
 
-      _path.get("expression").replaceWith(t.assignmentExpression("=", uid, _path.node.expression));
+      path.get("expression").replaceWith(t().assignmentExpression("=", t().cloneNode(uid), path.node.expression));
     } else {
-      _path.replaceWith(t.returnStatement(_path.node.expression));
+      path.replaceWith(t().returnStatement(path.node.expression));
     }
   }
 
-  var callee = this.get("callee");
+  const callee = this.get("callee");
   callee.arrowFunctionToExpression();
   return callee.get("body.body");
 }
@@ -238,7 +245,7 @@ function replaceInline(nodes) {
     if (Array.isArray(this.container)) {
       nodes = this._verifyNodeList(nodes);
 
-      var paths = this._containerInsertAfter(nodes);
+      const paths = this._containerInsertAfter(nodes);
 
       this.remove();
       return paths;

package/lib/scope/binding.js

@@ -1,14 +1,17 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.default = void 0;
 
-var Binding = function () {
-  function Binding(_ref) {
-    var identifier = _ref.identifier,
-        scope = _ref.scope,
-        path = _ref.path,
-        kind = _ref.kind;
+class Binding {
+  constructor({
+    identifier,
+    scope,
+    path,
+    kind
+  }) {
     this.identifier = identifier;
     this.scope = scope;
     this.path = path;
@@ -21,26 +24,24 @@ var Binding = function () {
     this.clearValue();
   }
 
-  var _proto = Binding.prototype;
-
-  _proto.deoptValue = function deoptValue() {
+  deoptValue() {
     this.clearValue();
     this.hasDeoptedValue = true;
-  };
+  }
 
-  _proto.setValue = function setValue(value) {
+  setValue(value) {
     if (this.hasDeoptedValue) return;
     this.hasValue = true;
     this.value = value;
-  };
+  }
 
-  _proto.clearValue = function clearValue() {
+  clearValue() {
     this.hasDeoptedValue = false;
     this.hasValue = false;
     this.value = null;
-  };
+  }
 
-  _proto.reassign = function reassign(path) {
+  reassign(path) {
     this.constant = false;
 
     if (this.constantViolations.indexOf(path) !== -1) {
@@ -48,9 +49,9 @@ var Binding = function () {
     }
 
     this.constantViolations.push(path);
-  };
+  }
 
-  _proto.reference = function reference(path) {
+  reference(path) {
     if (this.referencePaths.indexOf(path) !== -1) {
       return;
     }
@@ -58,14 +59,13 @@ var Binding = function () {
     this.referenced = true;
     this.references++;
     this.referencePaths.push(path);
-  };
+  }
 
-  _proto.dereference = function dereference() {
+  dereference() {
     this.references--;
     this.referenced = !!this.references;
-  };
+  }
 
-  return Binding;
-}();
+}
 
 exports.default = Binding;