@babel/traverse 7.17.12 → 7.18.5

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) {

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/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;
@@ -94,9 +93,12 @@ function isCompletionRecord(allowInsideFunction) {
   let first = true;
 
   do {
-    const container = path.container;
+    const {
+      type,
+      container
+    } = path;
 
-    if (path.isFunction() && !first) {
+    if (!first && (path.isFunction() || type === "StaticBlock")) {
       return !!allowInsideFunction;
     }
 
@@ -105,7 +107,7 @@ function isCompletionRecord(allowInsideFunction) {
     if (Array.isArray(container) && path.key !== container.length - 1) {
       return false;
     }
-  } while ((path = path.parentPath) && !path.isProgram());
+  } while ((path = path.parentPath) && !path.isProgram() && !path.isDoExpression());
 
   return true;
 }
@@ -229,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 = {
@@ -286,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";
   }
@@ -309,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/scope/index.js

@@ -368,9 +368,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);
 
@@ -854,7 +854,9 @@ class Scope {
   push(opts) {
     let path = this.path;
 
-    if (!path.isBlockStatement() && !path.isProgram()) {
+    if (path.isPattern()) {
+      path = this.getPatternParent().path;
+    } else if (!path.isBlockStatement() && !path.isProgram()) {
       path = this.getBlockParent().path;
     }
 
@@ -921,6 +923,18 @@ class Scope {
     throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
   }
 
+  getPatternParent() {
+    let scope = this;
+
+    do {
+      if (!scope.path.isPattern()) {
+        return scope.getBlockParent();
+      }
+    } while (scope = scope.parent.parent);
+
+    throw new Error("We couldn't find a BlockStatement, For, Switch, Function, Loop or Program...");
+  }
+
   getAllBindings() {
     const ids = Object.create(null);
     let scope = this;

package/lib/scope/lib/renamer.js

@@ -11,8 +11,9 @@ var _helperSplitExportDeclaration = require("@babel/helper-split-export-declarat
 
 var _t = require("@babel/types");
 
+var _helperEnvironmentVisitor = require("@babel/helper-environment-visitor");
+
 const {
-  VISITOR_KEYS,
   assignmentExpression,
   identifier,
   toExpression,
@@ -30,7 +31,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);
+      }
     }
   },
 
@@ -130,17 +135,4 @@ class Renamer {
 
 }
 
-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.17.12",
+  "version": "7.18.5",
   "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",
@@ -17,13 +17,13 @@
   "main": "./lib/index.js",
   "dependencies": {
     "@babel/code-frame": "^7.16.7",
-    "@babel/generator": "^7.17.12",
-    "@babel/helper-environment-visitor": "^7.16.7",
+    "@babel/generator": "^7.18.2",
+    "@babel/helper-environment-visitor": "^7.18.2",
     "@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.17.12",
-    "@babel/types": "^7.17.12",
+    "@babel/parser": "^7.18.5",
+    "@babel/types": "^7.18.4",
     "debug": "^4.1.0",
     "globals": "^11.1.0"
   },