ember-estree 0.6.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-estree",
-  "version": "0.6.0",
+  "version": "0.6.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",
+    "@typescript-eslint/parser": "^8.59.0",
     "mitata": "^1.0.34",
     "oxfmt": "^0.40.0",
     "oxlint": "^1.55.0",

package/src/parse.js

@@ -13,7 +13,29 @@ import { parseSync } from "oxc-parser";
 import { Preprocessor } from "content-tag";
 import { walk } from "zimmerframe";
 
-import { processTemplate, DocumentLines, glimmerVisitorKeys } from "./transforms.js";
+import { processTemplate, DocumentLines, glimmerVisitorKeys, setParent } from "./transforms.js";
+
+// 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,
+// esTreeNodeToTSNodeMap) attached to the existing nodes.
+function replaceInParent(parent, oldNode, newNode) {
+  for (const key of Object.keys(parent)) {
+    const v = parent[key];
+    if (v === oldNode) {
+      parent[key] = newNode;
+      return true;
+    }
+    if (Array.isArray(v)) {
+      const idx = v.indexOf(oldNode);
+      if (idx !== -1) {
+        v[idx] = newNode;
+        return true;
+      }
+    }
+  }
+  return false;
+}
 
 const preprocessor = new Preprocessor();
 
@@ -112,8 +134,11 @@ export function toTree(source, options = {}) {
     ? new Map(parseResults.map((r) => [r.range.startUtf16Codepoint, r]))
     : null;
 
-  // Process a matched placeholder node: create Glimmer AST and tokens
-  function processPlaceholder(parseResult) {
+  // Process a matched placeholder node: create Glimmer AST and tokens.
+  // `placeholderNode` is the original JS/TS node being swapped out; we stash
+  // it on templateInfos so consumers can forward its parser-services mapping
+  // (e.g. esTreeNodeToTSNodeMap) onto the GlimmerTemplate that replaces it.
+  function processPlaceholder(parseResult, placeholderNode) {
     let templateContent = parseResult.contents;
     let contentRange = [
       parseResult.contentRange.startUtf16Codepoint,
@@ -159,7 +184,7 @@ export function toTree(source, options = {}) {
       ];
     }
 
-    templateInfos.push({ utf16Range: fullRange, ast });
+    templateInfos.push({ utf16Range: fullRange, ast, placeholder: placeholderNode });
     return ast;
   }
 
@@ -186,21 +211,23 @@ export function toTree(source, options = {}) {
       if (hasTemplates && PLACEHOLDER_TYPES.has(node.type)) {
         const parseResult = matchPlaceholder(node);
         if (parseResult) {
-          const ast = processPlaceholder(parseResult);
-          // Zimmerframe treats a visitor that returns a node as having
-          // taken responsibility for the subtree — it splices the result
-          // in but does NOT descend into it. So when any handlers are
-          // configured we re-enter the walk manually via `visit()` to
-          // dispatch them across the Glimmer nodes. With no handlers the
-          // walk would be pure overhead, so just return the subtree.
-          //
-          // Pass `state` (the placeholder's inherited parent context) so the
-          // Glimmer root's parentPath reflects its true JS parent. The
+          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 — the GlimmerTemplate logically lives where the
-          // placeholder was, so its parent is e.g. VariableDeclarator or
-          // ClassBody, not the placeholder itself.
-          return hasVisitors ? visit(ast, state) : ast;
+          // artifact. Not returning anything keeps apply_mutations from
+          // firing up the ancestor chain.
+          if (hasVisitors) visit(ast, state);
+          return;
         }
       }
 
@@ -240,8 +267,11 @@ export function toTree(source, options = {}) {
   // original source byte-for-byte across JS and Glimmer regions.
   //
   // Tokens are sorted by range, so use binary search for O(log n) lookup.
+  // Only splice if the caller asked for tokens — otherwise `ti.ast.tokens`
+  // wasn't populated by processPlaceholder, and a custom parser may still
+  // have returned its own token stream we shouldn't touch.
   const astRoot = result.ast.program || result.ast;
-  if (astRoot.tokens) {
+  if (generateTokens && astRoot.tokens) {
     for (const ti of templateInfos) {
       const [tStart, tEnd] = ti.utf16Range;
       const tokens = astRoot.tokens;

package/src/transforms.js

@@ -64,7 +64,7 @@ export const glimmerVisitorKeys = (() => {
 //   Block: blockParams
 const _desc = { value: undefined, configurable: true, enumerable: true, writable: true };
 const _parentDesc = { value: null, configurable: true, enumerable: false, writable: true };
-function setParent(node, parent) {
+export function setParent(node, parent) {
   _parentDesc.value = parent;
   Object.defineProperty(node, "parent", _parentDesc);
 }