ember-estree 0.6.1 → 0.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-estree",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "ESTree generator for gjs and gts file used by ember",
   "keywords": [
     "AST",
@@ -33,8 +33,7 @@
     "@glimmer/env": "^0.1.7",
     "@glimmer/syntax": "^0.95.0",
     "content-tag": "^4.1.0",
-    "oxc-parser": "^0.119.0",
-    "zimmerframe": "^1.1.4"
+    "oxc-parser": "^0.119.0"
   },
   "devDependencies": {
     "@tsconfig/node-lts": "^22.0.2",
@@ -45,7 +44,8 @@
     "publint": "^0.3.18",
     "release-plan": "^0.18.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.4",
+    "zimmerframe": "^1.1.4"
   },
   "scripts": {
     "bench": "node --expose-gc tests/parser.bench.mjs",

package/src/parse.js

@@ -9,12 +9,24 @@
  * 6. Done
  */
 
-import { parseSync } from "oxc-parser";
+import { parseSync, visitorKeys as oxcVisitorKeys } from "oxc-parser";
 import { Preprocessor } from "content-tag";
-import { walk } from "zimmerframe";
 
 import { processTemplate, DocumentLines, glimmerVisitorKeys, setParent } from "./transforms.js";
 
+// Base visitor-keys map for the outer-AST walk: oxc-parser's own keys (covers
+// standard ESTree + TS), plus the `File` wrapper we add on the default path,
+// plus Glimmer's keys. Used to iterate only declared child slots instead of
+// every enumerable property on every node.
+//
+// When `options.parser` returns `visitorKeys`, callers merge on top — but if
+// their parser's AST is oxc-compatible, this base is already sufficient.
+const DEFAULT_VISITOR_KEYS = {
+  ...oxcVisitorKeys,
+  File: ["program"],
+  ...glimmerVisitorKeys,
+};
+
 // Swap `oldNode` for `newNode` in whichever slot of `parent` currently holds it.
 // Used to splice a GlimmerTemplate directly into the outer AST without
 // allocating new ancestor objects — keeps WeakMap-keyed data (scope manager,
@@ -55,7 +67,9 @@ const PLACEHOLDER_TYPES = new Set([
  * @param {string}  [options.filePath] - File path for language detection
  * @param {boolean} [options.tokens] - Generate a flat token stream on the AST (needed by ESLint; skipped by default)
  * @param {boolean} [options.templateOnly] - Parse as raw Glimmer template content (for .hbs)
- * @param {function} [options.parser] - Custom JS/TS parser: (placeholderJS) => { ast, scopeManager?, visitorKeys?, services?, ... }
+ * @param {function} [options.parser] - Custom JS/TS parser: (placeholderJS) => { ast, scopeManager?, visitorKeys?, services?, ... }.
+ *   Recommended to return `visitorKeys` describing the parser's AST; when omitted, oxc-parser's
+ *   keys are used (fine for oxc-compatible ASTs, incomplete for parsers that emit bespoke node types).
  * @param {object|function} [options.visitors] - Either a map of `{ [Type]: (node, path) => void }`
  *   handlers, or a factory `(outerAst) => handlers` invoked once after parsing (before any
  *   template splicing) to give callers a view of the raw JS/TS tree. Handlers fire on every
@@ -206,49 +220,66 @@ export function toTree(source, options = {}) {
     return parseResult;
   }
 
-  result.ast = walk(result.ast, null, {
-    _(node, { next, visit, state }) {
-      if (hasTemplates && PLACEHOLDER_TYPES.has(node.type)) {
-        const parseResult = matchPlaceholder(node);
-        if (parseResult) {
-          const ast = processPlaceholder(parseResult, node);
-          // Splice in place: write the GlimmerTemplate directly into the
-          // parent's slot instead of returning it from the visitor. Returning
-          // would trigger zimmerframe's apply_mutations, which shallow-clones
-          // every ancestor up to the root — orphaning any WeakMap-keyed data
-          // held by custom parsers (scope manager, esTreeNodeToTSNodeMap).
-          // In-place mutation preserves node identity for all ancestors.
-          const parent = state?.parentPath?.node ?? null;
-          if (parent) replaceInParent(parent, node, ast);
-          setParent(ast, parent);
-          // Dispatch visitors on the Glimmer subtree. We pass `state` so the
-          // Glimmer root's parentPath reflects its true JS parent — the
-          // placeholder (TemplateLiteral / StaticBlock) is an internal
-          // artifact. Not returning anything keeps apply_mutations from
-          // firing up the ancestor chain.
-          if (hasVisitors) visit(ast, state);
-          return;
-        }
+  // Walk the outer AST keyed on visitorKeys — iterating only declared child
+  // slots instead of every enumerable property on every node. Custom parsers
+  // may supply their own keys; those override the defaults for types they
+  // recognise, and Glimmer keys stay on top for the spliced subtrees.
+  const allVisitorKeys =
+    useCustomParser && result.visitorKeys
+      ? { ...DEFAULT_VISITOR_KEYS, ...result.visitorKeys, ...glimmerVisitorKeys }
+      : DEFAULT_VISITOR_KEYS;
+
+  function walkWithKeys(node, parentPath) {
+    if (!node || !node.type) return;
+
+    if (hasTemplates && PLACEHOLDER_TYPES.has(node.type)) {
+      const parseResult = matchPlaceholder(node);
+      if (parseResult) {
+        // Splice in place: write the GlimmerTemplate directly into the parent's
+        // slot instead of allocating new ancestor objects. This preserves node
+        // identity for every ancestor, which matters for WeakMap-keyed data
+        // held by custom parsers (scope manager, esTreeNodeToTSNodeMap).
+        const ast = processPlaceholder(parseResult, node);
+        const parent = parentPath?.node ?? null;
+        if (parent) replaceInParent(parent, node, ast);
+        setParent(ast, parent);
+        // Recurse into the Glimmer subtree so visitors fire on its nodes too.
+        // The Glimmer root's parentPath reflects its true JS parent — the
+        // placeholder (TemplateLiteral / StaticBlock) is an internal artifact.
+        if (hasVisitors) walkWithKeys(ast, parentPath);
+        return;
       }
+    }
 
-      const path = {
-        node,
-        parent: state?.parentPath?.node ?? null,
-        parentPath: state?.parentPath ?? null,
-      };
-
-      if (hasVisitors && !seen.has(node)) {
-        seen.add(node);
-        const handler = visitors[node.type];
-        if (handler) handler(node, path);
-        if ("blockParams" in node && visitors.GlimmerBlockParams) {
-          visitors.GlimmerBlockParams(node, path);
+    const path = { node, parent: parentPath?.node ?? null, parentPath };
+
+    if (hasVisitors && !seen.has(node)) {
+      seen.add(node);
+      const handler = visitors[node.type];
+      if (handler) handler(node, path);
+      if ("blockParams" in node && visitors.GlimmerBlockParams) {
+        visitors.GlimmerBlockParams(node, path);
+      }
+    }
+
+    const keys = allVisitorKeys[node.type];
+    if (!keys) return;
+    for (const key of keys) {
+      const child = node[key];
+      if (!child) continue;
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && item.type) {
+            walkWithKeys(item, path);
+          }
         }
+      } else if (typeof child === "object" && child.type) {
+        walkWithKeys(child, path);
       }
+    }
+  }
 
-      next({ parentPath: path });
-    },
-  });
+  walkWithKeys(result.ast, null);
 
   // Splice template tokens into the AST token stream.
   //