fix: literals shouldn't emit original, block inner strip, UndefinedLiteral.value

Three related AST shape fixes to match the reference builder:

1. Literals (String/Number/Boolean/Null/Undefined) no longer emit
   `original` from Rust. The JS wrapper adds it as a non-enumerable
   getter that returns value — matching the reference builder's
   defineProperty pattern.

2. UndefinedLiteral needs a real `value: undefined` own property on
   its node, not a missing key. The JS wrapper assigns this after
   conversion since JSON can't serialize undefined.

3. BlockStatement's inner strip flags now apply whitespace stripping
   to program/inverse bodies:
     openStrip.close   → trim leading ws in program body first text
     inverseStrip.open → trim trailing ws in program body last text
     inverseStrip.close → trim leading ws in inverse body first text
     closeStrip.open   → trim trailing ws in inverse (or program)
                         body last text

Local test count: 326 → 190 → (expected further drop)

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

Author: NullVoxPopuli

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

@@ -343,6 +343,33 @@ function stripBodyWhitespace(body: Stripable[]): void {
         next.chars = next.chars.replace(/^[ \t\r\n]+/u, '');
       }
     }
+
+    // BlockStatement has additional inner stripping:
+    //   openStrip.close   → trim leading ws on program body's first text
+    //   inverseStrip.open → trim trailing ws on program body's last text
+    //   inverseStrip.close → trim leading ws on inverse body's first text
+    //   closeStrip.open   → trim trailing ws on inverse (or program) last text
+    if (stmt.type === 'BlockStatement') {
+      const program = stmt.program?.body;
+      const inverse = stmt.inverse?.body;
+
+      if (stmt.openStrip?.close && program && program.length > 0) {
+        stripFirstTextLeading(program);
+      }
+      if (stmt.inverseStrip?.open && program && program.length > 0) {
+        stripLastTextTrailing(program);
+      }
+      if (stmt.inverseStrip?.close && inverse && inverse.length > 0) {
+        stripFirstTextLeading(inverse);
+      }
+      if (stmt.closeStrip?.open) {
+        if (inverse && inverse.length > 0) {
+          stripLastTextTrailing(inverse);
+        } else if (program && program.length > 0) {
+          stripLastTextTrailing(program);
+        }
+      }
+    }
   }
 
   // Drop any text nodes that are now empty after stripping.
@@ -354,6 +381,20 @@ function stripBodyWhitespace(body: Stripable[]): void {
   }
 }
 
+function stripFirstTextLeading(body: Stripable[]): void {
+  const first = body[0];
+  if (first?.type === 'TextNode' && typeof first.chars === 'string') {
+    first.chars = first.chars.replace(/^[ \t\r\n]+/u, '');
+  }
+}
+
+function stripLastTextTrailing(body: Stripable[]): void {
+  const last = body[body.length - 1];
+  if (last?.type === 'TextNode' && typeof last.chars === 'string') {
+    last.chars = last.chars.replace(/[ \t\r\n]+$/u, '');
+  }
+}
+
 function getOpenStrip(stmt: Stripable): boolean {
   if (stmt.type === 'MustacheStatement') return !!stmt.strip?.open;
   if (stmt.type === 'MustacheCommentStatement') return !!stmt.__strip?.open;
@@ -432,6 +473,32 @@ function convertLocations(node: unknown, source: src.Source): void {
     });
   }
 
+  // Add deprecated `original` as a non-enumerable getter on literal nodes
+  // (matches the reference builder's defineProperty pattern).
+  if (
+    (obj['type'] === 'StringLiteral' ||
+      obj['type'] === 'NumberLiteral' ||
+      obj['type'] === 'BooleanLiteral' ||
+      obj['type'] === 'NullLiteral' ||
+      obj['type'] === 'UndefinedLiteral') &&
+    !Object.getOwnPropertyDescriptor(obj, 'original')
+  ) {
+    Object.defineProperty(obj, 'original', {
+      enumerable: false,
+      configurable: true,
+      get(this: { value: unknown }): unknown {
+        return this.value;
+      },
+    });
+  }
+
+  // UndefinedLiteral needs a real `value: undefined` property (the reference
+  // builder creates it this way). We can't emit undefined from JSON so we
+  // assign it here.
+  if (obj['type'] === 'UndefinedLiteral' && !('value' in obj)) {
+    obj['value'] = undefined;
+  }
+
   // Decode HTML entities in text node content (precompile mode only).
   // The old parser used simple-html-tokenizer's EntityParser; we inline
   // a minimal decoder here to avoid re-adding that dependency.

packages/@glimmer/syntax/pkg/standalone/glimmer_template_parser_bg.wasm

@@ -259,7 +259,6 @@ pub struct StringLiteral {
     #[serde(rename = "type")]
     pub node_type: &'static str, // "StringLiteral"
     pub value: String,
-    pub original: String,
     pub loc: SourceLocation,
 }
 
@@ -268,7 +267,6 @@ pub struct BooleanLiteral {
     #[serde(rename = "type")]
     pub node_type: &'static str, // "BooleanLiteral"
     pub value: bool,
-    pub original: bool,
     pub loc: SourceLocation,
 }
 
@@ -277,7 +275,6 @@ pub struct NumberLiteral {
     #[serde(rename = "type")]
     pub node_type: &'static str, // "NumberLiteral"
     pub value: f64,
-    pub original: f64,
     pub loc: SourceLocation,
 }
 
@@ -294,7 +291,6 @@ pub struct NullLiteral {
     pub node_type: &'static str, // "NullLiteral"
     // value and original are both `null` in ASTv1
     pub value: Option<()>,
-    pub original: Option<()>,
     pub loc: SourceLocation,
 }
 

packages/@glimmer/syntax/pkg/wasm-bytes.mjs

@@ -589,7 +589,6 @@ fn build_string_literal(pair: Pair<'_, Rule>, source: &str) -> Expression {
     Expression::StringLiteral(StringLiteral {
         node_type: "StringLiteral",
         value: unescaped.clone(),
-        original: unescaped,
         loc,
     })
 }
@@ -601,7 +600,6 @@ fn build_number_literal(pair: Pair<'_, Rule>, source: &str) -> Expression {
     Expression::NumberLiteral(NumberLiteral {
         node_type: "NumberLiteral",
         value,
-        original: value,
         loc,
     })
 }
@@ -613,7 +611,6 @@ fn build_boolean_literal(pair: Pair<'_, Rule>, source: &str) -> Expression {
     Expression::BooleanLiteral(BooleanLiteral {
         node_type: "BooleanLiteral",
         value,
-        original: value,
         loc,
     })
 }
@@ -631,7 +628,6 @@ fn build_null_literal(pair: Pair<'_, Rule>, source: &str) -> Expression {
     Expression::NullLiteral(NullLiteral {
         node_type: "NullLiteral",
         value: None,
-        original: None,
         loc,
     })
 }