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

package/lib/path/inference/inferers.js

@@ -1,6 +1,8 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.VariableDeclarator = VariableDeclarator;
 exports.TypeCastExpression = TypeCastExpression;
 exports.NewExpression = NewExpression;
@@ -25,24 +27,32 @@ exports.CallExpression = CallExpression;
 exports.TaggedTemplateExpression = TaggedTemplateExpression;
 Object.defineProperty(exports, "Identifier", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _infererReference.default;
   }
 });
 
-var t = _interopRequireWildcard(require("@babel/types"));
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _infererReference = _interopRequireDefault(require("./inferer-reference"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+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 VariableDeclarator() {
-  var id = this.get("id");
+  const id = this.get("id");
   if (!id.isIdentifier()) return;
-  var init = this.get("init");
-  var type = init.getTypeAnnotation();
+  const init = this.get("init");
+  let type = init.getTypeAnnotation();
 
   if (type && type.type === "AnyTypeAnnotation") {
     if (init.isCallExpression() && init.get("callee").isIdentifier({
@@ -63,55 +73,55 @@ TypeCastExpression.validParent = true;
 
 function NewExpression(node) {
   if (this.get("callee").isIdentifier()) {
-    return t.genericTypeAnnotation(node.callee);
+    return t().genericTypeAnnotation(node.callee);
   }
 }
 
 function TemplateLiteral() {
-  return t.stringTypeAnnotation();
+  return t().stringTypeAnnotation();
 }
 
 function UnaryExpression(node) {
-  var operator = node.operator;
+  const operator = node.operator;
 
   if (operator === "void") {
-    return t.voidTypeAnnotation();
-  } else if (t.NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.numberTypeAnnotation();
-  } else if (t.STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.stringTypeAnnotation();
-  } else if (t.BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.booleanTypeAnnotation();
+    return t().voidTypeAnnotation();
+  } else if (t().NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().numberTypeAnnotation();
+  } else if (t().STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().stringTypeAnnotation();
+  } else if (t().BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().booleanTypeAnnotation();
   }
 }
 
 function BinaryExpression(node) {
-  var operator = node.operator;
+  const operator = node.operator;
 
-  if (t.NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.numberTypeAnnotation();
-  } else if (t.BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
-    return t.booleanTypeAnnotation();
+  if (t().NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().numberTypeAnnotation();
+  } else if (t().BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
+    return t().booleanTypeAnnotation();
   } else if (operator === "+") {
-    var right = this.get("right");
-    var left = this.get("left");
+    const right = this.get("right");
+    const left = this.get("left");
 
     if (left.isBaseType("number") && right.isBaseType("number")) {
-      return t.numberTypeAnnotation();
+      return t().numberTypeAnnotation();
     } else if (left.isBaseType("string") || right.isBaseType("string")) {
-      return t.stringTypeAnnotation();
+      return t().stringTypeAnnotation();
     }
 
-    return t.unionTypeAnnotation([t.stringTypeAnnotation(), t.numberTypeAnnotation()]);
+    return t().unionTypeAnnotation([t().stringTypeAnnotation(), t().numberTypeAnnotation()]);
   }
 }
 
 function LogicalExpression() {
-  return t.createUnionTypeAnnotation([this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]);
+  return t().createUnionTypeAnnotation([this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]);
 }
 
 function ConditionalExpression() {
-  return t.createUnionTypeAnnotation([this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]);
+  return t().createUnionTypeAnnotation([this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]);
 }
 
 function SequenceExpression() {
@@ -123,39 +133,39 @@ function AssignmentExpression() {
 }
 
 function UpdateExpression(node) {
-  var operator = node.operator;
+  const operator = node.operator;
 
   if (operator === "++" || operator === "--") {
-    return t.numberTypeAnnotation();
+    return t().numberTypeAnnotation();
   }
 }
 
 function StringLiteral() {
-  return t.stringTypeAnnotation();
+  return t().stringTypeAnnotation();
 }
 
 function NumericLiteral() {
-  return t.numberTypeAnnotation();
+  return t().numberTypeAnnotation();
 }
 
 function BooleanLiteral() {
-  return t.booleanTypeAnnotation();
+  return t().booleanTypeAnnotation();
 }
 
 function NullLiteral() {
-  return t.nullLiteralTypeAnnotation();
+  return t().nullLiteralTypeAnnotation();
 }
 
 function RegExpLiteral() {
-  return t.genericTypeAnnotation(t.identifier("RegExp"));
+  return t().genericTypeAnnotation(t().identifier("RegExp"));
 }
 
 function ObjectExpression() {
-  return t.genericTypeAnnotation(t.identifier("Object"));
+  return t().genericTypeAnnotation(t().identifier("Object"));
 }
 
 function ArrayExpression() {
-  return t.genericTypeAnnotation(t.identifier("Array"));
+  return t().genericTypeAnnotation(t().identifier("Array"));
 }
 
 function RestElement() {
@@ -165,23 +175,25 @@ function RestElement() {
 RestElement.validParent = true;
 
 function Func() {
-  return t.genericTypeAnnotation(t.identifier("Function"));
+  return t().genericTypeAnnotation(t().identifier("Function"));
 }
 
-var isArrayFrom = t.buildMatchMemberExpression("Array.from");
-var isObjectKeys = t.buildMatchMemberExpression("Object.keys");
-var isObjectValues = t.buildMatchMemberExpression("Object.values");
-var isObjectEntries = t.buildMatchMemberExpression("Object.entries");
+const isArrayFrom = t().buildMatchMemberExpression("Array.from");
+const isObjectKeys = t().buildMatchMemberExpression("Object.keys");
+const isObjectValues = t().buildMatchMemberExpression("Object.values");
+const isObjectEntries = t().buildMatchMemberExpression("Object.entries");
 
 function CallExpression() {
-  var callee = this.node.callee;
+  const {
+    callee
+  } = this.node;
 
   if (isObjectKeys(callee)) {
-    return t.arrayTypeAnnotation(t.stringTypeAnnotation());
+    return t().arrayTypeAnnotation(t().stringTypeAnnotation());
   } else if (isArrayFrom(callee) || isObjectValues(callee)) {
-    return t.arrayTypeAnnotation(t.anyTypeAnnotation());
+    return t().arrayTypeAnnotation(t().anyTypeAnnotation());
   } else if (isObjectEntries(callee)) {
-    return t.arrayTypeAnnotation(t.tupleTypeAnnotation([t.stringTypeAnnotation(), t.anyTypeAnnotation()]));
+    return t().arrayTypeAnnotation(t().tupleTypeAnnotation([t().stringTypeAnnotation(), t().anyTypeAnnotation()]));
   }
 
   return resolveCall(this.get("callee"));
@@ -197,9 +209,9 @@ function resolveCall(callee) {
   if (callee.isFunction()) {
     if (callee.is("async")) {
       if (callee.is("generator")) {
-        return t.genericTypeAnnotation(t.identifier("AsyncIterator"));
+        return t().genericTypeAnnotation(t().identifier("AsyncIterator"));
       } else {
-        return t.genericTypeAnnotation(t.identifier("Promise"));
+        return t().genericTypeAnnotation(t().identifier("Promise"));
       }
     } else {
       if (callee.node.returnType) {

package/lib/path/introspection.js

@@ -1,6 +1,8 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.matchesPattern = matchesPattern;
 exports.has = has;
 exports.isStatic = isStatic;
@@ -19,22 +21,39 @@ exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatu
 exports.resolve = resolve;
 exports._resolve = _resolve;
 exports.isConstantExpression = isConstantExpression;
+exports.isInStrictMode = isInStrictMode;
 exports.is = void 0;
 
-var _includes = _interopRequireDefault(require("lodash/includes"));
+function _includes() {
+  const data = _interopRequireDefault(require("lodash/includes"));
 
-var t = _interopRequireWildcard(require("@babel/types"));
+  _includes = 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 t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  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; } }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function matchesPattern(pattern, allowPartial) {
-  return t.matchesPattern(this.node, pattern, allowPartial);
+  return t().matchesPattern(this.node, 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;
@@ -47,7 +66,7 @@ function isStatic() {
   return this.scope.isStatic(this.node);
 }
 
-var is = has;
+const is = has;
 exports.is = is;
 
 function isnt(key) {
@@ -59,7 +78,7 @@ function equals(key, value) {
 }
 
 function isNodeType(type) {
-  return t.isType(this.type, type);
+  return t().isType(this.type, type);
 }
 
 function canHaveVariableDeclarationOrExpression() {
@@ -72,20 +91,20 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   }
 
   if (this.isExpression()) {
-    return t.isBlockStatement(replacement);
+    return t().isBlockStatement(replacement);
   } else if (this.isBlockStatement()) {
-    return t.isExpression(replacement);
+    return t().isExpression(replacement);
   }
 
   return false;
 }
 
 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;
@@ -102,19 +121,19 @@ function isCompletionRecord(allowInsideFunction) {
 }
 
 function isStatementOrBlock() {
-  if (this.parentPath.isLabeledStatement() || t.isBlockStatement(this.container)) {
+  if (this.parentPath.isLabeledStatement() || t().isBlockStatement(this.container)) {
     return false;
   } else {
-    return (0, _includes.default)(t.STATEMENT_OR_BLOCK_KEYS, this.key);
+    return (0, _includes().default)(t().STATEMENT_OR_BLOCK_KEYS, this.key);
   }
 }
 
 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) {
@@ -139,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);
@@ -153,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;
@@ -166,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) {
@@ -187,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";
@@ -198,59 +217,32 @@ 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;
-
-  for (var _iterator = referencePaths, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-    var _ref;
+  const referencePaths = binding.referencePaths;
 
-    if (_isArray) {
-      if (_i >= _iterator.length) break;
-      _ref = _iterator[_i++];
-    } else {
-      _i = _iterator.next();
-      if (_i.done) break;
-      _ref = _i.value;
-    }
-
-    var _path2 = _ref;
-
-    if (_path2.key !== "callee" || !_path2.parentPath.isCallExpression()) {
+  for (const path of referencePaths) {
+    if (path.key !== "callee" || !path.parentPath.isCallExpression()) {
       return;
     }
   }
 
-  var allStatus;
-
-  for (var _iterator2 = referencePaths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
-    var _ref2;
-
-    if (_isArray2) {
-      if (_i2 >= _iterator2.length) break;
-      _ref2 = _iterator2[_i2++];
-    } else {
-      _i2 = _iterator2.next();
-      if (_i2.done) break;
-      _ref2 = _i2.value;
-    }
+  let allStatus;
 
-    var _path3 = _ref2;
-    var childOfFunction = !!_path3.find(function (path) {
-      return path.node === targetFuncPath.node;
-    });
+  for (const path of referencePaths) {
+    const childOfFunction = !!path.find(path => path.node === targetFuncPath.node);
     if (childOfFunction) continue;
 
-    var status = this._guessExecutionStatusRelativeTo(_path3);
+    const status = this._guessExecutionStatusRelativeTo(path);
 
     if (allStatus) {
       if (allStatus !== status) return;
@@ -276,35 +268,31 @@ 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();
-    if (!t.isLiteral(targetKey)) return;
-    var targetName = targetKey.value;
-    var target = this.get("object").resolve(dangerous, resolved);
+    const targetKey = this.toComputedKey();
+    if (!t().isLiteral(targetKey)) return;
+    const targetName = targetKey.value;
+    const target = this.get("object").resolve(dangerous, resolved);
 
     if (target.isObjectExpression()) {
-      var props = target.get("properties");
-      var _arr = props;
+      const props = target.get("properties");
 
-      for (var _i3 = 0; _i3 < _arr.length; _i3++) {
-        var prop = _arr[_i3];
+      for (const prop of props) {
         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({
@@ -313,8 +301,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);
     }
   }
@@ -322,13 +310,9 @@ function _resolve(dangerous, resolved) {
 
 function isConstantExpression() {
   if (this.isIdentifier()) {
-    var binding = this.scope.getBinding(this.node.name);
-
-    if (!binding) {
-      return false;
-    }
-
-    return binding.constant && binding.path.get("init").isConstantExpression();
+    const binding = this.scope.getBinding(this.node.name);
+    if (!binding) return false;
+    return binding.constant;
   }
 
   if (this.isLiteral()) {
@@ -337,9 +321,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;
@@ -358,4 +340,31 @@ function isConstantExpression() {
   }
 
   return false;
+}
+
+function isInStrictMode() {
+  const start = this.isProgram() ? this : this.parentPath;
+  const strictParent = start.find(path => {
+    if (path.isProgram({
+      sourceType: "module"
+    })) return true;
+    if (path.isClass()) return true;
+    if (!path.isProgram() && !path.isFunction()) return false;
+
+    if (path.isArrowFunctionExpression() && !path.get("body").isBlockStatement()) {
+      return false;
+    }
+
+    let {
+      node
+    } = path;
+    if (path.isFunction()) node = node.body;
+
+    for (const directive of node.directives) {
+      if (directive.value.value === "use strict") {
+        return true;
+      }
+    }
+  });
+  return !!strictParent;
 }