@babel/traverse 7.0.0-beta.43 → 7.0.0-beta.44

package/lib/path/index.js

@@ -7,10 +7,10 @@ exports.default = void 0;
 
 var virtualTypes = _interopRequireWildcard(require("./lib/virtual-types"));
 
-function _debug() {
-  const data = _interopRequireDefault(require("debug"));
+function _debug2() {
+  var data = _interopRequireDefault(require("debug"));
 
-  _debug = function () {
+  _debug2 = function _debug2() {
     return data;
   };
 
@@ -18,9 +18,9 @@ function _debug() {
 }
 
 function _invariant() {
-  const data = _interopRequireDefault(require("invariant"));
+  var data = _interopRequireDefault(require("invariant"));
 
-  _invariant = function () {
+  _invariant = function _invariant() {
     return data;
   };
 
@@ -32,9 +32,9 @@ var _index = _interopRequireDefault(require("../index"));
 var _scope = _interopRequireDefault(require("../scope"));
 
 function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+  var data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
+  t = function t() {
     return data;
   };
 
@@ -44,9 +44,9 @@ function t() {
 var _cache = require("../cache");
 
 function _generator() {
-  const data = _interopRequireDefault(require("@babel/generator"));
+  var data = _interopRequireDefault(require("@babel/generator"));
 
-  _generator = function () {
+  _generator = function _generator() {
     return data;
   };
 
@@ -79,10 +79,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 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 debug = (0, _debug().default)("babel");
+var _debug = (0, _debug2().default)("babel");
 
-class NodePath {
-  constructor(hub, parent) {
+var NodePath = function () {
+  function NodePath(hub, parent) {
     this.parent = parent;
     this.hub = hub;
     this.contexts = [];
@@ -106,30 +106,30 @@ class NodePath {
     this.typeAnnotation = null;
   }
 
-  static get({
-    hub,
-    parentPath,
-    parent,
-    container,
-    listKey,
-    key
-  }) {
+  NodePath.get = function get(_ref) {
+    var hub = _ref.hub,
+        parentPath = _ref.parentPath,
+        parent = _ref.parent,
+        container = _ref.container,
+        listKey = _ref.listKey,
+        key = _ref.key;
+
     if (!hub && parentPath) {
       hub = parentPath.hub;
     }
 
     (0, _invariant().default)(parent, "To get a node path the parent needs to exist");
-    const targetNode = container[key];
-    const paths = _cache.path.get(parent) || [];
+    var targetNode = container[key];
+    var paths = _cache.path.get(parent) || [];
 
     if (!_cache.path.has(parent)) {
       _cache.path.set(parent, paths);
     }
 
-    let path;
+    var path;
 
-    for (let i = 0; i < paths.length; i++) {
-      const pathCheck = paths[i];
+    for (var i = 0; i < paths.length; i++) {
+      var pathCheck = paths[i];
 
       if (pathCheck.node === targetNode) {
         path = pathCheck;
@@ -144,82 +144,102 @@ class NodePath {
 
     path.setup(parentPath, container, listKey, key);
     return path;
-  }
+  };
+
+  var _proto = NodePath.prototype;
 
-  getScope(scope) {
+  _proto.getScope = function getScope(scope) {
     return this.isScope() ? new _scope.default(this) : scope;
-  }
+  };
 
-  setData(key, val) {
+  _proto.setData = function setData(key, val) {
     return this.data[key] = val;
-  }
+  };
 
-  getData(key, def) {
-    let val = this.data[key];
+  _proto.getData = function getData(key, def) {
+    var 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);
-  }
+  };
 
-  traverse(visitor, state) {
+  _proto.traverse = function traverse(visitor, state) {
     (0, _index.default)(this.node, visitor, this.scope, state, this);
-  }
+  };
 
-  set(key, node) {
+  _proto.set = function set(key, node) {
     t().validate(this.node, key, node);
     this.node[key] = node;
-  }
+  };
 
-  getPathLocation() {
-    const parts = [];
-    let path = this;
+  _proto.getPathLocation = function getPathLocation() {
+    var parts = [];
+    var path = this;
 
     do {
-      let key = path.key;
-      if (path.inList) key = `${path.listKey}[${key}]`;
+      var key = path.key;
+      if (path.inList) key = path.listKey + "[" + key + "]";
       parts.unshift(key);
     } while (path = path.parentPath);
 
     return parts.join(".");
-  }
+  };
 
-  debug(message) {
-    if (!debug.enabled) return;
-    debug(`${this.getPathLocation()} ${this.type}: ${message}`);
-  }
+  _proto.debug = function debug(message) {
+    if (!_debug.enabled) return;
+
+    _debug(this.getPathLocation() + " " + this.type + ": " + message);
+  };
 
-  toString() {
+  _proto.toString = function 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 _arr = t().TYPES;
 
-for (const type of t().TYPES) {
-  const typeKey = `is${type}`;
+var _loop2 = function _loop2() {
+  var type = _arr[_i];
+  var typeKey = "is" + type;
 
   NodePath.prototype[typeKey] = function (opts) {
     return t()[typeKey](this.node, opts);
   };
 
-  NodePath.prototype[`assert${type}`] = function (opts) {
+  NodePath.prototype["assert" + type] = function (opts) {
     if (!this[typeKey](opts)) {
-      throw new TypeError(`Expected node path of type ${type}`);
+      throw new TypeError("Expected node path of type " + type);
     }
   };
+};
+
+for (var _i = 0; _i < _arr.length; _i++) {
+  _loop2();
 }
 
-for (const type in virtualTypes) {
-  if (type[0] === "_") continue;
+var _loop = function _loop(type) {
+  if (type[0] === "_") return "continue";
   if (t().TYPES.indexOf(type) < 0) t().TYPES.push(type);
-  const virtualType = virtualTypes[type];
+  var 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 = _loop(type);
+
+  if (_ret === "continue") continue;
 }

package/lib/path/inference/index.js

@@ -13,9 +13,9 @@ exports.isGenericType = isGenericType;
 var inferers = _interopRequireWildcard(require("./inferers"));
 
 function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+  var data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
+  t = function t() {
     return data;
   };
 
@@ -26,18 +26,18 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function getTypeAnnotation() {
   if (this.typeAnnotation) return this.typeAnnotation;
-  let type = this._getTypeAnnotation() || t().anyTypeAnnotation();
+  var type = this._getTypeAnnotation() || t().anyTypeAnnotation();
   if (t().isTypeAnnotation(type)) type = type.typeAnnotation;
   return this.typeAnnotation = type;
 }
 
 function _getTypeAnnotation() {
-  const node = this.node;
+  var node = this.node;
 
   if (!node) {
     if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
-      const declar = this.parentPath.parentPath;
-      const declarParent = declar.parentPath;
+      var declar = this.parentPath.parentPath;
+      var declarParent = declar.parentPath;
 
       if (declar.key === "left" && declarParent.isForInStatement()) {
         return t().stringTypeAnnotation();
@@ -57,7 +57,7 @@ function _getTypeAnnotation() {
     return node.typeAnnotation;
   }
 
-  let inferer = inferers[node.type];
+  var inferer = inferers[node.type];
 
   if (inferer) {
     return inferer.call(this, node);
@@ -93,17 +93,21 @@ function _isBaseType(baseName, type, soft) {
     if (soft) {
       return false;
     } else {
-      throw new Error(`Unknown base type ${baseName}`);
+      throw new Error("Unknown base type " + baseName);
     }
   }
 }
 
 function couldBeBaseType(name) {
-  const type = this.getTypeAnnotation();
+  var type = this.getTypeAnnotation();
   if (t().isAnyTypeAnnotation(type)) return true;
 
   if (t().isUnionTypeAnnotation(type)) {
-    for (const type2 of type.types) {
+    var _arr = type.types;
+
+    for (var _i = 0; _i < _arr.length; _i++) {
+      var type2 = _arr[_i];
+
       if (t().isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
         return true;
       }
@@ -116,7 +120,7 @@ function couldBeBaseType(name) {
 }
 
 function baseTypeStrictlyMatches(right) {
-  const left = this.getTypeAnnotation();
+  var left = this.getTypeAnnotation();
   right = right.getTypeAnnotation();
 
   if (!t().isAnyTypeAnnotation(left) && t().isFlowBaseAnnotation(left)) {
@@ -125,7 +129,7 @@ function baseTypeStrictlyMatches(right) {
 }
 
 function isGenericType(genericName) {
-  const type = this.getTypeAnnotation();
+  var type = this.getTypeAnnotation();
   return t().isGenericTypeAnnotation(type) && t().isIdentifier(type.id, {
     name: genericName
   });

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

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = _default;
 
 function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+  var data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
+  t = function t() {
     return data;
   };
 
@@ -19,7 +19,7 @@ function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj;
 
 function _default(node) {
   if (!this.isReferenced()) return;
-  const binding = this.scope.getBinding(node.name);
+  var binding = this.scope.getBinding(node.name);
 
   if (binding) {
     if (binding.identifier.typeAnnotation) {
@@ -37,21 +37,25 @@ function _default(node) {
 }
 
 function getTypeAnnotationBindingConstantViolations(binding, path, name) {
-  const types = [];
-  const functionConstantViolations = [];
-  let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
-  const testType = getConditionalAnnotation(binding, path, name);
+  var types = [];
+  var functionConstantViolations = [];
+  var constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
+  var testType = getConditionalAnnotation(binding, path, name);
 
   if (testType) {
-    const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
-    constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0);
+    var testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+    constantViolations = constantViolations.filter(function (path) {
+      return testConstantViolations.indexOf(path) < 0;
+    });
     types.push(testType.typeAnnotation);
   }
 
   if (constantViolations.length) {
     constantViolations = constantViolations.concat(functionConstantViolations);
+    var _arr = constantViolations;
 
-    for (const violation of constantViolations) {
+    for (var _i = 0; _i < _arr.length; _i++) {
+      var violation = _arr[_i];
       types.push(violation.getTypeAnnotation());
     }
   }
@@ -62,12 +66,12 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
 }
 
 function getConstantViolationsBefore(binding, path, functions) {
-  const violations = binding.constantViolations.slice();
+  var violations = binding.constantViolations.slice();
   violations.unshift(binding.path);
-  return violations.filter(violation => {
+  return violations.filter(function (violation) {
     violation = violation.resolve();
 
-    const status = violation._guessExecutionStatusRelativeTo(path);
+    var status = violation._guessExecutionStatusRelativeTo(path);
 
     if (functions && status === "function") functions.push(violation);
     return status === "before";
@@ -75,17 +79,17 @@ function getConstantViolationsBefore(binding, path, functions) {
 }
 
 function inferAnnotationFromBinaryExpression(name, path) {
-  const operator = path.node.operator;
-  const right = path.get("right").resolve();
-  const left = path.get("left").resolve();
-  let target;
+  var operator = path.node.operator;
+  var right = path.get("right").resolve();
+  var left = path.get("left").resolve();
+  var target;
 
   if (left.isIdentifier({
-    name
+    name: name
   })) {
     target = right;
   } else if (right.isIdentifier({
-    name
+    name: name
   })) {
     target = left;
   }
@@ -103,8 +107,8 @@ function inferAnnotationFromBinaryExpression(name, path) {
   }
 
   if (operator !== "===" && operator !== "==") return;
-  let typeofPath;
-  let typePath;
+  var typeofPath;
+  var typePath;
 
   if (left.isUnaryExpression({
     operator: "typeof"
@@ -120,17 +124,17 @@ function inferAnnotationFromBinaryExpression(name, path) {
 
   if (!typeofPath) return;
   if (!typeofPath.get("argument").isIdentifier({
-    name
+    name: name
   })) return;
   typePath = typePath.resolve();
   if (!typePath.isLiteral()) return;
-  const typeValue = typePath.node.value;
+  var typeValue = typePath.node.value;
   if (typeof typeValue !== "string") return;
   return t().createTypeAnnotationBasedOnTypeof(typeValue);
 }
 
 function getParentConditionalPath(binding, path, name) {
-  let parentPath;
+  var parentPath;
 
   while (parentPath = path.parentPath) {
     if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
@@ -150,22 +154,22 @@ function getParentConditionalPath(binding, path, name) {
 }
 
 function getConditionalAnnotation(binding, path, name) {
-  const ifStatement = getParentConditionalPath(binding, path, name);
+  var ifStatement = getParentConditionalPath(binding, path, name);
   if (!ifStatement) return;
-  const test = ifStatement.get("test");
-  const paths = [test];
-  const types = [];
+  var test = ifStatement.get("test");
+  var paths = [test];
+  var types = [];
 
-  for (let i = 0; i < paths.length; i++) {
-    const path = paths[i];
+  for (var i = 0; i < paths.length; i++) {
+    var _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()) {
-      const type = inferAnnotationFromBinaryExpression(name, path);
+    } else if (_path.isBinaryExpression()) {
+      var type = inferAnnotationFromBinaryExpression(name, _path);
       if (type) types.push(type);
     }
   }
@@ -173,7 +177,7 @@ function getConditionalAnnotation(binding, path, name) {
   if (types.length) {
     return {
       typeAnnotation: t().createUnionTypeAnnotation(types),
-      ifStatement
+      ifStatement: ifStatement
     };
   }
 

package/lib/path/inference/inferers.js

@@ -27,15 +27,15 @@ exports.CallExpression = CallExpression;
 exports.TaggedTemplateExpression = TaggedTemplateExpression;
 Object.defineProperty(exports, "Identifier", {
   enumerable: true,
-  get: function () {
+  get: function get() {
     return _infererReference.default;
   }
 });
 
 function t() {
-  const data = _interopRequireWildcard(require("@babel/types"));
+  var data = _interopRequireWildcard(require("@babel/types"));
 
-  t = function () {
+  t = function t() {
     return data;
   };
 
@@ -49,10 +49,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 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() {
-  const id = this.get("id");
+  var id = this.get("id");
   if (!id.isIdentifier()) return;
-  const init = this.get("init");
-  let type = init.getTypeAnnotation();
+  var init = this.get("init");
+  var type = init.getTypeAnnotation();
 
   if (type && type.type === "AnyTypeAnnotation") {
     if (init.isCallExpression() && init.get("callee").isIdentifier({
@@ -82,7 +82,7 @@ function TemplateLiteral() {
 }
 
 function UnaryExpression(node) {
-  const operator = node.operator;
+  var operator = node.operator;
 
   if (operator === "void") {
     return t().voidTypeAnnotation();
@@ -96,15 +96,15 @@ function UnaryExpression(node) {
 }
 
 function BinaryExpression(node) {
-  const operator = node.operator;
+  var 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();
   } else if (operator === "+") {
-    const right = this.get("right");
-    const left = this.get("left");
+    var right = this.get("right");
+    var left = this.get("left");
 
     if (left.isBaseType("number") && right.isBaseType("number")) {
       return t().numberTypeAnnotation();
@@ -133,7 +133,7 @@ function AssignmentExpression() {
 }
 
 function UpdateExpression(node) {
-  const operator = node.operator;
+  var operator = node.operator;
 
   if (operator === "++" || operator === "--") {
     return t().numberTypeAnnotation();
@@ -178,15 +178,13 @@ function Func() {
   return t().genericTypeAnnotation(t().identifier("Function"));
 }
 
-const isArrayFrom = t().buildMatchMemberExpression("Array.from");
-const isObjectKeys = t().buildMatchMemberExpression("Object.keys");
-const isObjectValues = t().buildMatchMemberExpression("Object.values");
-const isObjectEntries = t().buildMatchMemberExpression("Object.entries");
+var isArrayFrom = t().buildMatchMemberExpression("Array.from");
+var isObjectKeys = t().buildMatchMemberExpression("Object.keys");
+var isObjectValues = t().buildMatchMemberExpression("Object.values");
+var isObjectEntries = t().buildMatchMemberExpression("Object.entries");
 
 function CallExpression() {
-  const {
-    callee
-  } = this.node;
+  var callee = this.node.callee;
 
   if (isObjectKeys(callee)) {
     return t().arrayTypeAnnotation(t().stringTypeAnnotation());