@babel/traverse 7.0.0-beta.46 → 7.0.0-beta.47

package/lib/path/introspection.js

@@ -25,7 +25,7 @@ exports.isInStrictMode = isInStrictMode;
 exports.is = void 0;
 
 function _includes() {
-  var data = _interopRequireDefault(require("lodash/includes"));
+  const data = _interopRequireDefault(require("lodash/includes"));
 
   _includes = function _includes() {
     return data;
@@ -35,7 +35,7 @@ function _includes() {
 }
 
 function t() {
-  var data = _interopRequireWildcard(require("@babel/types"));
+  const data = _interopRequireWildcard(require("@babel/types"));
 
   t = function t() {
     return data;
@@ -53,7 +53,7 @@ function matchesPattern(pattern, allowPartial) {
 }
 
 function has(key) {
-  var val = this.node && this.node[key];
+  const val = this.node && this.node[key];
 
   if (val && Array.isArray(val)) {
     return !!val.length;
@@ -66,7 +66,7 @@ function isStatic() {
   return this.scope.isStatic(this.node);
 }
 
-var is = has;
+const is = has;
 exports.is = is;
 
 function isnt(key) {
@@ -100,11 +100,11 @@ function canSwapBetweenExpressionAndStatement(replacement) {
 }
 
 function isCompletionRecord(allowInsideFunction) {
-  var path = this;
-  var first = true;
+  let path = this;
+  let first = true;
 
   do {
-    var container = path.container;
+    const container = path.container;
 
     if (path.isFunction() && !first) {
       return !!allowInsideFunction;
@@ -130,10 +130,10 @@ function isStatementOrBlock() {
 
 function referencesImport(moduleSource, importName) {
   if (!this.isReferencedIdentifier()) return false;
-  var binding = this.scope.getBinding(this.node.name);
+  const binding = this.scope.getBinding(this.node.name);
   if (!binding || binding.kind !== "module") return false;
-  var path = binding.path;
-  var parent = path.parentPath;
+  const path = binding.path;
+  const parent = path.parentPath;
   if (!parent.isImportDeclaration()) return false;
 
   if (parent.node.source.value === moduleSource) {
@@ -158,7 +158,7 @@ function referencesImport(moduleSource, importName) {
 }
 
 function getSource() {
-  var node = this.node;
+  const node = this.node;
 
   if (node.end) {
     return this.hub.file.code.slice(node.start, node.end);
@@ -172,11 +172,11 @@ function willIMaybeExecuteBefore(target) {
 }
 
 function _guessExecutionStatusRelativeTo(target) {
-  var targetFuncParent = target.scope.getFunctionParent() || target.scope.getProgramParent();
-  var selfFuncParent = this.scope.getFunctionParent() || target.scope.getProgramParent();
+  const targetFuncParent = target.scope.getFunctionParent() || target.scope.getProgramParent();
+  const selfFuncParent = this.scope.getFunctionParent() || target.scope.getProgramParent();
 
   if (targetFuncParent.node !== selfFuncParent.node) {
-    var status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent);
+    const status = this._guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent);
 
     if (status) {
       return status;
@@ -185,15 +185,15 @@ function _guessExecutionStatusRelativeTo(target) {
     }
   }
 
-  var targetPaths = target.getAncestry();
+  const targetPaths = target.getAncestry();
   if (targetPaths.indexOf(this) >= 0) return "after";
-  var selfPaths = this.getAncestry();
-  var commonPath;
-  var targetIndex;
-  var selfIndex;
+  const selfPaths = this.getAncestry();
+  let commonPath;
+  let targetIndex;
+  let selfIndex;
 
   for (selfIndex = 0; selfIndex < selfPaths.length; selfIndex++) {
-    var selfPath = selfPaths[selfIndex];
+    const selfPath = selfPaths[selfIndex];
     targetIndex = targetPaths.indexOf(selfPath);
 
     if (targetIndex >= 0) {
@@ -206,8 +206,8 @@ function _guessExecutionStatusRelativeTo(target) {
     return "before";
   }
 
-  var targetRelationship = targetPaths[targetIndex - 1];
-  var selfRelationship = selfPaths[selfIndex - 1];
+  const targetRelationship = targetPaths[targetIndex - 1];
+  const selfRelationship = selfPaths[selfIndex - 1];
 
   if (!targetRelationship || !selfRelationship) {
     return "before";
@@ -217,18 +217,18 @@ function _guessExecutionStatusRelativeTo(target) {
     return targetRelationship.key > selfRelationship.key ? "before" : "after";
   }
 
-  var keys = t().VISITOR_KEYS[commonPath.type];
-  var targetKeyPosition = keys.indexOf(targetRelationship.key);
-  var selfKeyPosition = keys.indexOf(selfRelationship.key);
+  const keys = t().VISITOR_KEYS[commonPath.type];
+  const targetKeyPosition = keys.indexOf(targetRelationship.key);
+  const selfKeyPosition = keys.indexOf(selfRelationship.key);
   return targetKeyPosition > selfKeyPosition ? "before" : "after";
 }
 
 function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) {
-  var targetFuncPath = targetFuncParent.path;
+  const targetFuncPath = targetFuncParent.path;
   if (!targetFuncPath.isFunctionDeclaration()) return;
-  var binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name);
+  const binding = targetFuncPath.scope.getBinding(targetFuncPath.node.id.name);
   if (!binding.references) return "before";
-  var referencePaths = binding.referencePaths;
+  const referencePaths = binding.referencePaths;
 
   for (var _iterator = referencePaths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
     var _ref;
@@ -242,14 +242,14 @@ function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) {
       _ref = _i.value;
     }
 
-    var path = _ref;
+    const path = _ref;
 
     if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
       return;
     }
   }
 
-  var allStatus;
+  let allStatus;
 
   for (var _iterator2 = referencePaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
     var _ref2;
@@ -263,13 +263,11 @@ function _guessExecutionStatusRelativeToDifferentFunctions(targetFuncParent) {
       _ref2 = _i2.value;
     }
 
-    var _path = _ref2;
-    var childOfFunction = !!_path.find(function (path) {
-      return path.node === targetFuncPath.node;
-    });
+    const path = _ref2;
+    const childOfFunction = !!path.find(path => path.node === targetFuncPath.node);
     if (childOfFunction) continue;
 
-    var status = this._guessExecutionStatusRelativeTo(_path);
+    const status = this._guessExecutionStatusRelativeTo(path);
 
     if (allStatus) {
       if (allStatus !== status) return;
@@ -295,35 +293,33 @@ function _resolve(dangerous, resolved) {
       return this.get("init").resolve(dangerous, resolved);
     } else {}
   } else if (this.isReferencedIdentifier()) {
-    var binding = this.scope.getBinding(this.node.name);
+    const binding = this.scope.getBinding(this.node.name);
     if (!binding) return;
     if (!binding.constant) return;
     if (binding.kind === "module") return;
 
     if (binding.path !== this) {
-      var ret = binding.path.resolve(dangerous, resolved);
-      if (this.find(function (parent) {
-        return parent.node === ret.node;
-      })) return;
+      const ret = binding.path.resolve(dangerous, resolved);
+      if (this.find(parent => parent.node === ret.node)) return;
       return ret;
     }
   } else if (this.isTypeCastExpression()) {
     return this.get("expression").resolve(dangerous, resolved);
   } else if (dangerous && this.isMemberExpression()) {
-    var targetKey = this.toComputedKey();
+    const targetKey = this.toComputedKey();
     if (!t().isLiteral(targetKey)) return;
-    var targetName = targetKey.value;
-    var target = this.get("object").resolve(dangerous, resolved);
+    const targetName = targetKey.value;
+    const target = this.get("object").resolve(dangerous, resolved);
 
     if (target.isObjectExpression()) {
-      var props = target.get("properties");
+      const props = target.get("properties");
       var _arr = props;
 
       for (var _i3 = 0; _i3 < _arr.length; _i3++) {
-        var prop = _arr[_i3];
+        const prop = _arr[_i3];
         if (!prop.isProperty()) continue;
-        var key = prop.get("key");
-        var match = prop.isnt("computed") && key.isIdentifier({
+        const key = prop.get("key");
+        let match = prop.isnt("computed") && key.isIdentifier({
           name: targetName
         });
         match = match || key.isLiteral({
@@ -332,8 +328,8 @@ function _resolve(dangerous, resolved) {
         if (match) return prop.get("value").resolve(dangerous, resolved);
       }
     } else if (target.isArrayExpression() && !isNaN(+targetName)) {
-      var elems = target.get("elements");
-      var elem = elems[targetName];
+      const elems = target.get("elements");
+      const elem = elems[targetName];
       if (elem) return elem.resolve(dangerous, resolved);
     }
   }
@@ -341,7 +337,7 @@ function _resolve(dangerous, resolved) {
 
 function isConstantExpression() {
   if (this.isIdentifier()) {
-    var binding = this.scope.getBinding(this.node.name);
+    const binding = this.scope.getBinding(this.node.name);
 
     if (!binding) {
       return false;
@@ -356,9 +352,7 @@ function isConstantExpression() {
     }
 
     if (this.isTemplateLiteral()) {
-      return this.get("expressions").every(function (expression) {
-        return expression.isConstantExpression();
-      });
+      return this.get("expressions").every(expression => expression.isConstantExpression());
     }
 
     return true;
@@ -380,8 +374,8 @@ function isConstantExpression() {
 }
 
 function isInStrictMode() {
-  var start = this.isProgram() ? this : this.parentPath;
-  var strictParent = start.find(function (path) {
+  const start = this.isProgram() ? this : this.parentPath;
+  const strictParent = start.find(path => {
     if (path.isProgram({
       sourceType: "module"
     })) return true;
@@ -392,7 +386,7 @@ function isInStrictMode() {
       return false;
     }
 
-    var node = path.node;
+    let node = path.node;
     if (path.isFunction()) node = node.body;
 
     for (var _iterator3 = node.directives, _isArray3 = Array.isArray(_iterator3), _i4 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
@@ -407,7 +401,7 @@ function isInStrictMode() {
         _ref3 = _i4.value;
       }
 
-      var directive = _ref3;
+      const directive = _ref3;
 
       if (directive.value.value === "use strict") {
         return true;

package/lib/path/lib/hoister.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 
 function t() {
-  var data = _interopRequireWildcard(require("@babel/types"));
+  const data = _interopRequireWildcard(require("@babel/types"));
 
   t = function t() {
     return data;
@@ -17,14 +17,14 @@ function t() {
 
 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) {
+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()) {
@@ -35,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 = [];
@@ -52,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;
@@ -64,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)) {
@@ -80,28 +79,28 @@ 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;
@@ -109,7 +108,7 @@ var PathHoister = function () {
           var _arr = binding.constantViolations;
 
           for (var _i = 0; _i < _arr.length; _i++) {
-            var violationPath = _arr[_i];
+            const violationPath = _arr[_i];
 
             if (this.getAttachmentParentForPath(violationPath).key > path.key) {
               path = violationPath;
@@ -120,19 +119,19 @@ var PathHoister = function () {
     }
 
     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];
         }
@@ -142,45 +141,45 @@ 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";
+    let uid = attachTo.scope.generateUidIdentifier("ref");
+    const declarator = t().variableDeclarator(uid, this.path.node);
+    const insertFn = this.attachAfter ? "insertAfter" : "insertBefore";
 
-    var _attachTo$insertFn = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t().variableDeclaration("var", [declarator])]),
-        attached = _attachTo$insertFn[0];
+    const _attachTo$insertFn = attachTo[insertFn]([attachTo.isVariableDeclarator() ? declarator : t().variableDeclaration("var", [declarator])]),
+          attached = _attachTo$insertFn[0];
 
-    var parent = this.path.parentPath;
+    const parent = this.path.parentPath;
 
     if (parent.isJSXElement() && this.path.container === parent.node.children) {
       uid = t().JSXExpressionContainer(uid);
@@ -188,9 +187,8 @@ var PathHoister = function () {
 
     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

@@ -4,8 +4,8 @@ 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();