@babel/traverse 7.18.0 → 7.18.6

package/lib/context.js

@@ -31,17 +31,19 @@ class TraversalContext {
     if (!(keys != null && keys.length)) return false;
 
     for (const key of keys) {
-      if (node[key]) return true;
+      if (node[key]) {
+        return true;
+      }
     }
 
     return false;
   }
 
-  create(node, obj, key, listKey) {
+  create(node, container, key, listKey) {
     return _path.default.get({
       parentPath: this.parentPath,
       parent: node,
-      container: obj,
+      container,
       key: key,
       listKey
     });

package/lib/path/context.js

@@ -129,7 +129,11 @@ function stop() {
 function setScope() {
   if (this.opts && this.opts.noScope) return;
   let path = this.parentPath;
-  if (this.key === "key" && path.isMethod()) path = path.parentPath;
+
+  if ((this.key === "key" || this.listKey === "decorators") && path.isMethod()) {
+    path = path.parentPath;
+  }
+
   let target;
 
   while (path && !target) {
@@ -177,7 +181,10 @@ function _resyncParent() {
 
 function _resyncKey() {
   if (!this.container) return;
-  if (this.node === this.container[this.key]) return;
+
+  if (this.node === this.container[this.key]) {
+    return;
+  }
 
   if (Array.isArray(this.container)) {
     for (let i = 0; i < this.container.length; i++) {

package/lib/path/conversion.js

@@ -251,10 +251,11 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
     const flatSuperProps = superProps.reduce((acc, superProp) => acc.concat(standardizeSuperProperty(superProp)), []);
     flatSuperProps.forEach(superProp => {
       const key = superProp.node.computed ? "" : superProp.get("property").node.name;
-      const isAssignment = superProp.parentPath.isAssignmentExpression({
+      const superParentPath = superProp.parentPath;
+      const isAssignment = superParentPath.isAssignmentExpression({
         left: superProp.node
       });
-      const isCall = superProp.parentPath.isCallExpression({
+      const isCall = superParentPath.isCallExpression({
         callee: superProp.node
       });
       const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
@@ -265,18 +266,18 @@ function hoistFunctionEnvironment(fnPath, noNewArrows = true, allowInsertArrow =
       }
 
       if (isAssignment) {
-        const value = superProp.parentPath.node.right;
+        const value = superParentPath.node.right;
         args.push(value);
       }
 
       const call = callExpression(identifier(superBinding), args);
 
       if (isCall) {
-        superProp.parentPath.unshiftContainer("arguments", thisExpression());
+        superParentPath.unshiftContainer("arguments", thisExpression());
         superProp.replaceWith(memberExpression(call, identifier("call")));
-        thisPaths.push(superProp.parentPath.get("arguments.0"));
+        thisPaths.push(superParentPath.get("arguments.0"));
       } else if (isAssignment) {
-        superProp.parentPath.replaceWith(call);
+        superParentPath.replaceWith(call);
       } else {
         superProp.replaceWith(call);
       }

package/lib/path/evaluation.js

@@ -8,6 +8,14 @@ exports.evaluateTruthy = evaluateTruthy;
 const VALID_CALLEES = ["String", "Number", "Math"];
 const INVALID_METHODS = ["random"];
 
+function isValidCallee(val) {
+  return VALID_CALLEES.includes(val);
+}
+
+function isInvalidMethod(val) {
+  return INVALID_METHODS.includes(val);
+}
+
 function evaluateTruthy() {
   const res = this.evaluate();
   if (res.confident) return !!res.value;
@@ -336,7 +344,7 @@ function _evaluate(path, state) {
     let context;
     let func;
 
-    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && VALID_CALLEES.indexOf(callee.node.name) >= 0) {
+    if (callee.isIdentifier() && !path.scope.getBinding(callee.node.name) && isValidCallee(callee.node.name)) {
       func = global[callee.node.name];
     }
 
@@ -344,7 +352,7 @@ function _evaluate(path, state) {
       const object = callee.get("object");
       const property = callee.get("property");
 
-      if (object.isIdentifier() && property.isIdentifier() && VALID_CALLEES.indexOf(object.node.name) >= 0 && INVALID_METHODS.indexOf(property.node.name) < 0) {
+      if (object.isIdentifier() && property.isIdentifier() && isValidCallee(object.node.name) && !isInvalidMethod(property.node.name)) {
         context = global[object.node.name];
         func = context[property.node.name];
       }

package/lib/path/index.js

@@ -227,6 +227,9 @@ class 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);
+{
+  NodePath.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
+}
 
 for (const type of t.TYPES) {
   const typeKey = `is${type}`;

package/lib/path/inference/index.js

@@ -33,10 +33,16 @@ const {
 } = _t;
 
 function getTypeAnnotation() {
-  if (this.typeAnnotation) return this.typeAnnotation;
-  let type = this._getTypeAnnotation() || anyTypeAnnotation();
+  let type = this.getData("typeAnnotation");
+
+  if (type != null) {
+    return type;
+  }
+
+  type = this._getTypeAnnotation() || anyTypeAnnotation();
   if (isTypeAnnotation(type)) type = type.typeAnnotation;
-  return this.typeAnnotation = type;
+  this.setData("typeAnnotation", type);
+  return type;
 }
 
 const typeAnnotationInferringNodes = new WeakSet();

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

@@ -202,5 +202,5 @@ function getConditionalAnnotation(binding, path, name) {
     };
   }
 
-  return getConditionalAnnotation(ifStatement, name);
+  return getConditionalAnnotation(binding, ifStatement, name);
 }

package/lib/path/inference/inferers.js

@@ -87,7 +87,7 @@ function TypeCastExpression(node) {
 TypeCastExpression.validParent = true;
 
 function NewExpression(node) {
-  if (this.get("callee").isIdentifier()) {
+  if (node.callee.type === "Identifier") {
     return genericTypeAnnotation(node.callee);
   }
 }

package/lib/path/introspection.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._guessExecutionStatusRelativeTo = _guessExecutionStatusRelativeTo;
-exports._guessExecutionStatusRelativeToDifferentFunctions = _guessExecutionStatusRelativeToDifferentFunctions;
 exports._resolve = _resolve;
 exports.canHaveVariableDeclarationOrExpression = canHaveVariableDeclarationOrExpression;
 exports.canSwapBetweenExpressionAndStatement = canSwapBetweenExpressionAndStatement;
@@ -232,20 +231,24 @@ function isExecutionUncertainInList(paths, maxIndex) {
 }
 
 function _guessExecutionStatusRelativeTo(target) {
+  return _guessExecutionStatusRelativeToCached(this, target, new Map());
+}
+
+function _guessExecutionStatusRelativeToCached(base, target, cache) {
   const funcParent = {
-    this: getOuterFunction(this),
+    this: getOuterFunction(base),
     target: getOuterFunction(target)
   };
 
   if (funcParent.target.node !== funcParent.this.node) {
-    return this._guessExecutionStatusRelativeToDifferentFunctions(funcParent.target);
+    return _guessExecutionStatusRelativeToDifferentFunctionsCached(base, funcParent.target, cache);
   }
 
   const paths = {
     target: target.getAncestry(),
-    this: this.getAncestry()
+    this: base.getAncestry()
   };
-  if (paths.target.indexOf(this) >= 0) return "after";
+  if (paths.target.indexOf(base) >= 0) return "after";
   if (paths.this.indexOf(target) >= 0) return "before";
   let commonPath;
   const commonIndex = {
@@ -289,9 +292,9 @@ function _guessExecutionStatusRelativeTo(target) {
   return keyPosition.target > keyPosition.this ? "before" : "after";
 }
 
-const executionOrderCheckedNodes = new WeakSet();
+const executionOrderCheckedNodes = new Set();
 
-function _guessExecutionStatusRelativeToDifferentFunctions(target) {
+function _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache) {
   if (!target.isFunctionDeclaration() || target.parentPath.isExportDeclaration()) {
     return "unknown";
   }
@@ -312,20 +315,37 @@ function _guessExecutionStatusRelativeToDifferentFunctions(target) {
     if (executionOrderCheckedNodes.has(path.node)) continue;
     executionOrderCheckedNodes.add(path.node);
 
-    const status = this._guessExecutionStatusRelativeTo(path);
-
-    executionOrderCheckedNodes.delete(path.node);
+    try {
+      const status = _guessExecutionStatusRelativeToCached(base, path, cache);
 
-    if (allStatus && allStatus !== status) {
-      return "unknown";
-    } else {
-      allStatus = status;
+      if (allStatus && allStatus !== status) {
+        return "unknown";
+      } else {
+        allStatus = status;
+      }
+    } finally {
+      executionOrderCheckedNodes.delete(path.node);
     }
   }
 
   return allStatus;
 }
 
+function _guessExecutionStatusRelativeToDifferentFunctionsCached(base, target, cache) {
+  let nodeMap = cache.get(base.node);
+
+  if (!nodeMap) {
+    cache.set(base.node, nodeMap = new Map());
+  } else if (nodeMap.has(target.node)) {
+    return nodeMap.get(target.node);
+  }
+
+  const result = _guessExecutionStatusRelativeToDifferentFunctionsInternal(base, target, cache);
+
+  nodeMap.set(target.node, result);
+  return result;
+}
+
 function resolve(dangerous, resolved) {
   return this._resolve(dangerous, resolved) || this;
 }

package/lib/path/lib/removal-hooks.js

@@ -4,6 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.hooks = void 0;
+
+var _ = require("..");
+
 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();
 

package/lib/path/replacement.js

@@ -69,10 +69,11 @@ function replaceWithMultiple(nodes) {
 
 function replaceWithSourceString(replacement) {
   this.resync();
+  let ast;
 
   try {
     replacement = `(${replacement})`;
-    replacement = (0, _parser.parse)(replacement);
+    ast = (0, _parser.parse)(replacement);
   } catch (err) {
     const loc = err.loc;
 
@@ -89,23 +90,21 @@ function replaceWithSourceString(replacement) {
     throw err;
   }
 
-  replacement = replacement.program.body[0].expression;
+  const expressionAST = ast.program.body[0].expression;
 
-  _index.default.removeProperties(replacement);
+  _index.default.removeProperties(expressionAST);
 
-  return this.replaceWith(replacement);
+  return this.replaceWith(expressionAST);
 }
 
-function replaceWith(replacement) {
+function replaceWith(replacementPath) {
   this.resync();
 
   if (this.removed) {
     throw new Error("You can't replace this node, we've already removed it");
   }
 
-  if (replacement instanceof _index2.default) {
-    replacement = replacement.node;
-  }
+  let replacement = replacementPath instanceof _index2.default ? replacementPath.node : replacementPath;
 
   if (!replacement) {
     throw new Error("You passed `path.replaceWith()` a falsy node, use `path.remove()` instead");

package/lib/scope/index.js

@@ -38,9 +38,11 @@ const {
   isMethod,
   isModuleDeclaration,
   isModuleSpecifier,
+  isNullLiteral,
   isObjectExpression,
   isProperty,
   isPureish,
+  isRegExpLiteral,
   isSuper,
   isTaggedTemplateExpression,
   isTemplateLiteral,
@@ -75,7 +77,7 @@ function gatherNodeParts(node, parts) {
         }
       } else if (isModuleSpecifier(node)) {
         gatherNodeParts(node.local, parts);
-      } else if (isLiteral(node)) {
+      } else if (isLiteral(node) && !isNullLiteral(node) && !isRegExpLiteral(node) && !isTemplateLiteral(node)) {
         parts.push(node.value);
       }
 
@@ -185,7 +187,7 @@ function gatherNodeParts(node, parts) {
       break;
 
     case "JSXOpeningElement":
-      parts.push(node.name);
+      gatherNodeParts(node.name, parts);
       break;
 
     case "JSXFragment":
@@ -368,9 +370,9 @@ class Scope {
         path = this.path;
 
     do {
-      const isKey = path.key === "key";
+      const shouldSkip = path.key === "key" || path.listKey === "decorators";
       path = path.parentPath;
-      if (isKey && path.isMethod()) path = path.parentPath;
+      if (shouldSkip && path.isMethod()) path = path.parentPath;
       if (path && path.isScope()) parent = path;
     } while (path && !parent);
 

package/lib/scope/lib/renamer.js

@@ -9,16 +9,10 @@ var _binding = require("../binding");
 
 var _helperSplitExportDeclaration = require("@babel/helper-split-export-declaration");
 
-var _t = require("@babel/types");
-
-const {
-  VISITOR_KEYS,
-  assignmentExpression,
-  identifier,
-  toExpression,
-  variableDeclaration,
-  variableDeclarator
-} = _t;
+var t = require("@babel/types");
+
+var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
+
 const renameVisitor = {
   ReferencedIdentifier({
     node
@@ -30,7 +24,11 @@ const renameVisitor = {
 
   Scope(path, state) {
     if (!path.scope.bindingIdentifierEquals(state.oldName, state.binding.identifier)) {
-      skipAllButComputedMethodKey(path);
+      path.skip();
+
+      if (path.isMethod()) {
+        (0, _helperEnvironmentVisitor.requeueComputedKeyAndDecorators)(path);
+      }
     }
   },
 
@@ -59,7 +57,17 @@ class Renamer {
       return;
     }
 
-    if (maybeExportDeclar.isExportDefaultDeclaration() && !maybeExportDeclar.get("declaration").node.id) {
+    if (maybeExportDeclar.isExportDefaultDeclaration()) {
+      const {
+        declaration
+      } = maybeExportDeclar.node;
+
+      if (t.isDeclaration(declaration) && !declaration.id) {
+        return;
+      }
+    }
+
+    if (maybeExportDeclar.isExportAllDeclaration()) {
       return;
     }
 
@@ -67,23 +75,11 @@ class Renamer {
   }
 
   maybeConvertFromClassFunctionDeclaration(path) {
-    return;
-    if (!path.isFunctionDeclaration() && !path.isClassDeclaration()) return;
-    if (this.binding.kind !== "hoisted") return;
-    path.node.id = identifier(this.oldName);
-    path.node._blockHoist = 3;
-    path.replaceWith(variableDeclaration("let", [variableDeclarator(identifier(this.newName), toExpression(path.node))]));
+    return path;
   }
 
   maybeConvertFromClassFunctionExpression(path) {
-    return;
-    if (!path.isFunctionExpression() && !path.isClassExpression()) return;
-    if (this.binding.kind !== "local") return;
-    path.node.id = identifier(this.oldName);
-    this.binding.scope.parent.push({
-      id: identifier(this.newName)
-    });
-    path.replaceWith(assignmentExpression("=", identifier(this.newName), path.node));
+    return path;
   }
 
   rename(block) {
@@ -123,24 +119,11 @@ class Renamer {
     }
 
     if (parentDeclar) {
-      this.maybeConvertFromClassFunctionDeclaration(parentDeclar);
-      this.maybeConvertFromClassFunctionExpression(parentDeclar);
+      this.maybeConvertFromClassFunctionDeclaration(path);
+      this.maybeConvertFromClassFunctionExpression(path);
     }
   }
 
 }
 
-exports.default = Renamer;
-
-function skipAllButComputedMethodKey(path) {
-  if (!path.isMethod() || !path.node.computed) {
-    path.skip();
-    return;
-  }
-
-  const keys = VISITOR_KEYS[path.type];
-
-  for (const key of keys) {
-    if (key !== "key") path.skipKey(key);
-  }
-}
+exports.default = Renamer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babel/traverse",
-  "version": "7.18.0",
+  "version": "7.18.6",
   "description": "The Babel Traverse module maintains the overall tree state, and is responsible for replacing, removing, and adding nodes",
   "author": "The Babel Team (https://babel.dev/team)",
   "homepage": "https://babel.dev/docs/en/next/babel-traverse",
@@ -16,21 +16,22 @@
   },
   "main": "./lib/index.js",
   "dependencies": {
-    "@babel/code-frame": "^7.16.7",
-    "@babel/generator": "^7.18.0",
-    "@babel/helper-environment-visitor": "^7.16.7",
-    "@babel/helper-function-name": "^7.17.9",
-    "@babel/helper-hoist-variables": "^7.16.7",
-    "@babel/helper-split-export-declaration": "^7.16.7",
-    "@babel/parser": "^7.18.0",
-    "@babel/types": "^7.18.0",
+    "@babel/code-frame": "^7.18.6",
+    "@babel/generator": "^7.18.6",
+    "@babel/helper-environment-visitor": "^7.18.6",
+    "@babel/helper-function-name": "^7.18.6",
+    "@babel/helper-hoist-variables": "^7.18.6",
+    "@babel/helper-split-export-declaration": "^7.18.6",
+    "@babel/parser": "^7.18.6",
+    "@babel/types": "^7.18.6",
     "debug": "^4.1.0",
     "globals": "^11.1.0"
   },
   "devDependencies": {
-    "@babel/helper-plugin-test-runner": "^7.16.7"
+    "@babel/helper-plugin-test-runner": "^7.18.6"
   },
   "engines": {
     "node": ">=6.9.0"
-  }
+  },
+  "type": "commonjs"
 }

package/scripts/generators/asserts.js

@@ -1,4 +1,4 @@
-import t from "@babel/types";
+import * as t from "@babel/types";
 
 export default function generateAsserts() {
   let output = `/*

package/scripts/generators/validators.js

@@ -1,5 +1,5 @@
-import t from "@babel/types";
-import virtualTypes from "../../lib/path/lib/virtual-types.js";
+import * as t from "@babel/types";
+import * as virtualTypes from "../../lib/path/lib/virtual-types.js";
 
 export default function generateValidators() {
   let output = `/*
@@ -18,6 +18,9 @@ export interface NodePathValidators {
   }
 
   for (const type of Object.keys(virtualTypes)) {
+    // TODO: Remove this check once we stop compiling to CJS
+    if (type === "default" || type === "__esModule") continue;
+
     const { types } = virtualTypes[type];
     if (type[0] === "_") continue;
     if (t.NODE_FIELDS[type] || t.FLIPPED_ALIAS_KEYS[type]) {

package/scripts/generators/virtual-types.js

@@ -1,4 +1,4 @@
-import virtualTypes from "../../lib/path/lib/virtual-types.js";
+import * as virtualTypes from "../../lib/path/lib/virtual-types.js";
 
 export default function generateValidators() {
   let output = `/*
@@ -11,6 +11,9 @@ export interface VirtualTypeAliases {
 `;
 
   for (const type of Object.keys(virtualTypes)) {
+    // TODO: Remove this check once we stop compiling to CJS
+    if (type === "default" || type === "__esModule") continue;
+
     output += `  ${type}: ${(virtualTypes[type].types || ["Node"])
       .map(t => `t.${t}`)
       .join(" | ")};`;