[Babel 8] Improve scope information collection performance (#17043)

Author: liuxingbaoyu

packages/babel-traverse/src/context.ts

@@ -127,6 +127,9 @@ export default class TraversalContext<S = unknown> {
       visitIndex++;
       resync.call(path);
 
+      // this path no longer belongs to the tree
+      if (process.env.BABEL_8_BREAKING && path.key === null) continue;
+
       if (
         path.contexts.length === 0 ||
         path.contexts[path.contexts.length - 1] !== this
@@ -138,7 +141,7 @@ export default class TraversalContext<S = unknown> {
       }
 
       // this path no longer belongs to the tree
-      if (path.key === null) continue;
+      if (!process.env.BABEL_8_BREAKING && path.key === null) continue;
 
       // ensure we don't visit the same node twice
       const { node } = path;
@@ -160,6 +163,7 @@ export default class TraversalContext<S = unknown> {
 
     // pop contexts
     for (let i = 0; i < visitIndex; i++) {
+      if (process.env.BABEL_8_BREAKING && queue[i].key === null) continue;
       popContext.call(queue[i]);
     }
 

packages/babel-traverse/src/path/context.ts

@@ -134,7 +134,7 @@ export function stop(this: NodePath) {
 }
 
 export function setScope(this: NodePath) {
-  if (this.opts?.noScope) return;
+  if (!process.env.BABEL_8_BREAKING && this.opts?.noScope) return;
 
   let path = this.parentPath;
 
@@ -150,7 +150,7 @@ export function setScope(this: NodePath) {
 
   let target;
   while (path && !target) {
-    if (path.opts?.noScope) return;
+    if (!process.env.BABEL_8_BREAKING && path.opts?.noScope) return;
 
     target = path.scope;
     path = path.parentPath;

packages/babel-traverse/src/path/lib/virtual-types.ts

@@ -2,7 +2,10 @@ import type * as t from "@babel/types";
 
 export interface VirtualTypeAliases {
   BindingIdentifier: t.Identifier;
-  BlockScoped: t.Node;
+  BlockScoped:
+    | t.FunctionDeclaration
+    | t.ClassDeclaration
+    | t.VariableDeclaration;
   ExistentialTypeParam: t.ExistsTypeAnnotation;
   Expression: t.Expression;
   Flow: t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier;
@@ -42,7 +45,11 @@ export const Scope: VirtualTypeMapping = ["Scopable", "Pattern"] as const;
 
 export const Referenced: VirtualTypeMapping = null;
 
-export const BlockScoped: VirtualTypeMapping = null;
+export const BlockScoped: VirtualTypeMapping = [
+  "FunctionDeclaration",
+  "ClassDeclaration",
+  "VariableDeclaration",
+] as const;
 
 export const Var: VirtualTypeMapping = ["VariableDeclaration"];
 

packages/babel-traverse/src/scope/index.ts

@@ -1,6 +1,7 @@
 import Renamer from "./lib/renamer.ts";
 import type NodePath from "../path/index.ts";
 import traverse from "../index.ts";
+import traverseForScope from "./traverseForScope.ts";
 import Binding from "./binding.ts";
 import type { BindingKind } from "./binding.ts";
 import globalsBuiltinLower from "@babel/helper-globals/data/builtin-lower.json" with { type: "json" };
@@ -1011,6 +1012,10 @@ class Scope {
   crawl() {
     const path = this.path;
 
+    if (process.env.BABEL_8_BREAKING && path.opts?.noScope) {
+      return;
+    }
+
     resetScope(this);
     this.data = Object.create(null);
 
@@ -1042,17 +1047,18 @@ class Scope {
     // traverse does not visit the root node, here we explicitly collect
     // root node binding info when the root is not a Program.
     if (path.type !== "Program") {
-      for (const visit of scopeVisitor.enter) {
-        visit.call(state, path, state);
-      }
       const typeVisitors = scopeVisitor[path.type];
       if (typeVisitors) {
         for (const visit of typeVisitors.enter) {
           visit.call(state, path, state);
         }
       }
     }
-    path.traverse(scopeVisitor, state);
+    if (process.env.BABEL_8_BREAKING) {
+      traverseForScope(path, scopeVisitor, state);
+    } else {
+      path.traverse(scopeVisitor, state);
+    }
     this.crawling = false;
 
     // register assignments

packages/babel-traverse/src/scope/traverseForScope.ts

@@ -0,0 +1,93 @@
+import { VISITOR_KEYS } from "@babel/types";
+import type * as t from "@babel/types";
+import type { HubInterface, Visitor } from "../index.ts";
+import { NodePath } from "../index.ts";
+import { explode } from "../visitors.ts";
+import { setScope } from "../path/context.ts";
+
+export default function traverseForScope(
+  path: NodePath,
+  visitors: Visitor,
+  state: any,
+) {
+  const exploded = explode(visitors);
+
+  if (exploded.enter || exploded.exit) {
+    throw new Error("Should not be used with enter/exit visitors.");
+  }
+
+  _traverse(
+    path.parentPath,
+    path.parent,
+    path.node,
+    path.container,
+    path.key,
+    path.listKey,
+    path.hub,
+    path,
+  );
+
+  function _traverse(
+    parentPath: NodePath,
+    parent: t.Node,
+    node: t.Node,
+    container: t.Node | t.Node[],
+    key: string | number,
+    listKey: string,
+    hub?: HubInterface,
+    inPath?: NodePath,
+  ) {
+    if (!node) {
+      return;
+    }
+
+    const path =
+      inPath ||
+      NodePath.get({
+        hub,
+        parentPath,
+        parent,
+        container,
+        listKey,
+        key,
+      });
+
+    setScope.call(path);
+
+    const visitor = exploded[node.type];
+    if (visitor) {
+      if (visitor.enter) {
+        for (const visit of visitor.enter) {
+          visit.call(state, path, state);
+        }
+      }
+      if (visitor.exit) {
+        for (const visit of visitor.exit) {
+          visit.call(state, path, state);
+        }
+      }
+    }
+    if (path.shouldSkip) {
+      return;
+    }
+
+    const keys = VISITOR_KEYS[node.type];
+    if (!keys?.length) {
+      return;
+    }
+
+    for (const key of keys) {
+      // @ts-expect-error key must present in node
+      const prop = node[key];
+      if (!prop) continue;
+      if (Array.isArray(prop)) {
+        for (let i = 0; i < prop.length; i++) {
+          const value = prop[i];
+          _traverse(path, node, value, prop, i, key);
+        }
+      } else {
+        _traverse(path, node, prop, node, key, null);
+      }
+    }
+  }
+}

packages/babel-traverse/src/visitors.ts

@@ -104,13 +104,9 @@ function explode$1<S>(visitor: Visitor<S>): ExplodedVisitor<S> {
     const types = virtualTypes[nodeType];
     if (types !== null) {
       for (const type of types) {
-        // merge the visitor if necessary or just put it back in
-        if (visitor[type]) {
-          mergePair(visitor[type], fns);
-        } else {
-          // @ts-expect-error Expression produces too complex union
-          visitor[type] = fns;
-        }
+        // @ts-expect-error Expression produces too complex union
+        visitor[type] ??= {};
+        mergePair(visitor[type], fns);
       }
     } else {
       mergePair(visitor, fns);

packages/babel-traverse/test/scope.js

@@ -291,6 +291,31 @@ describe("scope", () => {
       ).toBe("outside");
     });
 
+    it.each([
+      `switch (a) { default: let a = "inside" }`,
+      `class foo { @a m() { var a = "inside"; } }`,
+      `class foo { [a]() { var a = "inside" } }`,
+    ])("scope hasGlobal with crawl: `%s`", function (code) {
+      let hasGlobal;
+      traverse(
+        parse(code, {
+          plugins: [["decorators", { version: "2025-03" }]],
+        }),
+        {
+          Identifier(path) {
+            if (
+              path.node.name === "a" &&
+              path.parent.type !== "VariableDeclarator" &&
+              path.parent.type !== "AssignmentPattern"
+            ) {
+              hasGlobal = path.scope.hasGlobal("a");
+            }
+          },
+        },
+      );
+      expect(hasGlobal).toBe(true);
+    });
+
     it("variable declaration", function () {
       expect(getPath("var foo = null;").scope.getBinding("foo").path.type).toBe(
         "VariableDeclarator",