Revert PathExpression legacy-upgrade in convertLocations

The previous commit (83ccd8d) tried to address a review comment by
upgrading every PathExpression through buildLegacyPath during
convertLocations, so that setting `.original` would flow through to
`head`/`tail` automatically. The auto-import-builtins plugin was then
simplified back to `node.path.original = rewritten`.

That combination passed the browser test suite locally but regressed
two smoke-test scenarios:

  {{fn}} as keyword (but it is shadowed): it works
  {{on}} as keyword (but it is shadowed): it works

These `.gjs` tests verify that a lexical JS binding (e.g. `const fn =
...`) shadows the built-in keyword inside the template. The regression
isn't due to the simpler auto-import-builtins — the plugin correctly
skips rewriting when `hasLocal('fn')` is true — but rather something
about the buildLegacyPath-upgraded PathExpression interacts poorly with
the lexical-scope path inside the v2 normalizer for this specific case.

Without the upgrade, the previous commit's auto-import-builtins
simplification also has to be reverted: without head/tail-rewriting in
the plugin, the runtime compilation path (env.meta.emberRuntime) leaves
`node.path.head` pointing at the original keyword name while
`node.path.original` contains the rewritten `__ember_keywords__.<name>`,
and the v2 normalizer reads head.name. So:

- Revert convertLocations: drop the buildLegacyPath upgrade and the
  import. PathExpression stays as plain grammar-emitted data.
- Restore the manual head/tail rewrite in auto-import-builtins, with a
  comment explaining why it's needed (the grammar emits PathExpression
  as a plain object whose `original`, `head`, and `tail` are
  independent data properties, so they must be kept in sync by hand).

Verified locally: browser test suite (9138/9138 pass) and all 3
classic-basics smoke-test scenarios (pass 3, fail 0).

The reviewer's architectural point — that setting `.original` should
propagate to `head`/`tail` — is still valid, but realizing it requires
having the Peggy grammar emit PathExpression nodes through
buildLegacyPath directly (not as a post-process step). That's a larger
change that can happen in a follow-up.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: NullVoxPopuli

packages/@ember/template-compiler/lib/plugins/auto-import-builtins.ts

@@ -51,7 +51,24 @@ function rewriteKeyword(
       name,
     });
   } else if (env.meta?.emberRuntime) {
-    node.path.original = env.meta.emberRuntime.lookupKeyword(name);
+    const rewritten = env.meta.emberRuntime.lookupKeyword(name);
+    node.path.original = rewritten;
+    // Also update head and tail so the v2 normalizer resolves correctly.
+    // e.g., "__ember_keywords__.on" → head="__ember_keywords__", tail=["on"]
+    // (The Peggy grammar emits PathExpression nodes as plain objects where
+    // `original`, `head`, and `tail` are independent data properties, so we
+    // need to keep them in sync by hand here.)
+    const parts = rewritten.split('.');
+    if (parts.length >= 2) {
+      const headName = parts[0] as string;
+      node.path.head = {
+        type: 'VarHead',
+        name: headName,
+        original: headName,
+        loc: node.path.head.loc,
+      } as AST.VarHead;
+      node.path.tail = parts.slice(1);
+    }
   }
 }
 

packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts

@@ -11,7 +11,6 @@ import * as src from '../source/api';
 import { generateSyntaxError } from '../syntax-error';
 import traverse from '../traversal/traverse';
 import Walker from '../traversal/walker';
-import { buildLegacyPath } from '../v1/legacy-interop';
 import publicBuilder from '../v1/public-builders';
 
 // ============================================================================
@@ -473,12 +472,6 @@ function isPeggySpan(
 
 /**
  * Recursively convert plain {start, end} location objects to SourceSpan instances.
- *
- * PathExpression nodes are additionally upgraded via `buildLegacyPath` so that
- * `node.path.original` is a live getter/setter backed by `head` and `tail`.
- * This way downstream AST plugins (e.g. auto-import-builtins) can assign
- * `node.path.original = 'foo.bar'` and have `head`/`tail` update automatically,
- * matching the behavior of the legacy parser-builders-produced nodes.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function convertLocations(node: any, source: src.Source): any {
@@ -492,10 +485,6 @@ function convertLocations(node: any, source: src.Source): any {
   let result: any = {};
 
   for (let key of Object.keys(node)) {
-    // PathExpression owns its own `original` via buildLegacyPath's getter.
-    // Drop the grammar-emitted data field so the getter wins.
-    if (node.type === 'PathExpression' && key === 'original') continue;
-
     let val = node[key];
     if ((key === 'loc' || key === 'openTag' || key === 'closeTag') && isPeggySpan(val)) {
       result[key] = peggySpanToSourceSpan(source, val);
@@ -506,10 +495,6 @@ function convertLocations(node: any, source: src.Source): any {
     }
   }
 
-  if (result.type === 'PathExpression') {
-    return buildLegacyPath({ head: result.head, tail: result.tail, loc: result.loc });
-  }
-
   return result;
 }