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

package/lib/path/index.js

@@ -1,22 +1,58 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.default = void 0;
 
 var virtualTypes = _interopRequireWildcard(require("./lib/virtual-types"));
 
-var _debug2 = _interopRequireDefault(require("debug"));
+function _debug() {
+  const data = _interopRequireDefault(require("debug"));
 
-var _invariant = _interopRequireDefault(require("invariant"));
+  _debug = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _invariant() {
+  const data = _interopRequireDefault(require("invariant"));
+
+  _invariant = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _index = _interopRequireDefault(require("../index"));
 
 var _scope = _interopRequireDefault(require("../scope"));
 
-var t = _interopRequireWildcard(require("@babel/types"));
+function t() {
+  const data = _interopRequireWildcard(require("@babel/types"));
+
+  t = function () {
+    return data;
+  };
+
+  return data;
+}
 
 var _cache = require("../cache");
 
+function _generator() {
+  const data = _interopRequireDefault(require("@babel/generator"));
+
+  _generator = function () {
+    return data;
+  };
+
+  return data;
+}
+
 var NodePath_ancestry = _interopRequireWildcard(require("./ancestry"));
 
 var NodePath_inference = _interopRequireWildcard(require("./inference"));
@@ -41,12 +77,12 @@ var NodePath_comments = _interopRequireWildcard(require("./comments"));
 
 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; } }
 
-var _debug = (0, _debug2.default)("babel");
+const debug = (0, _debug().default)("babel");
 
