Add v1 AST PathHead.original

This makes printing-esq tasks easier when working with `path.head`
and restores feature parity with `path.original` which is a very
common way to work with PathExpression nodes

Author: chancancode

packages/@glimmer/syntax/lib/v1/legacy-interop.ts

@@ -70,35 +70,21 @@ export function buildLegacyMustache({
 
 export type PathExpressionParams = Omit<ASTv1.MinimalPathExpression, 'type'>;
 
-function original(head: ASTv1.PathHead, tail: readonly string[]): string {
-  switch (head.type) {
-    case 'ThisHead':
-      return ['this', ...tail].join('.');
-    case 'AtHead':
-    case 'VarHead':
-      return [head.name, ...tail].join('.');
-  }
-}
-
 export function buildLegacyPath({ head, tail, loc }: PathExpressionParams): ASTv1.PathExpression {
   const node = {
     type: 'PathExpression',
     head,
     tail,
-    loc,
-  };
-
-  Object.defineProperty(node, 'original', {
-    enumerable: true,
-    get(this: typeof node): string {
-      return original(this.head, this.tail);
+    get original() {
+      return [this.head.original, ...this.tail].join('.');
     },
-    set(this: typeof node, value: string) {
+    set original(value: string) {
       let [head, ...tail] = asPresentArray(value.split('.'));
       this.head = b.head(head, this.head.loc);
       this.tail = tail;
     },
-  });
+    loc,
+  };
 
   Object.defineProperty(node, 'parts', {
     enumerable: false,

packages/@glimmer/syntax/lib/v1/nodes-v1.ts

@@ -146,19 +146,30 @@ export interface SubExpression extends BaseNode {
 
 export interface ThisHead {
   type: 'ThisHead';
+  original: 'this';
   loc: SourceSpan;
 }
 
 export interface AtHead {
   type: 'AtHead';
   name: string;
   loc: SourceSpan;
+
+  /**
+   * alias for name
+   */
+  original: string;
 }
 
 export interface VarHead {
   type: 'VarHead';
   name: string;
   loc: SourceSpan;
+
+  /**
+   * alias for name
+   */
+  original: string;
 }
 
 export type PathHead = ThisHead | AtHead | VarHead;

packages/@glimmer/syntax/lib/v1/parser-builders.ts

@@ -286,41 +286,80 @@ class Builders {
   this({ loc }: { loc: SourceSpan }): ASTv1.ThisHead {
     return {
       type: 'ThisHead',
+      get original() {
+        return 'this' as const;
+      },
       loc,
     };
   }
 
   atName({ name, loc }: { name: string; loc: SourceSpan }): ASTv1.PathHead {
-    // the `@` should be included so we have a complete source range
-    assert(name[0] === '@', `call builders.at() with a string that starts with '@'`);
-    assert(
-      name.indexOf('.') === -1,
-      `builder.at() should not be called with a name with dots in it`
-    );
-
-    return {
-      type: 'AtHead',
-      name,
+    let _name = '';
+
+    const node = {
+      type: 'AtHead' as const,
+      get name() {
+        return _name;
+      },
+      set name(value) {
+        assert(value[0] === '@', `call builders.at() with a string that starts with '@'`);
+        assert(
+          value.indexOf('.') === -1,
+          `builder.at() should not be called with a name with dots in it`
+        );
+        _name = value;
+      },
+      get original() {
+        return this.name;
+      },
+      set original(value) {
+        this.name = value;
+      },
       loc,
     };
+
+    // trigger the assertions
+    node.name = name;
+
+    return node;
   }
 
   var({ name, loc }: { name: string; loc: SourceSpan }): ASTv1.PathHead {
-    assert(name !== 'this', `You called builders.var() with 'this'. Call builders.this instead`);
-    assert(
-      name[0] !== '@',
-      `You called builders.var() with '${name}'. Call builders.at('${name}') instead`
-    );
-    assert(
-      name.indexOf('.') === -1,
-      `builder.var() should not be called with a name with dots in it`
-    );
-
-    return {
-      type: 'VarHead',
-      name,
+    let _name = '';
+
+    const node = {
+      type: 'VarHead' as const,
+      get name() {
+        return _name;
+      },
+      set name(value) {
+        assert(
+          value !== 'this',
+          `You called builders.var() with 'this'. Call builders.this instead`
+        );
+        assert(
+          value[0] !== '@',
+          `You called builders.var() with '${name}'. Call builders.at('${name}') instead`
+        );
+        assert(
+          value.indexOf('.') === -1,
+          `builder.var() should not be called with a name with dots in it`
+        );
+        _name = value;
+      },
+      get original() {
+        return this.name;
+      },
+      set original(value) {
+        this.name = value;
+      },
       loc,
     };
+
+    // trigger the assertions
+    node.name = name;
+
+    return node;
   }
 
   hash({ pairs, loc }: { pairs: ASTv1.HashPair[]; loc: SourceSpan }): ASTv1.Hash {

packages/@glimmer/syntax/lib/v2/normalize.ts

@@ -1010,13 +1010,7 @@ function printPath(node: ASTv1.PathExpression | ASTv1.CallNode): string {
 
 function printHead(node: ASTv1.PathExpression | ASTv1.CallNode): string {
   if (node.type === 'PathExpression') {
-    switch (node.head.type) {
-      case 'AtHead':
-      case 'VarHead':
-        return node.head.name;
-      case 'ThisHead':
-        return 'this';
-    }
+    return node.head.original;
   } else if (node.path.type === 'PathExpression') {
     return printHead(node.path);
   } else {