@babel/traverse 8.0.0-alpha.1 → 8.0.0-alpha.3

package/lib/index.js

@@ -30,24 +30,24 @@ const ForAwaitStatement = ["ForOfStatement"];
 
 var virtualTypes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  ReferencedIdentifier: ReferencedIdentifier,
-  ReferencedMemberExpression: ReferencedMemberExpression,
   BindingIdentifier: BindingIdentifier,
-  Statement: Statement,
-  Expression: Expression,
-  Scope: Scope$1,
-  Referenced: Referenced,
   BlockScoped: BlockScoped,
-  Var: Var,
-  User: User,
+  ExistentialTypeParam: ExistentialTypeParam,
+  Expression: Expression,
+  Flow: Flow,
+  ForAwaitStatement: ForAwaitStatement,
   Generated: Generated,
+  NumericLiteralTypeAnnotation: NumericLiteralTypeAnnotation,
   Pure: Pure,
-  Flow: Flow,
+  Referenced: Referenced,
+  ReferencedIdentifier: ReferencedIdentifier,
+  ReferencedMemberExpression: ReferencedMemberExpression,
   RestProperty: RestProperty,
+  Scope: Scope$1,
   SpreadProperty: SpreadProperty,
-  ExistentialTypeParam: ExistentialTypeParam,
-  NumericLiteralTypeAnnotation: NumericLiteralTypeAnnotation,
-  ForAwaitStatement: ForAwaitStatement
+  Statement: Statement,
+  User: User,
+  Var: Var
 });
 
 const {
@@ -257,32 +257,45 @@ function mergePair(dest, src) {
 
 var visitors = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  isExplodedVisitor: isExplodedVisitor,
   explode: explode,
-  verify: verify,
-  merge: merge
+  isExplodedVisitor: isExplodedVisitor,
+  merge: merge,
+  verify: verify
 });
 
-let path = new WeakMap();
+let pathsCache = new WeakMap();
 let scope = new WeakMap();
 function clear() {
   clearPath();
   clearScope();
 }
 function clearPath() {
-  path = new WeakMap();
+  pathsCache = new WeakMap();
 }
 function clearScope() {
   scope = new WeakMap();
 }
+const nullHub = Object.freeze({});
+function getCachedPaths(hub, parent) {
+  return pathsCache.get(hub ?? nullHub)?.get(parent);
+}
+function getOrCreateCachedPaths(hub, parent) {
+  let parents = pathsCache.get(hub ?? nullHub);
+  if (!parents) pathsCache.set(hub ?? nullHub, parents = new WeakMap());
+  let paths = parents.get(parent);
+  if (!paths) parents.set(parent, paths = new Map());
+  return paths;
+}
 
 var cache = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  get path () { return path; },
-  get scope () { return scope; },
   clear: clear,
   clearPath: clearPath,