-var NodePath = function () {
-  function NodePath(hub, parent) {
+class NodePath {
+  constructor(hub, parent) {
     this.parent = parent;
     this.hub = hub;
     this.contexts = [];
@@ -70,30 +106,30 @@ var NodePath = function () {
     this.typeAnnotation = null;
   }
 
-  NodePath.get = function get(_ref) {
-    var hub = _ref.hub,
-        parentPath = _ref.parentPath,
-        parent = _ref.parent,
-        container = _ref.container,
-        listKey = _ref.listKey,
-        key = _ref.key;
-
+  static get({
+    hub,
+    parentPath,
+    parent,
+    container,
+    listKey,
+    key
+  }) {
     if (!hub && parentPath) {
       hub = parentPath.hub;
     }
 
-    (0, _invariant.default)(parent, "To get a node path the parent needs to exist");
-    var targetNode = container[key];
-    var paths = _cache.path.get(parent) || [];
+    (0, _invariant().default)(parent, "To get a node path the parent needs to exist");
+    const targetNode = container[key];
+    const paths = _cache.path.get(parent) || [];
 
     if (!_cache.path.has(parent)) {
       _cache.path.set(parent, paths);
     }
 
-    var path;
+    let path;
 
-    for (var i = 0; i < paths.length; i++) {
-      var pathCheck = paths[i];
+    for (let i = 0; i < paths.length; i++) {
+      const pathCheck = paths[i];
 
       if (pathCheck.node === targetNode) {
         path = pathCheck;
@@ -108,100 +144,83 @@ var NodePath = function () {
 
     path.setup(parentPath, container, listKey, key);
     return path;
-  };
-
-  var _proto = NodePath.prototype;
+  }
 
-  _proto.getScope = function getScope(scope) {
+  getScope(scope) {
     return this.isScope() ? new _scope.default(this) : scope;
-  };
+  }
 
-  _proto.setData = function setData(key, val) {
+  setData(key, val) {
     return this.data[key] = val;
-  };
+  }
 
-  _proto.getData = function getData(key, def) {
-    var val = this.data[key];
+  getData(key, def) {
+    let val = this.data[key];
     if (!val && def) val = this.data[key] = def;
     return val;
-  };
-
-  _proto.buildCodeFrameError = function buildCodeFrameError(msg, Error) {
-    if (Error === void 0) {
-      Error = SyntaxError;
-    }
+  }
 
+  buildCodeFrameError(msg, Error = SyntaxError) {
     return this.hub.file.buildCodeFrameError(this.node, msg, Error);
-  };
+  }
 
-  _proto.traverse = function traverse(visitor, state) {
+  traverse(visitor, state) {
     (0, _index.default)(this.node, visitor, this.scope, state, this);
-  };
+  }
 
-  _proto.set = function set(key, node) {
-    t.validate(this.node, key, node);
+  set(key, node) {
+    t().validate(this.node, key, node);
     this.node[key] = node;
-  };
+  }
 
-  _proto.getPathLocation = function getPathLocation() {
-    var parts = [];
-    var path = this;
+  getPathLocation() {
+    const parts = [];
+    let path = this;
 
     do {
-      var key = path.key;
-      if (path.inList) key = path.listKey + "[" + key + "]";
+      let key = path.key;
+      if (path.inList) key = `${path.listKey}[${key}]`;
       parts.unshift(key);
     } while (path = path.parentPath);
 
     return parts.join(".");
-  };
+  }
 
-  _proto.debug = function debug(message) {
-    if (!_debug.enabled) return;
+  debug(message) {
+    if (!debug.enabled) return;
+    debug(`${this.getPathLocation()} ${this.type}: ${message}`);
+  }
 
-    _debug(this.getPathLocation() + " " + this.type + ": " + message);
-  };
+  toString() {
+    return (0, _generator().default)(this.node).code;
+  }
 
-  return NodePath;
-}();
+}
 
 exports.default = NodePath;
 Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePath_replacement, NodePath_evaluation, NodePath_conversion, NodePath_introspection, NodePath_context, NodePath_removal, NodePath_modification, NodePath_family, NodePath_comments);
 
-var _loop = function _loop(type) {
-  var typeKey = "is" + type;
+for (const type of t().TYPES) {
+  const typeKey = `is${type}`;
+  const fn = t()[typeKey];
 
   NodePath.prototype[typeKey] = function (opts) {
-    return t[typeKey](this.node, opts);
+    return fn(this.node, opts);
   };
 
-  NodePath.prototype["assert" + type] = function (opts) {
-    if (!this[typeKey](opts)) {
-      throw new TypeError("Expected node path of type " + type);
+  NodePath.prototype[`assert${type}`] = function (opts) {
+    if (!fn(this.node, opts)) {
+      throw new TypeError(`Expected node path of type ${type}`);
     }
   };
-};
-
-var _arr = t.TYPES;
-
-for (var _i = 0; _i < _arr.length; _i++) {
-  var type = _arr[_i];
-
-  _loop(type);
 }
 
-var _loop2 = function _loop2(type) {
-  if (type[0] === "_") return "continue";
-  if (t.TYPES.indexOf(type) < 0) t.TYPES.push(type);
-  var virtualType = virtualTypes[type];
+for (const type in virtualTypes) {
+  if (type[0] === "_") continue;
+  if (t().TYPES.indexOf(type) < 0) t().TYPES.push(type);
+  const virtualType = virtualTypes[type];
 
-  NodePath.prototype["is" + type] = function (opts) {
+  NodePath.prototype[`is${type}`] = function (opts) {
     return virtualType.checkPath(this, opts);
   };
-};
-
-for (var type in virtualTypes) {
-  var _ret = _loop2(type);
-
-  if (_ret === "continue") continue;
 }

package/lib/path/inference/index.js

@@ -1,6 +1,8 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.getTypeAnnotation = getTypeAnnotation;
 exports._getTypeAnnotation = _getTypeAnnotation;
 exports.isBaseType = isBaseType;
@@ -10,34 +12,42 @@ exports.isGenericType = isGenericType;
 
 var inferers = _interopRequireWildcard(require("./inferers"));
 
-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; } }
 
 function getTypeAnnotation() {
   if (this.typeAnnotation) return this.typeAnnotation;
-  var type = this._getTypeAnnotation() || t.anyTypeAnnotation();
-  if (t.isTypeAnnotation(type)) type = type.typeAnnotation;
+  let type = this._getTypeAnnotation() || t().anyTypeAnnotation();
+  if (t().isTypeAnnotation(type)) type = type.typeAnnotation;
   return this.typeAnnotation = type;
 }
 
 function _getTypeAnnotation() {
-  var node = this.node;
+  const node = this.node;
 
   if (!node) {
     if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
-      var declar = this.parentPath.parentPath;
-      var declarParent = declar.parentPath;
+      const declar = this.parentPath.parentPath;
+      const declarParent = declar.parentPath;
 
       if (declar.key === "left" && declarParent.isForInStatement()) {
-        return t.stringTypeAnnotation();
+        return t().stringTypeAnnotation();
       }
 
       if (declar.key === "left" && declarParent.isForOfStatement()) {
-        return t.anyTypeAnnotation();
+        return t().anyTypeAnnotation();
       }
 
-      return t.voidTypeAnnotation();
+      return t().voidTypeAnnotation();
     } else {
       return;
     }
@@ -47,7 +57,7 @@ function _getTypeAnnotation() {
     return node.typeAnnotation;
   }
 
-  var inferer = inferers[node.type];
+  let inferer = inferers[node.type];
 
   if (inferer) {
     return inferer.call(this, node);
@@ -66,39 +76,35 @@ function isBaseType(baseName, soft) {
 
 function _isBaseType(baseName, type, soft) {
   if (baseName === "string") {
-    return t.isStringTypeAnnotation(type);
+    return t().isStringTypeAnnotation(type);
   } else if (baseName === "number") {
-    return t.isNumberTypeAnnotation(type);
+    return t().isNumberTypeAnnotation(type);
   } else if (baseName === "boolean") {
-    return t.isBooleanTypeAnnotation(type);
+    return t().isBooleanTypeAnnotation(type);
   } else if (baseName === "any") {
-    return t.isAnyTypeAnnotation(type);
+    return t().isAnyTypeAnnotation(type);
   } else if (baseName === "mixed") {
-    return t.isMixedTypeAnnotation(type);
+    return t().isMixedTypeAnnotation(type);
   } else if (baseName === "empty") {
-    return t.isEmptyTypeAnnotation(type);
+    return t().isEmptyTypeAnnotation(type);
   } else if (baseName === "void") {
-    return t.isVoidTypeAnnotation(type);
+    return t().isVoidTypeAnnotation(type);
   } else {
     if (soft) {
       return false;
     } else {
-      throw new Error("Unknown base type " + baseName);
+      throw new Error(`Unknown base type ${baseName}`);
     }
   }
 }
 
 function couldBeBaseType(name) {
-  var type = this.getTypeAnnotation();
-  if (t.isAnyTypeAnnotation(type)) return true;
-
-  if (t.isUnionTypeAnnotation(type)) {
-    var _arr = type.types;
-
-    for (var _i = 0; _i < _arr.length; _i++) {
-      var type2 = _arr[_i];
+  const type = this.getTypeAnnotation();
+  if (t().isAnyTypeAnnotation(type)) return true;
 
-      if (t.isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
+  if (t().isUnionTypeAnnotation(type)) {
+    for (const type2 of type.types) {
+      if (t().isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
         return true;
       }
     }
@@ -110,17 +116,17 @@ function couldBeBaseType(name) {
 }
 
 function baseTypeStrictlyMatches(right) {
-  var left = this.getTypeAnnotation();
+  const left = this.getTypeAnnotation();
   right = right.getTypeAnnotation();
 
-  if (!t.isAnyTypeAnnotation(left) && t.isFlowBaseAnnotation(left)) {
+  if (!t().isAnyTypeAnnotation(left) && t().isFlowBaseAnnotation(left)) {
     return right.type === left.type;
   }
 }
 
 function isGenericType(genericName) {
-  var type = this.getTypeAnnotation();
-  return t.isGenericTypeAnnotation(type) && t.isIdentifier(type.id, {
+  const type = this.getTypeAnnotation();
+  return t().isGenericTypeAnnotation(type) && t().isIdentifier(type.id, {
     name: genericName
   });
 }

package/lib/path/inference/inferer-reference.js

@@ -1,15 +1,25 @@
 "use strict";
 
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.default = _default;
 
-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; } }
 
 function _default(node) {
   if (!this.isReferenced()) return;
-  var binding = this.scope.getBinding(node.name);
+  const binding = this.scope.getBinding(node.name);
 
   if (binding) {
     if (binding.identifier.typeAnnotation) {
@@ -20,48 +30,44 @@ function _default(node) {
   }
 
   if (node.name === "undefined") {
-    return t.voidTypeAnnotation();
+    return t().voidTypeAnnotation();
   } else if (node.name === "NaN" || node.name === "Infinity") {
-    return t.numberTypeAnnotation();
+    return t().numberTypeAnnotation();
   } else if (node.name === "arguments") {}
 }
 
 function getTypeAnnotationBindingConstantViolations(binding, path, name) {
-  var types = [];
-  var functionConstantViolations = [];
-  var constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
-  var testType = getConditionalAnnotation(binding, path, name);
+  const types = [];
+  const functionConstantViolations = [];
+  let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
+  const testType = getConditionalAnnotation(binding, path, name);
 
   if (testType) {
-    var testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
-    constantViolations = constantViolations.filter(function (path) {
-      return testConstantViolations.indexOf(path) < 0;
-    });
+    const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+    constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0);
     types.push(testType.typeAnnotation);
   }
 
   if (constantViolations.length) {
     constantViolations = constantViolations.concat(functionConstantViolations);
-    var _arr = constantViolations;
 
-    for (var _i = 0; _i < _arr.length; _i++) {
-      var violation = _arr[_i];
+    for (const violation of constantViolations) {
       types.push(violation.getTypeAnnotation());
     }
   }
 
   if (types.length) {
-    return t.createUnionTypeAnnotation(types);
+    return t().createUnionTypeAnnotation(types);
   }
 }
 
 function getConstantViolationsBefore(binding, path, functions) {
-  var violations = binding.constantViolations.slice();
+  const violations = binding.constantViolations.slice();
   violations.unshift(binding.path);
-  return violations.filter(function (violation) {
+  return violations.filter(violation => {
     violation = violation.resolve();
 
-    var status = violation._guessExecutionStatusRelativeTo(path);
+    const status = violation._guessExecutionStatusRelativeTo(path);
 
     if (functions && status === "function") functions.push(violation);
     return status === "before";
@@ -69,17 +75,17 @@ function getConstantViolationsBefore(binding, path, functions) {
 }
 
 function inferAnnotationFromBinaryExpression(name, path) {
-  var operator = path.node.operator;
-  var right = path.get("right").resolve();
-  var left = path.get("left").resolve();
-  var target;
+  const operator = path.node.operator;
+  const right = path.get("right").resolve();
+  const left = path.get("left").resolve();
+  let target;
 
   if (left.isIdentifier({
-    name: name
+    name
   })) {
     target = right;
   } else if (right.isIdentifier({
-    name: name
+    name
   })) {
     target = left;
   }
@@ -89,16 +95,16 @@ function inferAnnotationFromBinaryExpression(name, path) {
       return target.getTypeAnnotation();
     }
 
-    if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
-      return t.numberTypeAnnotation();
+    if (t().BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
+      return t().numberTypeAnnotation();
     }
 
     return;
   }
 
   if (operator !== "===" && operator !== "==") return;
-  var typeofPath;
-  var typePath;
+  let typeofPath;
+  let typePath;
 
   if (left.isUnaryExpression({
     operator: "typeof"
@@ -114,17 +120,17 @@ function inferAnnotationFromBinaryExpression(name, path) {
 
   if (!typeofPath) return;
   if (!typeofPath.get("argument").isIdentifier({
-    name: name
+    name
   })) return;
   typePath = typePath.resolve();
   if (!typePath.isLiteral()) return;
-  var typeValue = typePath.node.value;
+  const typeValue = typePath.node.value;
   if (typeof typeValue !== "string") return;
-  return t.createTypeAnnotationBasedOnTypeof(typeValue);
+  return t().createTypeAnnotationBasedOnTypeof(typeValue);
 }
 
 function getParentConditionalPath(binding, path, name) {
-  var parentPath;
+  let parentPath;
 
   while (parentPath = path.parentPath) {
     if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
@@ -144,30 +150,30 @@ function getParentConditionalPath(binding, path, name) {
 }
 
 function getConditionalAnnotation(binding, path, name) {
-  var ifStatement = getParentConditionalPath(binding, path, name);
+  const ifStatement = getParentConditionalPath(binding, path, name);
   if (!ifStatement) return;
-  var test = ifStatement.get("test");
-  var paths = [test];
-  var types = [];
+  const test = ifStatement.get("test");
+  const paths = [test];
+  const types = [];
 
-  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.isLogicalExpression()) {
-      if (_path.node.operator === "&&") {
-        paths.push(_path.get("left"));
-        paths.push(_path.get("right"));
+    if (path.isLogicalExpression()) {
+      if (path.node.operator === "&&") {
+        paths.push(path.get("left"));
+        paths.push(path.get("right"));
       }
-    } else if (_path.isBinaryExpression()) {
-      var type = inferAnnotationFromBinaryExpression(name, _path);
+    } else if (path.isBinaryExpression()) {
+      const type = inferAnnotationFromBinaryExpression(name, path);
       if (type) types.push(type);
     }
   }
 
   if (types.length) {
     return {
-      typeAnnotation: t.createUnionTypeAnnotation(types),
-      ifStatement: ifStatement
+      typeAnnotation: t().createUnionTypeAnnotation(types),
+      ifStatement
     };
   }