ember-estree 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-estree",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "ESTree generator for gjs and gts file used by ember",
   "keywords": [
     "AST",
@@ -38,6 +38,7 @@
   },
   "devDependencies": {
     "@tsconfig/node-lts": "^22.0.2",
+    "mitata": "^1.0.34",
     "oxfmt": "^0.40.0",
     "oxlint": "^1.55.0",
     "publint": "^0.3.18",
@@ -48,6 +49,9 @@
   "scripts": {
     "format": "oxfmt",
     "format:check": "oxfmt --check",
+    "bench": "node --expose-gc tests/parser.bench.mjs",
+    "bench:compare": "node scripts/bench-compare.mjs",
+    "bench:summary": "./scripts/local-bench-summary.sh",
     "lint": "oxlint && pnpm format:check && publint",
     "lint:fix": "oxlint --fix && oxfmt",
     "test": "vitest run"

package/src/transforms.js

@@ -54,46 +54,15 @@ export const glimmerVisitorKeys = (() => {
 
 // ── Internal helpers ──────────────────────────────────────────────────
 
-/**
- * Recursively collect all nodes in a Glimmer AST using visitor keys.
- * Sets parent references during traversal.
- */
-function collectNodes(node, parent, allNodes, comments, textNodes, emptyTextNodes) {
-  node.parent = parent;
-  allNodes.push(node);
-  if (node.type === "CommentStatement" || node.type === "MustacheCommentStatement") {
-    comments.push(node);
-  }
-  if (node.type === "TextNode") {
-    node.value = node.chars;
-    if (node.value.trim().length !== 0 || (parent && parent.type === "AttrNode")) {
-      textNodes.push(node);
-    } else {
-      emptyTextNodes.push(node);
-    }
-  }
-  const keys = rawGlimmerVisitorKeys[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) {
-          collectNodes(item, node, allNodes, comments, textNodes, emptyTextNodes);
-        }
-      }
-    } else if (typeof child === "object" && child.type) {
-      collectNodes(child, node, allNodes, comments, textNodes, emptyTextNodes);
-    }
-  }
-}
-
-// Reusable descriptor — shadows prototype getters with own properties.
-// @glimmer/syntax nodes have getter chains that cause esrecurse infinite recursion.
+// @glimmer/syntax nodes use prototype getters that form circular chains,
+// crashing traversers like esrecurse. We snapshot configurable getters:
+//   ElementNode: tag, blockParams, selfClosing
+//   PathExpression: original
+//   VarHead: name, original
+//   Block: blockParams
 const _desc = { value: undefined, configurable: true, enumerable: true, writable: true };
-function defOwn(obj, key, val) {
-  _desc.value = val;
+function defOwn(obj, key) {
+  _desc.value = obj[key];
   Object.defineProperty(obj, key, _desc);
 }
 
@@ -194,6 +163,10 @@ function buildTokenStream(rawTokens, comments, textNodes) {
 /**
  * Parse and transform a Glimmer template into an ESTree-compatible AST.
  * Internal — consumed by toTree.
+ *
+ * Single recursive pass: collect, categorize, snapshot getters, fix
+ * positions, create parts/blockParamNodes, nullify empty hashes, and
+ * prefix types. No separate collect-then-transform loop.
  */
 export function processTemplate(
   templateContent,
@@ -202,7 +175,7 @@ export function processTemplate(
   { includeParentLinks = true } = {},
 ) {
   const offset = templateRange[0];
-  const docLines = new DocumentLines(templateContent);
+  const docLines = offset === 0 ? codeLines : new DocumentLines(templateContent);
 
   const toFileRange = (loc) => [
     offset + docLines.positionToOffset(loc.start),
@@ -218,27 +191,67 @@ export function processTemplate(
   const comments = [];
   const textNodes = [];
   const emptyTextNodes = [];
-  collectNodes(ast, null, allNodes, comments, textNodes, emptyTextNodes);
 
-  for (const n of allNodes) {
+  // Single recursive pass over the glimmer AST. Processes each node
+  // fully (getters, positions, parts, blockParams) then recurses into
+  // children using raw visitor keys. Type prefixing happens inline
+  // AFTER recursing (so children see the original type during lookup).
+  function visit(n, parent) {
+    n.parent = parent;
+    allNodes.push(n);
+
+    // Categorize
+    if (n.type === "CommentStatement" || n.type === "MustacheCommentStatement") {
+      comments.push(n);
+    }
+    if (n.type === "TextNode") {
+      n.value = n.chars;
+      if (n.value.trim().length !== 0 || (parent && parent.type === "AttrNode")) {
+        textNodes.push(n);
+      } else {
+        emptyTextNodes.push(n);
+      }
+    }
+
+    // Snapshot configurable prototype getters
+    switch (n.type) {
+      case "ElementNode":
+        defOwn(n, "tag");
+        defOwn(n, "blockParams");
+        defOwn(n, "selfClosing");
+        if (n.path?.head) {
+          defOwn(n.path.head, "name");
+          defOwn(n.path.head, "original");
+        }
+        break;
+      case "PathExpression":
+        defOwn(n, "original");
+        if (n.head) {
+          defOwn(n.head, "name");
+          defOwn(n.head, "original");
+        }
+        break;
+      case "Block":
+        defOwn(n, "blockParams");
+        break;
+    }
+
+    // Fix positions
     if (n.type === "PathExpression") {
       n.head.range = toFileRange(n.head.loc);
       n.head.start = n.head.range[0];
       n.head.end = n.head.range[1];
       n.head.loc = toFileLoc(n.head.range);
     }
-
     n.range = n.type === "Template" ? [...templateRange] : toFileRange(n.loc);
     n.start = n.range[0];
     n.end = n.range[1];
     n.loc = toFileLoc(n.range);
 
+    // Create parts for ElementNode
     if (n.type === "ElementNode") {
-      defOwn(n, "tag", n.tag);
       n.name = n.tag;
       const p = n.path.head;
-      defOwn(p, "name", p.name);
-      defOwn(p, "original", p.original);
       const partRange = toFileRange(p.loc);
       n.parts = [
         {
@@ -254,11 +267,10 @@ export function processTemplate(
       ];
     }
 
+    // Create blockParamNodes
     if ("blockParams" in n && Array.isArray(n.blockParams)) {
       if (n.params && n.params.length === n.blockParams.length) {
         n.blockParamNodes = n.params.map((p) => {
-          defOwn(p, "name", p.name);
-          defOwn(p, "original", p.original);
           const range = toFileRange(p.loc);
           return {
             type: "GlimmerBlockParam",
@@ -272,9 +284,9 @@ export function processTemplate(
           };
         });
       } else {
-        n.blockParamNodes = n.blockParams.map((name) => ({
+        n.blockParamNodes = n.blockParams.map((bpName) => ({
           type: "GlimmerBlockParam",
-          name,
+          name: bpName,
           parent: n,
           range: [n.range[0], n.range[1]],
           start: n.range[0],
@@ -284,26 +296,38 @@ export function processTemplate(
       }
     }
 
+    // Nullify empty hashes
     if (
       (n.type === "MustacheStatement" ||
         n.type === "BlockStatement" ||
         n.type === "SubExpression") &&
-      n.hash &&
-      n.hash.pairs &&
-      n.hash.pairs.length === 0
+      n.hash?.pairs?.length === 0
     ) {
       n.hash = null;
     }
 
-    n.type = `Glimmer${n.type}`;
-
-    // Snapshot PathExpression.head getters (name/original)
-    if (n.type === "GlimmerPathExpression" && n.head) {
-      defOwn(n.head, "name", n.head.name);
-      defOwn(n.head, "original", n.head.original);
+    // Recurse into children BEFORE prefixing type (visitor keys use original type)
+    const keys = rawGlimmerVisitorKeys[n.type];
+    if (keys) {
+      for (const key of keys) {
+        const child = n[key];
+        if (!child) continue;
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && item.type) visit(item, n);
+          }
+        } else if (typeof child === "object" && child.type) {
+          visit(child, n);
+        }
+      }
     }
+
+    // Prefix type after children are visited
+    n.type = `Glimmer${n.type}`;
   }
 
+  visit(ast, null);
+
   removeFromParent(emptyTextNodes);
   removeFromParent(comments);
   for (const comment of comments) {