-  clearScope: clearScope
+  clearScope: clearScope,
+  getCachedPaths: getCachedPaths,
+  getOrCreateCachedPaths: getOrCreateCachedPaths,
+  get path () { return pathsCache; },
+  get scope () { return scope; }
 });
 
 const renameVisitor = {
@@ -399,9 +412,7 @@ class Binding {
     this.scope = scope;
     this.path = path;
     this.kind = kind;
-    if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path || (() => {
-      throw new Error("Internal Babel error: unreachable ");
-    })())) {
+    if ((kind === "var" || kind === "hoisted") && isDeclaredInLoop(path)) {
       this.reassign(path);
     }
     this.clearValue();
@@ -496,7 +507,6 @@ const {
   memberExpression: memberExpression$1,
   numericLiteral: numericLiteral$2,
   toIdentifier,
-  unaryExpression: unaryExpression$2,
   variableDeclaration: variableDeclaration$1,
   variableDeclarator: variableDeclarator$1,
   isRecordExpression,
@@ -505,7 +515,8 @@ const {
   isTopicReference,
   isMetaProperty,
   isPrivateName,
-  isExportDeclaration: isExportDeclaration$1
+  isExportDeclaration: isExportDeclaration$1,
+  buildUndefinedNode
 } = _t;
 function gatherNodeParts(node, parts) {
   switch (node?.type) {
@@ -955,7 +966,7 @@ class Scope {
     }
   }
   buildUndefinedNode() {
-    return unaryExpression$2("void", numericLiteral$2(0), true);
+    return buildUndefinedNode();
   }
   registerConstantViolation(path) {
     const ids = path.getBindingIdentifiers();
@@ -1448,16 +1459,16 @@ function inType(...candidateTypes) {
 
 var NodePath_ancestry = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  findParent: findParent,
   find: find,
+  findParent: findParent,
+  getAncestry: getAncestry,
+  getDeepestCommonAncestorFrom: getDeepestCommonAncestorFrom,
+  getEarliestCommonAncestorFrom: getEarliestCommonAncestorFrom,
   getFunctionParent: getFunctionParent,
   getStatementParent: getStatementParent,
-  getEarliestCommonAncestorFrom: getEarliestCommonAncestorFrom,
-  getDeepestCommonAncestorFrom: getDeepestCommonAncestorFrom,
-  getAncestry: getAncestry,
+  inType: inType,
   isAncestor: isAncestor,
-  isDescendant: isDescendant,
-  inType: inType
+  isDescendant: isDescendant
 });
 
 const {
@@ -1789,36 +1800,36 @@ function resolveCall(callee) {
 
 var inferers = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  VariableDeclarator: VariableDeclarator,
-  TypeCastExpression: TypeCastExpression,
-  TSAsExpression: TSAsExpression,
-  TSNonNullExpression: TSNonNullExpression,
-  NewExpression: NewExpression,
-  TemplateLiteral: TemplateLiteral,
-  UnaryExpression: UnaryExpression,
-  BinaryExpression: BinaryExpression,
-  LogicalExpression: LogicalExpression,
-  ConditionalExpression: ConditionalExpression,
-  SequenceExpression: SequenceExpression,
-  ParenthesizedExpression: ParenthesizedExpression,
+  ArrayExpression: ArrayExpression,
+  ArrowFunctionExpression: Func,
   AssignmentExpression: AssignmentExpression,
-  UpdateExpression: UpdateExpression,
-  StringLiteral: StringLiteral,
-  NumericLiteral: NumericLiteral,
+  BinaryExpression: BinaryExpression,
   BooleanLiteral: BooleanLiteral,
+  CallExpression: CallExpression,
+  ClassDeclaration: Func,
+  ClassExpression: Func,
+  ConditionalExpression: ConditionalExpression,
+  FunctionDeclaration: Func,
+  FunctionExpression: Func,
+  Identifier: infererReference,
+  LogicalExpression: LogicalExpression,
+  NewExpression: NewExpression,
   NullLiteral: NullLiteral,
-  RegExpLiteral: RegExpLiteral,
+  NumericLiteral: NumericLiteral,
   ObjectExpression: ObjectExpression,
-  ArrayExpression: ArrayExpression,
+  ParenthesizedExpression: ParenthesizedExpression,
+  RegExpLiteral: RegExpLiteral,
   RestElement: RestElement,
-  FunctionExpression: Func,
-  ArrowFunctionExpression: Func,
-  FunctionDeclaration: Func,
-  ClassExpression: Func,
-  ClassDeclaration: Func,
-  CallExpression: CallExpression,
+  SequenceExpression: SequenceExpression,
+  StringLiteral: StringLiteral,
+  TSAsExpression: TSAsExpression,
+  TSNonNullExpression: TSNonNullExpression,
   TaggedTemplateExpression: TaggedTemplateExpression,
-  Identifier: infererReference
+  TemplateLiteral: TemplateLiteral,
+  TypeCastExpression: TypeCastExpression,
+  UnaryExpression: UnaryExpression,
+  UpdateExpression: UpdateExpression,
+  VariableDeclarator: VariableDeclarator
 });
 
 const {
@@ -1957,11 +1968,11 @@ function isGenericType(genericName) {
 
 var NodePath_inference = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  getTypeAnnotation: getTypeAnnotation,
   _getTypeAnnotation: _getTypeAnnotation,
-  isBaseType: isBaseType,
-  couldBeBaseType: couldBeBaseType,
   baseTypeStrictlyMatches: baseTypeStrictlyMatches,
+  couldBeBaseType: couldBeBaseType,
+  getTypeAnnotation: getTypeAnnotation,
+  isBaseType: isBaseType,
   isGenericType: isGenericType
 });
 
@@ -1992,7 +2003,7 @@ function replaceWithMultiple(nodes) {
   nodes = this._verifyNodeList(nodes);
   inheritLeadingComments(nodes[0], this.node);
   inheritTrailingComments(nodes[nodes.length - 1], this.node);
-  path.get(this.parent)?.delete(this.node);
+  getCachedPaths(this.hub, this.parent)?.delete(this.node);
   this.node = this.container[this.key] = null;
   const paths = this.insertAfter(nodes);
   if (this.node) {
@@ -2079,7 +2090,7 @@ function _replaceWith(node) {
     validate$1(this.parent, this.key, node);
   }
   this.debug(`Replace with ${node?.type}`);
-  path.get(this.parent)?.set(node, this).delete(this.node);
+  getCachedPaths(this.hub, this.parent)?.set(node, this).delete(this.node);
   this.node = this.container[this.key] = node;
 }
 function replaceExpressionWithStatements(nodes) {
@@ -2151,18 +2162,22 @@ function replaceInline(nodes) {
 
 var NodePath_replacement = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  replaceWithMultiple: replaceWithMultiple,
-  replaceWithSourceString: replaceWithSourceString,
-  replaceWith: replaceWith,
   _replaceWith: _replaceWith,
   replaceExpressionWithStatements: replaceExpressionWithStatements,
-  replaceInline: replaceInline
+  replaceInline: replaceInline,
+  replaceWith: replaceWith,
+  replaceWithMultiple: replaceWithMultiple,
+  replaceWithSourceString: replaceWithSourceString
 });
 
-const VALID_CALLEES = ["String", "Number", "Math"];
+const VALID_OBJECT_CALLEES = ["Number", "String", "Math"];
+const VALID_IDENTIFIER_CALLEES = ["isFinite", "isNaN", "parseFloat", "parseInt", "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "btoa", "atob"];
 const INVALID_METHODS = ["random"];
-function isValidCallee(val) {
-  return VALID_CALLEES.includes(val);
+function isValidObjectCallee(val) {
+  return VALID_OBJECT_CALLEES.includes(val);
+}
+function isValidIdentifierCallee(val) {
+  return VALID_IDENTIFIER_CALLEES.includes(val);
 }
 function isInvalidMethod(val) {
   return INVALID_METHODS.includes(val);
@@ -2437,13 +2452,13 @@ function _evaluate(path, state) {
     const callee = path.get("callee");
     let context;
     let func;
-    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && isValidCallee(callee.node.name)) {
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && (isValidObjectCallee(callee.node.name) || isValidIdentifierCallee(callee.node.name))) {
       func = global[callee.node.name];
     }
     if (callee.isMemberExpression()) {
       const object = callee.get("object");
       const property = callee.get("property");
-      if (object.isIdentifier() && property.isIdentifier() && isValidCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
+      if (object.isIdentifier() && property.isIdentifier() && isValidObjectCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
         context = global[object.node.name];
         func = context[property.node.name];
       }
@@ -2493,8 +2508,8 @@ function evaluate() {
 
 var NodePath_evaluation = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  evaluateTruthy: evaluateTruthy,
-  evaluate: evaluate
+  evaluate: evaluate,
+  evaluateTruthy: evaluateTruthy
 });
 
 const {
@@ -2946,10 +2961,10 @@ function getScopeInformation(fnPath) {
 
 var NodePath_conversion = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  toComputedKey: toComputedKey,
+  arrowFunctionToExpression: arrowFunctionToExpression,
   ensureBlock: ensureBlock,
-  unwrapFunctionEnvironment: unwrapFunctionEnvironment,
-  arrowFunctionToExpression: arrowFunctionToExpression
+  toComputedKey: toComputedKey,
+  unwrapFunctionEnvironment: unwrapFunctionEnvironment
 });
 
 const {
@@ -3312,25 +3327,25 @@ function isInStrictMode() {
 
 var NodePath_introspection = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  matchesPattern: matchesPattern,
-  has: has,
-  isStatic: isStatic,
-  is: is,
-  isnt: isnt,
-  equals: equals,
-  isNodeType: isNodeType,
+  _guessExecutionStatusRelativeTo: _guessExecutionStatusRelativeTo,
+  _resolve: _resolve,
   canHaveVariableDeclarationOrExpression: canHaveVariableDeclarationOrExpression,
   canSwapBetweenExpressionAndStatement: canSwapBetweenExpressionAndStatement,
+  equals: equals,
+  getSource: getSource,
+  has: has,
+  is: is,
   isCompletionRecord: isCompletionRecord,
+  isConstantExpression: isConstantExpression,
+  isInStrictMode: isInStrictMode,
+  isNodeType: isNodeType,
   isStatementOrBlock: isStatementOrBlock,
+  isStatic: isStatic,
+  isnt: isnt,
+  matchesPattern: matchesPattern,
   referencesImport: referencesImport,
-  getSource: getSource,
-  willIMaybeExecuteBefore: willIMaybeExecuteBefore,
-  _guessExecutionStatusRelativeTo: _guessExecutionStatusRelativeTo,
   resolve: resolve,
-  _resolve: _resolve,
-  isConstantExpression: isConstantExpression,
-  isInStrictMode: isInStrictMode
+  willIMaybeExecuteBefore: willIMaybeExecuteBefore
 });
 
 function call(key) {
@@ -3525,27 +3540,27 @@ function _getQueueContexts() {
 
 var NodePath_context = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  call: call,
   _call: _call,
-  isDenylisted: isDenylisted,
-  isBlacklisted: isDenylisted,
-  visit: visit,
-  skip: skip,
-  skipKey: skipKey,
-  stop: stop,
-  setScope: setScope,
-  setContext: setContext,
-  resync: resync,
-  _resyncParent: _resyncParent,
+  _getQueueContexts: _getQueueContexts,
   _resyncKey: _resyncKey,
   _resyncList: _resyncList,
+  _resyncParent: _resyncParent,
   _resyncRemoved: _resyncRemoved,
+  call: call,
+  isBlacklisted: isDenylisted,
+  isDenylisted: isDenylisted,
   popContext: popContext,
   pushContext: pushContext,
-  setup: setup,
-  setKey: setKey,
   requeue: requeue,
-  _getQueueContexts: _getQueueContexts
+  resync: resync,
+  setContext: setContext,
+  setKey: setKey,
+  setScope: setScope,
+  setup: setup,
+  skip: skip,
+  skipKey: skipKey,
+  stop: stop,
+  visit: visit
 });
 
 const hooks = [function (self, parent) {
@@ -3611,7 +3626,9 @@ function _remove() {
 }
 function _markRemoved() {
   this._traverseFlags |= SHOULD_SKIP | REMOVED;
-  if (this.parent) path.get(this.parent).delete(this.node);
+  if (this.parent) {
+    getCachedPaths(this.hub, this.parent).delete(this.node);
+  }
   this.node = null;
 }
 function _assertUnremoved() {
@@ -3622,12 +3639,12 @@ function _assertUnremoved() {
 
 var NodePath_removal = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  remove: remove,
-  _removeFromScope: _removeFromScope,
+  _assertUnremoved: _assertUnremoved,
   _callRemovalHooks: _callRemovalHooks,
-  _remove: _remove,
   _markRemoved: _markRemoved,
-  _assertUnremoved: _assertUnremoved
+  _remove: _remove,
+  _removeFromScope: _removeFromScope,
+  remove: remove
 });
 
 const {
@@ -3932,7 +3949,7 @@ function insertAfter(nodes_) {
 }
 function updateSiblingKeys(fromIndex, incrementBy) {
   if (!this.parent) return;
-  const paths = path.get(this.parent);
+  const paths = getCachedPaths(this.hub, this.parent) || [];
   for (const [, path] of paths) {
     if (typeof path.key === "number" && path.key >= fromIndex) {
       path.key += incrementBy;
@@ -3997,16 +4014,16 @@ function hoist(scope = this.scope) {
 
 var NodePath_modification = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  insertBefore: insertBefore,
   _containerInsert: _containerInsert,
-  _containerInsertBefore: _containerInsertBefore,
   _containerInsertAfter: _containerInsertAfter,
-  insertAfter: insertAfter,
-  updateSiblingKeys: updateSiblingKeys,
+  _containerInsertBefore: _containerInsertBefore,
   _verifyNodeList: _verifyNodeList,
-  unshiftContainer: unshiftContainer,
+  hoist: hoist,
+  insertAfter: insertAfter,
+  insertBefore: insertBefore,
   pushContainer: pushContainer,
-  hoist: hoist
+  unshiftContainer: unshiftContainer,
+  updateSiblingKeys: updateSiblingKeys
 });
 
 const {
@@ -4325,20 +4342,20 @@ function getOuterBindingIdentifierPaths(duplicates = false) {
 
 var NodePath_family = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  getOpposite: getOpposite,
-  getCompletionRecords: getCompletionRecords,
-  getSibling: getSibling,
-  getPrevSibling: getPrevSibling,
-  getNextSibling: getNextSibling,
-  getAllNextSiblings: getAllNextSiblings,
-  getAllPrevSiblings: getAllPrevSiblings,
-  get: get,
   _getKey: _getKey,
   _getPattern: _getPattern,
+  get: get,
+  getAllNextSiblings: getAllNextSiblings,
+  getAllPrevSiblings: getAllPrevSiblings,
+  getBindingIdentifierPaths: getBindingIdentifierPaths,
   getBindingIdentifiers: getBindingIdentifiers,
+  getCompletionRecords: getCompletionRecords,
+  getNextSibling: getNextSibling,
+  getOpposite: getOpposite,
+  getOuterBindingIdentifierPaths: getOuterBindingIdentifierPaths,
   getOuterBindingIdentifiers: getOuterBindingIdentifiers,
-  getBindingIdentifierPaths: getBindingIdentifierPaths,
-  getOuterBindingIdentifierPaths: getOuterBindingIdentifierPaths
+  getPrevSibling: getPrevSibling,
+  getSibling: getSibling
 });
 
 const {
@@ -4387,9 +4404,9 @@ function addComments(type, comments) {
 
 var NodePath_comments = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  shareCommentsWithSiblings: shareCommentsWithSiblings,
   addComment: addComment,
-  addComments: addComments
+  addComments: addComments,
+  shareCommentsWithSiblings: shareCommentsWithSiblings
 });
 
 const {
@@ -4521,33 +4538,25 @@ function isForAwaitStatement() {
     await: true
   });
 }
-function isExistentialTypeParam() {
-  throw new Error("`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.");
-}
-function isNumericLiteralTypeAnnotation() {
-  throw new Error("`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.");
-}
 
 var NodePath_virtual_types_validator = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  isReferencedIdentifier: isReferencedIdentifier,
-  isReferencedMemberExpression: isReferencedMemberExpression,
   isBindingIdentifier: isBindingIdentifier,
-  isStatement: isStatement,
-  isExpression: isExpression,
-  isScope: isScope,
-  isReferenced: isReferenced,
   isBlockScoped: isBlockScoped,
-  isVar: isVar,
-  isUser: isUser,
+  isExpression: isExpression,
+  isFlow: isFlow,
+  isForAwaitStatement: isForAwaitStatement,
   isGenerated: isGenerated,
   isPure: isPure,
-  isFlow: isFlow,
+  isReferenced: isReferenced,
+  isReferencedIdentifier: isReferencedIdentifier,
+  isReferencedMemberExpression: isReferencedMemberExpression,
   isRestProperty: isRestProperty,
+  isScope: isScope,
   isSpreadProperty: isSpreadProperty,
-  isForAwaitStatement: isForAwaitStatement,
-  isExistentialTypeParam: isExistentialTypeParam,
-  isNumericLiteralTypeAnnotation: isNumericLiteralTypeAnnotation
+  isStatement: isStatement,
+  isUser: isUser,
+  isVar: isVar
 });
 
 const {
@@ -4591,18 +4600,14 @@ class NodePath {
       throw new Error("To get a node path the parent needs to exist");
     }
     const targetNode = container[key];
-    let paths = path.get(parent);
-    if (!paths) {
-      paths = new Map();
-      path.set(parent, paths);
-    }
-    let path$1 = paths.get(targetNode);
-    if (!path$1) {
-      path$1 = new NodePath(hub, parent);
-      if (targetNode) paths.set(targetNode, path$1);
+    const paths = getOrCreateCachedPaths(hub, parent);
+    let path = paths.get(targetNode);
+    if (!path) {
+      path = new NodePath(hub, parent);
+      if (targetNode) paths.set(targetNode, path);
     }
-    path$1.setup(parentPath, container, listKey, key);
-    return path$1;
+    path.setup(parentPath, container, listKey, key);
+    return path;
   }
   getScope(scope) {
     return this.isScope() ? new Scope(this) : scope;
@@ -4820,12 +4825,16 @@ class TraversalContext {
 const {
   VISITOR_KEYS: VISITOR_KEYS$1
 } = _t;
-function traverseNode(node, opts, scope, state, path, skipKeys) {
+function traverseNode(node, opts, scope, state, path, skipKeys, visitSelf) {
   const keys = VISITOR_KEYS$1[node.type];
   if (!keys) return false;
   const context = new TraversalContext(scope, opts, state, path);
+  if (visitSelf) {
+    if (skipKeys?.[path.parentKey]) return false;
+    return context.visitQueue([path]);
+  }
   for (const key of keys) {
-    if (skipKeys && skipKeys[key]) continue;
+    if (skipKeys?.[key]) continue;
     if (context.visit(node, key)) {
       return true;
     }
@@ -4849,18 +4858,21 @@ const {
   removeProperties,
   traverseFast
 } = _t;
-function traverse(parent, opts = {}, scope, state, parentPath) {
+function traverse(parent, opts = {}, scope, state, parentPath, visitSelf) {
   if (!parent) return;
   if (!opts.noScope && !scope) {
     if (parent.type !== "Program" && parent.type !== "File") {
       throw new Error("You must pass a scope and parentPath unless traversing a Program/File. " + `Instead of that you tried to traverse a ${parent.type} node without ` + "passing scope and parentPath.");
     }
   }
+  if (!parentPath && visitSelf) {
+    throw new Error("visitSelf can only be used when providing a NodePath.");
+  }
   if (!VISITOR_KEYS[parent.type]) {
     return;
   }
   explode(opts);
-  traverseNode(parent, opts, scope, state, parentPath);
+  traverseNode(parent, opts, scope, state, parentPath, null, visitSelf);
 }
 traverse.visitors = visitors;
 traverse.verify = verify;
@@ -4874,7 +4886,6 @@ traverse.node = function (node, opts, scope, state, path, skipKeys) {
 };
 traverse.clearNode = function (node, opts) {
   removeProperties(node, opts);
-  path.delete(node);
 };
 traverse.removeProperties = function (tree, opts) {
   traverseFast(tree, traverse.clearNode, opts);