test: port @glimmer/syntax parser tests from #15, add smoke-test regression fixtures

Two additions:

1. Port the full parser-node-test.ts from #15 (unified single-pass parser).
   That file was built by migrating @handlebars/parser/spec/ mocha tests to
   qunit during #15's package cleanup; this PR deletes the same package, so
   the same coverage is needed. +259 lines.

2. New test module "Prettier smoke-test regression fixtures" covering the
   inputs the prettier smoke test found regressing vs Jison:
   - empty mustache {{}}
   - unclosed mustache {{@name}
   - bare tilde {{~}}, {{~~}}
   - reserved-named-argument parse errors: {{@}}, {{@<digit>}}, {{@@}} etc.

   Tests only assert a parse error is thrown (not the exact message text),
   so they stay valid whether v2-parser is later adjusted to emit Jison-
   compatible error strings or not. They lock in the throw-vs-accept
   behavior as regression coverage.

Author: johanrd

packages/@glimmer/syntax/test/parser-node-test.ts

@@ -1083,6 +1083,353 @@ test('number literal as path throws error', (assert) => {
   );
 });
 
+// ── Backslash escape sequences ─────────────────────────────────────────────────
+// These tests document the Jison-matching escape behaviour of parser.ts.
+// See: packages/@glimmer/syntax/lib/parser/parser.ts § scanTextNode
+
+QUnit.module('[glimmer-syntax] Parser - backslash escape sequences');
+
+// k=1: \{{ → escape. Backslash consumed, {{content}} becomes literal text.
+test('\\{{ produces literal {{ in a TextNode', () => {
+  // Input file: \{{foo}}
+  astEqual('\\{{foo}}', b.template([b.text('{{foo}}')]));
+});
+
+test('\\{{ merges escaped content with following text (emu-state behaviour)', () => {
+  // Input file: \{{foo}} bar baz  →  one TextNode: "{{foo}} bar baz"
+  astEqual('\\{{foo}} bar baz', b.template([b.text('{{foo}} bar baz')]));
+});
+
+test('text before \\{{ is emitted as a separate TextNode', () => {
+  // Input file: prefix\{{foo}} suffix  →  "prefix" + "{{foo}} suffix"
+  astEqual('prefix\\{{foo}} suffix', b.template([b.text('prefix'), b.text('{{foo}} suffix')]));
+});
+
+test('\\{{ followed by a real mustache stops the emu-state merge', () => {
+  // Input file: \{{foo}}{{bar}}  →  TextNode "{{foo}}" + MustacheStatement bar
+  astEqual('\\{{foo}}{{bar}}', b.template([b.text('{{foo}}'), b.mustache(b.path('bar'))]));
+});
+
+test('emu-state merge stops at \\{{ (another escape)', () => {
+  // Input file: \{{foo}} text \{{bar}} done {{baz}}
+  // → TextNode "{{foo}} text " + TextNode "{{bar}} done " + Mustache baz
+  astEqual(
+    '\\{{foo}} text \\{{bar}} done {{baz}}',
+    b.template([b.text('{{foo}} text '), b.text('{{bar}} done '), b.mustache(b.path('baz'))])
+  );
+});
+
+// k=2: \\{{ → real mustache, ONE literal backslash emitted as TextNode.
+test('\\\\{{ emits one literal backslash and a real mustache', () => {
+  // Input file: \\{{foo}}  →  TextNode "\" + MustacheStatement foo
+  astEqual('\\\\{{foo}}', b.template([b.text('\\'), b.mustache(b.path('foo'))]));
+});
+
+// k=3: \\\{{ → real mustache, TWO literal backslashes emitted as TextNode.
+test('\\\\\\{{ emits two literal backslashes and a real mustache', () => {
+  // Input file: \\\{{foo}}  →  TextNode "\\" + MustacheStatement foo
+  astEqual('\\\\\\{{foo}}', b.template([b.text('\\\\'), b.mustache(b.path('foo'))]));
+});
+
+test('full escaped.hbs sequence produces correct AST', () => {
+  // Input file (raw):
+  //   an escaped mustache:\n\{{my-component}}\na non-escaped mustache:\n\\{{my-component}}\nanother non-escaped mustache:\n\\\{{my-component}}\n
+  const input =
+    'an escaped mustache:\n\\{{my-component}}\na non-escaped mustache:\n' +
+    '\\\\{{my-component}}\nanother non-escaped mustache:\n\\\\\\{{my-component}}\n';
+  astEqual(
+    input,
+    b.template([
+      b.text('an escaped mustache:\n'),
+      b.text('{{my-component}}\na non-escaped mustache:\n'),
+      b.text('\\'),
+      b.mustache(b.path('my-component')),
+      b.text('\nanother non-escaped mustache:\n\\\\'),
+      b.mustache(b.path('my-component')),
+      b.text('\n'),
+    ])
+  );
+});
+
+// ── Inside HTML elements ───────────────────────────────────────────────────────
+
+test('\\{{ in element text content produces literal {{', () => {
+  // Input file: <div>\{{foo}}</div>
+  astEqual('<div>\\{{foo}}</div>', b.template([element('div', ['body', b.text('{{foo}}')])]));
+});
+
+test('\\\\{{ in element text content produces one backslash + real mustache', () => {
+  // Input file: <div>\\{{foo}}</div>
+  astEqual(
+    '<div>\\\\{{foo}}</div>',
+    b.template([element('div', ['body', b.text('\\'), b.mustache(b.path('foo'))])])
+  );
+});
+
+// ── Inside quoted attribute values ─────────────────────────────────────────────
+
+test('\\{{ inside a quoted attribute value emits {{ as literal text', () => {
+  // Input file: <div title="foo \{{"></div>
+  // The attr value TextNode should have chars "foo {{"
+  const ast = parse('<div title="foo \\{{"></div>');
+  const el = ast.body[0] as ASTv1.ElementNode;
+  const attr = el.attributes[0] as ASTv1.AttrNode;
+  const value = attr.value as ASTv1.TextNode;
+  QUnit.assert.strictEqual(value.chars, 'foo {{');
+});
+
+// ── Backslash NOT before {{ passes through unchanged ───────────────────────────
+
+test('plain backslash not before {{ is preserved in text', () => {
+  // Input file: foo\bar  →  TextNode "foo\bar"
+  astEqual('foo\\bar', b.template([b.text('foo\\bar')]));
+});
+
+test('double backslash not before {{ is preserved in text', () => {
+  // Input file: foo\\bar  →  TextNode "foo\\bar"
+  astEqual('foo\\\\bar', b.template([b.text('foo\\\\bar')]));
+});
+
+test('triple backslash not before {{ is preserved in text (backslashes.hbs)', () => {
+  // Input file: <p>\\\</p>  →  TextNode "\\\"
+  astEqual('<p>\\\\\\</p>', b.template([element('p', ['body', b.text('\\\\\\')])]));
+});
+
+test('triple backslash + \\\\{{ in element text (backslashes.hbs)', () => {
+  // Input file: <p>\\\ \\{{foo}}</p>  →  TextNode "\\\ \" + Mustache foo
+  astEqual(
+    '<p>\\\\\\ \\\\{{foo}}</p>',
+    b.template([element('p', ['body', b.text('\\\\\\ \\'), b.mustache(b.path('foo'))])])
+  );
+});
+
+test('plain backslash in attribute value is preserved (backslashes-in-attributes.hbs)', () => {
+  // Input file: <p data-attr="backslash \ in an attribute"></p>
+  const ast = parse('<p data-attr="backslash \\\\ in an attribute"></p>');
+  const attr = (ast.body[0] as ASTv1.ElementNode).attributes[0] as ASTv1.AttrNode;
+  QUnit.assert.strictEqual((attr.value as ASTv1.TextNode).chars, 'backslash \\\\ in an attribute');
+});
+
+test('\\{{ in quoted class attribute value (mustache.hbs)', () => {
+  // Input file: <div class=" bar \{{">  →  attr value TextNode " bar {{"
+  const ast = parse('<div class=" bar \\{{"></div>');
+  const attr = (ast.body[0] as ASTv1.ElementNode).attributes[0] as ASTv1.AttrNode;
+  QUnit.assert.strictEqual((attr.value as ASTv1.TextNode).chars, ' bar {{');
+});
+
+// ── Unclosed escape (\\{{ with no }}) ─────────────────────────────────────────
+
+test('\\{{ without closing }} emits {{ and following text up to end', () => {
+  // Input file: \{{ unclosed  →  TextNode "{{ unclosed"
+  astEqual('\\{{ unclosed', b.template([b.text('{{ unclosed')]));
+});
+
+test('\\{{ without closing }} stops at < (HTML element boundary)', () => {
+  // Input file: <div>\{{ unclosed</div>
+  // The escape has no }}, so it emits {{ ... up to the < of </div>
+  astEqual(
+    '<div>\\{{ unclosed</div>',
+    b.template([element('div', ['body', b.text('{{ unclosed')])])
+  );
+});
+
+// ── Ported from @handlebars/parser spec/ast.js ────────────────────────────────
+
+QUnit.module('[glimmer-syntax] Parser - whitespace control (tilde and standalone)');
+
+// ── Tilde (whitespace stripping) ──────────────────────────────────────────────
+
+test('tilde on mustache strips adjacent whitespace text nodes, which are then removed', (assert) => {
+  // {{~comment~}}: leftStrip strips trailing WS from '  ', rightStrip strips leading WS from ' '.
+  // Both text nodes become '' and are removed by the post-pass filter.
+  const ast = parse('  {{~comment~}} ');
+  assert.strictEqual(ast.body.length, 1, 'empty text nodes are removed after tilde stripping');
+  assert.strictEqual(ast.body[0]?.type, 'MustacheStatement');
+});
+
+test('tilde on block open/close strips program body content', (assert) => {
+  // Use a non-standalone block (prefix 'x' prevents standalone detection) so that
+  // only tilde stripping applies, with no interaction with standalone stripping.
+  // {{# comment~}}: openStrip.close strips leading WS from program body.
+  // {{~/comment}}: closeStrip.open strips trailing WS from program body.
+  const ast = parse('x{{# comment~}} \nfoo\n {{~/comment}}y');
+  const block = ast.body[1] as ASTv1.BlockStatement;
+  assert.strictEqual((block.program.body[0] as ASTv1.TextNode).chars, 'foo');
+});
+
+// ── ignoreStandalone (parseWithoutProcessing equivalent) ─────────────────────
+
+test('ignoreStandalone: tilde still strips adjacent text nodes', (assert) => {
+  // ignoreStandalone only skips standalone-line detection; tilde stripping still runs.
+  const ast = parse('  {{~comment~}} ', { parseOptions: { ignoreStandalone: true } });
+  assert.strictEqual(
+    ast.body.length,
+    1,
+    'tilde-stripped empty nodes are removed even without standalone detection'
+  );
+  assert.strictEqual(ast.body[0]?.type, 'MustacheStatement');
+});
+
+// ── Standalone block detection ────────────────────────────────────────────────
+
+test('standalone block: surrounding whitespace text nodes are removed after stripping', (assert) => {
+  // Leading ' ' and trailing ' ' are stripped to '' by standalone detection, then removed.
+  const ast = parse(' {{#comment}} \nfoo\n {{/comment}} ');
+  assert.strictEqual(ast.body.length, 1, 'surrounding empty text nodes are removed');
+  const block = ast.body[0] as ASTv1.BlockStatement;
+  assert.strictEqual((block.program.body[0] as ASTv1.TextNode).chars, 'foo\n');
+});
+
+test('standalone block with else: surrounding nodes removed, inner content standalone-stripped', (assert) => {
+  const ast = parse(' {{#comment}} \nfoo\n {{else}} \n  bar \n  {{/comment}} ');
+  assert.strictEqual(ast.body.length, 1);
+  const block = ast.body[0] as ASTv1.BlockStatement;
+  assert.strictEqual((block.program.body[0] as ASTv1.TextNode).chars, 'foo\n');
+  assert.strictEqual(((block.inverse as ASTv1.Block).body[0] as ASTv1.TextNode).chars, '  bar \n');
+});
+
+test('standalone block at start of line: program body strips leading newline', (assert) => {
+  const ast = parse('{{#comment}} \nfoo\n {{/comment}}');
+  const block = ast.body[0] as ASTv1.BlockStatement;
+  assert.strictEqual((block.program.body[0] as ASTv1.TextNode).chars, 'foo\n');
+});
+
+test('standalone block containing mustache: surrounding text is stripped and empty node removed', (assert) => {
+  // Program body: [TextNode(' \n'), MustacheStatement(foo), TextNode('\n ')].
+  // Standalone strips first child to '' (removed) and last child to '\n'.
+  const ast = parse('{{#comment}} \n{{foo}}\n {{/comment}}');
+  const block = ast.body[0] as ASTv1.BlockStatement;
+  assert.strictEqual(block.program.body.length, 2);
+  assert.strictEqual(block.program.body[0]?.type, 'MustacheStatement');
+  assert.strictEqual((block.program.body[1] as ASTv1.TextNode).chars, '\n');
+});
+
+test('non-standalone block (inline): whitespace is NOT stripped', (assert) => {
+  // When a block open tag shares a line with other mustaches, it is not standalone
+  const ast = parse('{{#foo}} {{#comment}} \nfoo\n {{/comment}} {{/foo}}');
+  const outerBlock = ast.body[0] as ASTv1.BlockStatement;
+  // The inner block is not standalone because the line has other content
+  const innerBlock = outerBlock.program.body[1] as ASTv1.BlockStatement;
+  assert.strictEqual(innerBlock.type, 'BlockStatement');
+  // The program body of the non-standalone inner block keeps its whitespace
+  assert.strictEqual((innerBlock.program.body[0] as ASTv1.TextNode).chars, ' \nfoo\n ');
+});
+
+// ── Standalone comment detection ──────────────────────────────────────────────
+
+test('standalone comment: trailing whitespace node is removed after stripping', (assert) => {
+  // Trailing ' ' is stripped to '' and removed; only the comment node remains.
+  const ast = parse('{{! comment }} ');
+  assert.strictEqual(ast.body.length, 1);
+  assert.strictEqual(ast.body[0]?.type, 'MustacheCommentStatement');
+});
+
+test('standalone comment: both surrounding text nodes are removed after stripping', (assert) => {
+  // '  ' and ' ' both stripped to '' and removed.
+  const ast = parse('  {{! comment }} ');
+  assert.strictEqual(ast.body.length, 1);
+  assert.strictEqual(ast.body[0]?.type, 'MustacheCommentStatement');
+});
+
+// ── ignoreStandalone: standalone detection is skipped ────────────────────────
+
+test('ignoreStandalone: standalone block is NOT stripped', (assert) => {
+  const ast = parse('{{#comment}} \nfoo\n {{/comment}}', {
+    parseOptions: { ignoreStandalone: true },
+  });
+  const block = ast.body[0] as ASTv1.BlockStatement;
+  // Without standalone detection the raw content is preserved
+  assert.strictEqual((block.program.body[0] as ASTv1.TextNode).chars, ' \nfoo\n ');
+});
+
+// ── Prettier smoke-test regression fixtures ────────────────────────────────────
+// Each test below corresponds to a fixture in prettier's tests/format/handlebars
+// suite that the default parser must parse-error on. The exact error text is
+// parser-specific (Jison vs v2-parser emit different strings), so these tests
+// only assert that *some* parse error is thrown. This locks in the throw-vs-
+// accept behavior without coupling to a specific parser's wording.
+
+QUnit.module('[glimmer-syntax] Parser - prettier smoke-test regression fixtures');
+
+// prettier tests/format/handlebars/_errors_/invalid-3.hbs
+test('empty mustache {{}} is a parse error (invalid-3.hbs)', (assert) => {
+  assert.throws(
+    () => {
+      parse('<a>\n\n{{}}\n', { meta: { moduleName: 'test-module' } });
+    },
+    /./u,
+    'empty mustache should throw a parse error'
+  );
+});
+
+// prettier tests/format/handlebars/_errors_/invalid.hbs
+test('unclosed mustache {{@name} is a parse error (invalid.hbs)', (assert) => {
+  assert.throws(
+    () => {
+      parse('<A >\nx, {{@name}\n', { meta: { moduleName: 'test-module' } });
+    },
+    /./u,
+    'unclosed mustache should throw a parse error'
+  );
+});
+
+// prettier tests/format/handlebars/_errors_/tilde-comments-1.hbs
+test('bare tilde mustache {{~}} is a parse error (tilde-comments-1.hbs)', (assert) => {
+  assert.throws(
+    () => {
+      parse('{{~}}\n', { meta: { moduleName: 'test-module' } });
+    },
+    /./u,
+    'bare tilde mustache should throw a parse error'
+  );
+});
+
+// prettier tests/format/handlebars/_errors_/tilde-comments-2.hbs
+test('double tilde mustache {{~~}} is a parse error (tilde-comments-2.hbs)', (assert) => {
+  assert.throws(
+    () => {
+      parse('{{~~}}\n', { meta: { moduleName: 'test-module' } });
+    },
+    /./u,
+    'double tilde mustache should throw a parse error'
+  );
+});
+
+// assert-reserved-named-arguments-test: '@' alone is reserved / parse error
+test('mustache with bare @ is a parse error ({{@}})', (assert) => {
+  assert.throws(
+    () => {
+      parse('{{@}}', { meta: { moduleName: 'test-module' } });
+    },
+    /./u,
+    'mustache with bare @ should throw a parse error'
+  );
+});
+
+// assert-reserved-named-arguments-test: '@0' is not a valid path
+test('mustache with @<digit> is a parse error ({{@0}})', (assert) => {
+  assert.throws(
+    () => {
+      parse('{{@0}}', { meta: { moduleName: 'test-module' } });
+    },
+    /./u,
+    '@<digit> is not a valid identifier'
+  );
+});
+
+// assert-reserved-named-arguments-test: '@@', '@=', '@!' etc.
+test('mustache with @<non-id-char> is a parse error ({{@@}}, {{@=}}, {{@!}})', (assert) => {
+  for (const input of ['{{@@}}', '{{@=}}', '{{@!}}']) {
+    assert.throws(
+      () => {
+        parse(input, { meta: { moduleName: 'test-module' } });
+      },
+      /./u,
+      `${input} should throw a parse error`
+    );
+  }
+});
+
 export function strip(strings: TemplateStringsArray, ...args: string[]) {
   return strings
     .map((str: string, i: number) => {