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

package/lib/path/lib/hoister.js

@@ -1,20 +1,30 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.default = void 0;
 
-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;
+  };
+
+  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; } }
 
-var referenceVisitor = {
-  ReferencedIdentifier: function ReferencedIdentifier(path, state) {
-    if (path.isJSXIdentifier() && t.react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
+const referenceVisitor = {
+  ReferencedIdentifier(path, state) {
+    if (path.isJSXIdentifier() && t().react.isCompatTag(path.node.name) && !path.parentPath.isJSXMemberExpression()) {
       return;
     }
 
     if (path.node.name === "this") {
-      var scope = path.scope;
+      let scope = path.scope;
 
       do {
         if (scope.path.isFunction() && !scope.path.isArrowFunctionExpression()) {
@@ -25,15 +35,16 @@ var referenceVisitor = {
       if (scope) state.breakOnScopePaths.push(scope.path);
     }
 
-    var binding = path.scope.getBinding(path.node.name);
+    const binding = path.scope.getBinding(path.node.name);
     if (!binding) return;
     if (binding !== state.scope.getBinding(path.node.name)) return;
     state.bindings[path.node.name] = binding;
   }
+
 };
 
-var PathHoister = function () {
-  function PathHoister(path, scope) {
+class PathHoister {
+  constructor(path, scope) {
     this.breakOnScopePaths = [];
     this.bindings = {};
     this.scopes = [];
@@ -42,11 +53,9 @@ var PathHoister = function () {
     this.attachAfter = false;
   }
 
-  var _proto = PathHoister.prototype;
-
-  _proto.isCompatibleScope = function isCompatibleScope(scope) {
-    for (var key in this.bindings) {
-      var binding = this.bindings[key];
+  isCompatibleScope(scope) {
+    for (const key in this.bindings) {
+      const binding = this.bindings[key];
 
       if (!scope.bindingIdentifierEquals(key, binding.identifier)) {
         return false;
@@ -54,10 +63,10 @@ var PathHoister = function () {
     }
 
     return true;
-  };
+  }
 
-  _proto.getCompatibleScopes = function getCompatibleScopes() {
-    var scope = this.path.scope;
+  getCompatibleScopes() {
+    let scope = this.path.scope;
 
     do {
       if (this.isCompatibleScope(scope)) {
@@ -70,37 +79,34 @@ var PathHoister = function () {
         break;
       }
     } while (scope = scope.parent);
-  };
+  }
 
-  _proto.getAttachmentPath = function getAttachmentPath() {
-    var path = this._getAttachmentPath();
+  getAttachmentPath() {
+    let path = this._getAttachmentPath();
 
     if (!path) return;
-    var targetScope = path.scope;
+    let targetScope = path.scope;
 
     if (targetScope.path === path) {
       targetScope = path.scope.parent;
     }
 
     if (targetScope.path.isProgram() || targetScope.path.isFunction()) {
-      for (var name in this.bindings) {
+      for (const name in this.bindings) {
         if (!targetScope.hasOwnBinding(name)) continue;
-        var binding = this.bindings[name];
+        const binding = this.bindings[name];
 
         if (binding.kind === "param" || binding.path.parentKey === "params") {
           continue;
         }
 
-        var bindingParentPath = this.getAttachmentParentForPath(binding.path);
+        const bindingParentPath = this.getAttachmentParentForPath(binding.path);
 
         if (bindingParentPath.key >= path.key) {
           this.attachAfter = true;
           path = binding.path;
-          var _arr = binding.constantViolations;
-
-          for (var _i = 0; _i < _arr.length; _i++) {
-            var violationPath = _arr[_i];
 
+          for (const violationPath of binding.constantViolations) {
             if (this.getAttachmentParentForPath(violationPath).key > path.key) {
               path = violationPath;
             }
@@ -109,24 +115,20 @@ var PathHoister = function () {
       }
     }
 
-    if (path.parentPath.isExportDeclaration()) {
-      path = path.parentPath;
-    }
-
     return path;
-  };
+  }
 
-  _proto._getAttachmentPath = function _getAttachmentPath() {
-    var scopes = this.scopes;
-    var scope = scopes.pop();
+  _getAttachmentPath() {
+    const scopes = this.scopes;
+    const scope = scopes.pop();
     if (!scope) return;
 
     if (scope.path.isFunction()) {
       if (this.hasOwnParamBindings(scope)) {
         if (this.scope === scope) return;
-        var bodies = scope.path.get("body").get("body");
+        const bodies = scope.path.get("body").get("body");
 
-        for (var i = 0; i < bodies.length; i++) {
+        for (let i = 0; i < bodies.length; i++) {
           if (bodies[i].node._blockHoist) continue;
           return bodies[i];
         }
@@ -136,51 +138,51 @@ var PathHoister = function () {
     } else if (scope.path.isProgram()) {
       return this.getNextScopeAttachmentParent();
     }
-  };
+  }
 
-  _proto.getNextScopeAttachmentParent = function getNextScopeAttachmentParent() {
-    var scope = this.scopes.pop();
+  getNextScopeAttachmentParent() {
+    const scope = this.scopes.pop();
     if (scope) return this.getAttachmentParentForPath(scope.path);
-  };
+  }
 
-  _proto.getAttachmentParentForPath = function getAttachmentParentForPath(path) {
+  getAttachmentParentForPath(path) {
     do {
       if (!path.parentPath || Array.isArray(path.container) && path.isStatement()) {
         return path;
       }
     } while (path = path.parentPath);
-  };
+  }
 
-  _proto.hasOwnParamBindings = function hasOwnParamBindings(scope) {
-    for (var name in this.bindings) {
+  hasOwnParamBindings(scope) {
+    for (const name in this.bindings) {
       if (!scope.hasOwnBinding(name)) continue;
-      var binding = this.bindings[name];
+      const binding = this.bindings[name];
       if (binding.kind === "param" && binding.constant) return true;
     }
 
     return false;
-  };
+  }
 
-  _proto.run = function run() {
+  run() {
     this.path.traverse(referenceVisitor, this);
     this.getCompatibleScopes();
-    var attachTo = this.getAttachmentPath();
+    const attachTo = this.getAttachmentPath();
     if (!attachTo) return;
     if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
-    var uid = attachTo.scope.generateUidIdentifier("ref");
-    var declarator = t.variableDeclarator(uid, this.path.node);
-    var insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
-    attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t.variableDeclaration("var", [declarator])]);
-    var parent = this.path.parentPath;
+    let uid = attachTo.scope.generateUidIdentifier("ref");
+    const declarator = t().variableDeclarator(uid, this.path.node);
+    const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
+    const [attached] = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t().variableDeclaration("var", [declarator])]);
+    const parent = this.path.parentPath;
 
     if (parent.isJSXElement() && this.path.container === parent.node.children) {
-      uid = t.JSXExpressionContainer(uid);
+      uid = t().JSXExpressionContainer(uid);
     }
 
-    this.path.replaceWith(uid);
-  };
+    this.path.replaceWith(t().cloneNode(uid));
+    return attachTo.isVariableDeclarator() ? attached.get("init") : attached.get("declarations.0.init");
+  }
 
-  return PathHoister;
-}();
+}
 
 exports.default = PathHoister;

package/lib/path/lib/removal-hooks.js

@@ -1,9 +1,11 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.hooks = void 0;
-var hooks = [function (self, parent) {
-  var removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
+const hooks = [function (self, parent) {
+  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
 
   if (removeParent) {
     parent.remove();

package/lib/path/lib/virtual-types.js

@@ -1,60 +1,79 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.ForAwaitStatement = exports.NumericLiteralTypeAnnotation = exports.ExistentialTypeParam = exports.SpreadProperty = exports.RestProperty = exports.Flow = exports.Pure = exports.Generated = exports.User = exports.Var = exports.BlockScoped = exports.Referenced = exports.Scope = exports.Expression = exports.Statement = exports.BindingIdentifier = exports.ReferencedMemberExpression = exports.ReferencedIdentifier = void 0;
 
-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;
+  };
 
-var ReferencedIdentifier = {
+  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; } }
+
+const ReferencedIdentifier = {
   types: ["Identifier", "JSXIdentifier"],
-  checkPath: function checkPath(_ref, opts) {
-    var node = _ref.node,
-        parent = _ref.parent;
 
-    if (!t.isIdentifier(node, opts) && !t.isJSXMemberExpression(parent, opts)) {
-      if (t.isJSXIdentifier(node, opts)) {
-        if (t.react.isCompatTag(node.name)) return false;
+  checkPath({
+    node,
+    parent
+  }, opts) {
+    if (!t().isIdentifier(node, opts) && !t().isJSXMemberExpression(parent, opts)) {
+      if (t().isJSXIdentifier(node, opts)) {
+        if (t().react.isCompatTag(node.name)) return false;
       } else {
         return false;
       }
     }
 
-    return t.isReferenced(node, parent);
+    return t().isReferenced(node, parent);
   }
+
 };
 exports.ReferencedIdentifier = ReferencedIdentifier;
-var ReferencedMemberExpression = {
+const ReferencedMemberExpression = {
   types: ["MemberExpression"],
-  checkPath: function checkPath(_ref2) {
-    var node = _ref2.node,
-        parent = _ref2.parent;
-    return t.isMemberExpression(node) && t.isReferenced(node, parent);
+
+  checkPath({
+    node,
+    parent
+  }) {
+    return t().isMemberExpression(node) && t().isReferenced(node, parent);
   }
+
 };
 exports.ReferencedMemberExpression = ReferencedMemberExpression;
-var BindingIdentifier = {
+const BindingIdentifier = {
   types: ["Identifier"],
-  checkPath: function checkPath(_ref3) {
-    var node = _ref3.node,
-        parent = _ref3.parent;
-    return t.isIdentifier(node) && t.isBinding(node, parent);
+
+  checkPath({
+    node,
+    parent
+  }) {
+    return t().isIdentifier(node) && t().isBinding(node, parent);
   }
+
 };
 exports.BindingIdentifier = BindingIdentifier;
-var Statement = {
+const Statement = {
   types: ["Statement"],
-  checkPath: function checkPath(_ref4) {
-    var node = _ref4.node,
-        parent = _ref4.parent;
 
-    if (t.isStatement(node)) {
-      if (t.isVariableDeclaration(node)) {
-        if (t.isForXStatement(parent, {
+  checkPath({
+    node,
+    parent
+  }) {
+    if (t().isStatement(node)) {
+      if (t().isVariableDeclaration(node)) {
+        if (t().isForXStatement(parent, {
           left: node
         })) return false;
-        if (t.isForStatement(parent, {
+        if (t().isForStatement(parent, {
           init: node
         })) return false;
       }
@@ -64,109 +83,130 @@ var Statement = {
       return false;
     }
   }
+
 };
 exports.Statement = Statement;
-var Expression = {
+const Expression = {
   types: ["Expression"],
-  checkPath: function checkPath(path) {
+
+  checkPath(path) {
     if (path.isIdentifier()) {
       return path.isReferencedIdentifier();
     } else {
-      return t.isExpression(path.node);
+      return t().isExpression(path.node);
     }
   }
+
 };
 exports.Expression = Expression;
-var Scope = {
+const Scope = {
   types: ["Scopable"],
-  checkPath: function checkPath(path) {
-    return t.isScope(path.node, path.parent);
+
+  checkPath(path) {
+    return t().isScope(path.node, path.parent);
   }
+
 };
 exports.Scope = Scope;
-var Referenced = {
-  checkPath: function checkPath(path) {
-    return t.isReferenced(path.node, path.parent);
+const Referenced = {
+  checkPath(path) {
+    return t().isReferenced(path.node, path.parent);
   }
+
 };
 exports.Referenced = Referenced;
-var BlockScoped = {
-  checkPath: function checkPath(path) {
-    return t.isBlockScoped(path.node);
+const BlockScoped = {
+  checkPath(path) {
+    return t().isBlockScoped(path.node);
   }
+
 };
 exports.BlockScoped = BlockScoped;
-var Var = {
+const Var = {
   types: ["VariableDeclaration"],
-  checkPath: function checkPath(path) {
-    return t.isVar(path.node);
+
+  checkPath(path) {
+    return t().isVar(path.node);
   }
+
 };
 exports.Var = Var;
-var User = {
-  checkPath: function checkPath(path) {
+const User = {
+  checkPath(path) {
     return path.node && !!path.node.loc;
   }
+
 };
 exports.User = User;
-var Generated = {
-  checkPath: function checkPath(path) {
+const Generated = {
+  checkPath(path) {
     return !path.isUser();
   }
+
 };
 exports.Generated = Generated;
-var Pure = {
-  checkPath: function checkPath(path, opts) {
+const Pure = {
+  checkPath(path, opts) {
     return path.scope.isPure(path.node, opts);
   }
+
 };
 exports.Pure = Pure;
-var Flow = {
+const Flow = {
   types: ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"],
-  checkPath: function checkPath(_ref5) {
-    var node = _ref5.node;
 
-    if (t.isFlow(node)) {
+  checkPath({
+    node
+  }) {
+    if (t().isFlow(node)) {
       return true;
-    } else if (t.isImportDeclaration(node)) {
+    } else if (t().isImportDeclaration(node)) {
       return node.importKind === "type" || node.importKind === "typeof";
-    } else if (t.isExportDeclaration(node)) {
+    } else if (t().isExportDeclaration(node)) {
       return node.exportKind === "type";
-    } else if (t.isImportSpecifier(node)) {
+    } else if (t().isImportSpecifier(node)) {
       return node.importKind === "type" || node.importKind === "typeof";
     } else {
       return false;
     }
   }
+
 };
 exports.Flow = Flow;
-var RestProperty = {
+const RestProperty = {
   types: ["RestElement"],
-  checkPath: function checkPath(path) {
+
+  checkPath(path) {
     return path.parentPath && path.parentPath.isObjectPattern();
   }
+
 };
 exports.RestProperty = RestProperty;
-var SpreadProperty = {
+const SpreadProperty = {
   types: ["RestElement"],
-  checkPath: function checkPath(path) {
+
+  checkPath(path) {
     return path.parentPath && path.parentPath.isObjectExpression();
   }
+
 };
 exports.SpreadProperty = SpreadProperty;
-var ExistentialTypeParam = {
+const ExistentialTypeParam = {
   types: ["ExistsTypeAnnotation"]
 };
 exports.ExistentialTypeParam = ExistentialTypeParam;
-var NumericLiteralTypeAnnotation = {
+const NumericLiteralTypeAnnotation = {
   types: ["NumberLiteralTypeAnnotation"]
 };
 exports.NumericLiteralTypeAnnotation = NumericLiteralTypeAnnotation;
-var ForAwaitStatement = {
+const ForAwaitStatement = {
   types: ["ForOfStatement"],
-  checkPath: function checkPath(_ref6) {
-    var node = _ref6.node;
+
+  checkPath({
+    node
+  }) {
     return node.await === true;
   }
+
 };
 exports.ForAwaitStatement = ForAwaitStatement;