Replace Handlebars parser with Peggy grammar for @glimmer/syntax

.github/workflows/ci-jobs.yml

@@ -37,8 +37,6 @@ jobs:
         run: pnpm build:types
       - name: Check internal types
         run: pnpm type-check:internals
-      - name: Check @handlebars/parser types
-        run: pnpm type-check:handlebars
       - name: Check published types
         run: pnpm type-check:types
 
@@ -222,7 +220,7 @@ jobs:
           SHOULD_TRANSPILE_FOR_NODE: true
         run: pnpm build
       - name: test
-        run: pnpm test:node && pnpm --filter "@handlebars/parser" test
+        run: pnpm test:node
 
   blueprint-test:
     name: Blueprint Tests

.github/workflows/glimmer-syntax-prettier-smoke-test.yml

@@ -17,7 +17,6 @@ on:
       - "packages/@glimmer/interfaces/**"
       - "packages/@glimmer/util/**"
       - "packages/@glimmer/wire-format/**"
-      - "packages/@handlebars/parser/**"
   pull_request:
     paths:
       - ".github/workflows/glimmer-syntax-prettier-smoke-test.yml"
@@ -27,7 +26,6 @@ on:
       - "packages/@glimmer/interfaces/**"
       - "packages/@glimmer/util/**"
       - "packages/@glimmer/wire-format/**"
-      - "packages/@handlebars/parser/**"
   workflow_dispatch:
 
 permissions:

.prettierignore

@@ -7,8 +7,8 @@ docs/
 **/smoke-tests/
 **/types/
 **/type-tests/
-packages/@handlebars/**/*.l
-packages/@handlebars/**/*.yy
+packages/@glimmer/syntax/lib/hbs-parser/**/*.l
+packages/@glimmer/syntax/lib/hbs-parser/**/*.yy
 CHANGELOG.md
 package.json
 pnpm-lock.yaml

eslint.config.mjs

@@ -28,8 +28,8 @@ export default [
       '**/type-tests/',
       'internal-docs/guides/**',
       'packages/@glimmer-workspace/**',
-      'packages/@handlebars/parser/lib/parser.js',
-      'packages/@handlebars/parser/src/**',
+      'packages/@glimmer/syntax/lib/hbs-parser/parser.js',
+      'packages/@glimmer/syntax/lib/hbs-parser/src/**',
       'tracerbench-testing/',
     ],
   },
@@ -189,15 +189,6 @@ export default [
       'import/namespace': 'off',
     },
   },
-  {
-    files: ['packages/@handlebars/parser/spec/**/*.js'],
-
-    languageOptions: {
-      globals: {
-        ...globals.mocha,
-      },
-    },
-  },
   {
     files: [
       'packages/*/tests/**/*.[jt]s',

internal-docs/guides/development/build-constraints.md

@@ -137,7 +137,6 @@ The build system has specific rules for what gets inlined vs treated as external
 - TypeScript helper library (`tslib`)
 
 **Always External:**
-- `@handlebars/parser`
 - `simple-html-tokenizer`
 - `babel-plugin-debug-macros`
 - Other `@glimmer/*` packages (to avoid duplication)

package.json

@@ -55,7 +55,6 @@
     "test:browserstack": "node bin/run-browserstack-tests.js",
     "test:wip": "vite build --mode development --minify false && testem ci",
     "type-check:internals": "tsc --noEmit",
-    "type-check:handlebars": "tsc --noEmit --project packages/@handlebars/parser/tsconfig.json",
     "type-check:types": "tsc --noEmit --project type-tests",
     "type-check": "npm-run-all type-check:*"
   },

packages/@glimmer/syntax/lib/hbs-parser/exception.js

@@ -0,0 +1,25 @@
+function Exception(message, node) {
+  let loc = node && node.loc,
+    line,
+    column;
+
+  if (loc) {
+    line = loc.start.line;
+    column = loc.start.column;
+    message += ' - ' + line + ':' + column;
+  }
+
+  let error = new Error(message);
+  error.name = 'Exception';
+
+  if (loc) {
+    error.lineNumber = line;
+    error.endLineNumber = loc.end.line;
+    error.column = column;
+    error.endColumn = loc.end.column;
+  }
+
+  return error;
+}
+
+export default Exception;

packages/@handlebars/parser/lib/helpers.js → packages/@glimmer/syntax/lib/hbs-parser/helpers.js

@@ -55,12 +55,10 @@ export function preparePath(data, sexpr, parts, loc) {
   }
 
   let tail = [];
-  let depth = 0;
+  let isThis = false;
 
   for (let i = 0, l = parts.length; i < l; i++) {
     let part = parts[i].part;
-    // If we have [] syntax then we do not treat path references as operators,
-    // i.e. foo.[this] resolves to approximately context.foo['this']
     let isLiteral = parts[i].original !== part;
     let separator = parts[i].separator;
 
@@ -71,9 +69,11 @@ export function preparePath(data, sexpr, parts, loc) {
     if (!isLiteral && (part === '..' || part === '.' || part === 'this')) {
       if (tail.length > 0) {
         throw new Exception('Invalid path: ' + original, { loc });
-      } else if (part === '..') {
-        depth++;
+      } else if (part === 'this') {
+        isThis = true;
       }
+      // '..' and '.' are rejected by Glimmer downstream but must not
+      // be pushed into `tail` — just let them affect `original`.
     } else {
       tail.push(`${partPrefix}${part}`);
     }
@@ -83,9 +83,8 @@ export function preparePath(data, sexpr, parts, loc) {
 
   return {
     type: 'PathExpression',
-    this: original.startsWith('this.'),
+    this: isThis,
     data,
-    depth,
     head,
     tail,
     parts: head ? [head, ...tail] : tail,
@@ -95,13 +94,17 @@ export function preparePath(data, sexpr, parts, loc) {
 }
 
 export function prepareMustache(path, params, hash, open, strip, locInfo) {
-  // Must use charAt to support IE pre-10
+  if (/\*/.test(open)) {
+    throw new Exception('Handlebars decorators are not supported in Glimmer', {
+      loc: this.locInfo(locInfo),
+    });
+  }
+
   let escapeFlag = open.charAt(3) || open.charAt(2),
     escaped = escapeFlag !== '{' && escapeFlag !== '&';
 
-  let decorator = /\*/.test(open);
   return {
-    type: decorator ? 'Decorator' : 'MustacheStatement',
+    type: 'MustacheStatement',
     path,
     params,
     hash,
@@ -140,17 +143,17 @@ export function prepareBlock(openBlock, program, inverseAndProgram, close, inver
     validateClose(openBlock, close);
   }
 
-  let decorator = /\*/.test(openBlock.open);
+  if (/\*/.test(openBlock.open)) {
+    throw new Exception('Handlebars decorator blocks are not supported in Glimmer', {
+      loc: this.locInfo(locInfo),
+    });
+  }
 
   program.blockParams = openBlock.blockParams;
 
   let inverse, inverseStrip;
 
   if (inverseAndProgram) {
-    if (decorator) {
-      throw new Exception('Unexpected inverse block on decorator', inverseAndProgram);
-    }
-
     if (inverseAndProgram.chain) {
       inverseAndProgram.program.body[0].closeStrip = close.strip;
     }
@@ -166,7 +169,7 @@ export function prepareBlock(openBlock, program, inverseAndProgram, close, inver
   }
 
   return {
-    type: decorator ? 'DecoratorBlock' : 'BlockStatement',
+    type: 'BlockStatement',
     path: openBlock.path,
     params: openBlock.params,
     hash: openBlock.hash,
@@ -184,7 +187,6 @@ export function prepareProgram(statements, loc) {
     const firstLoc = statements[0].loc,
       lastLoc = statements[statements.length - 1].loc;
 
-    /* istanbul ignore else */
     if (firstLoc && lastLoc) {
       loc = {
         source: firstLoc.source,
@@ -208,17 +210,8 @@ export function prepareProgram(statements, loc) {
   };
 }
 
-export function preparePartialBlock(open, program, close, locInfo) {
-  validateClose(open, close);
-
-  return {
-    type: 'PartialBlockStatement',
-    name: open.path,
-    params: open.params,
-    hash: open.hash,
-    program,
-    openStrip: open.strip,
-    closeStrip: close && close.strip,
+export function preparePartialBlock(_open, _program, _close, locInfo) {
+  throw new Exception('Handlebars partial blocks are not supported in Glimmer', {
     loc: this.locInfo(locInfo),
-  };
+  });
 }

packages/@glimmer/syntax/lib/hbs-parser/index.js

@@ -0,0 +1 @@
+export { parse, parseWithoutProcessing } from './parse.js';

packages/@glimmer/syntax/lib/hbs-parser/parse.js

@@ -0,0 +1,64 @@
+import parser from './parser.js';
+import WhitespaceControl from './whitespace-control.js';
+import {
+  SourceLocation,
+  id,
+  stripFlags,
+  stripComment,
+  preparePath,
+  prepareMustache,
+  prepareRawBlock,
+  prepareBlock,
+  prepareProgram,
+  preparePartialBlock,
+} from './helpers.js';
+
+let baseHelpers = {
+  SourceLocation,
+  id,
+  stripFlags,
+  stripComment,
+  preparePath,
+  prepareMustache,
+  prepareRawBlock,
+  prepareBlock,
+  prepareProgram,
+  preparePartialBlock,
+};
+
+export function parseWithoutProcessing(input, options) {
+  // Just return if an already-compiled AST was passed in.
+  if (input.type === 'Program') {
+    return input;
+  }
+
+  parser.yy = baseHelpers;
+
+  parser.yy.locInfo = function (locInfo) {
+    return new SourceLocation(options && options.srcName, locInfo);
+  };
+
+  // The lexer needs a syntax.square value to decide how to handle `[`.
+  // Glimmer uses the default 'string' mode (bracket-escaped identifiers).
+  parser.yy.syntax = {
+    square: 'string',
+    hash: hashLiteralNode,
+  };
+
+  return parser.parse(input);
+}
+
+function hashLiteralNode(hash, loc) {
+  return {
+    type: 'HashLiteral',
+    pairs: hash.pairs,
+    loc,
+  };
+}
+
+export function parse(input, options) {
+  let ast = parseWithoutProcessing(input, options);
+  let strip = new WhitespaceControl(options);
+
+  return strip.accept(ast);
+}

packages/@handlebars/parser/lib/visitor.js → packages/@glimmer/syntax/lib/hbs-parser/visitor.js

@@ -8,12 +8,9 @@ Visitor.prototype = {
   constructor: Visitor,
   mutating: false,
 
-  // Visits a given value. If mutating, will replace the value if necessary.
   acceptKey: function (node, name) {
     let value = this.accept(node[name]);
     if (this.mutating) {
-      // Hacky sanity check: This may have a few false positives for type for the helper
-      // methods but will generally do the right thing without a lot of overhead.
       if (value && !Visitor.prototype[value.type]) {
         throw new Exception(
           'Unexpected node type "' +
@@ -28,8 +25,6 @@ Visitor.prototype = {
     }
   },
 
-  // Performs an accept operation with added sanity check to ensure
-  // required keys are not removed.
   acceptRequired: function (node, name) {
     this.acceptKey(node, name);
 
@@ -38,8 +33,6 @@ Visitor.prototype = {
     }
   },
 
-  // Traverses a given array. If mutating, empty responses will be removed
-  // for child elements.
   acceptArray: function (array) {
     for (let i = 0, l = array.length; i < l; i++) {
       this.acceptKey(array, i);
@@ -57,9 +50,11 @@ Visitor.prototype = {
       return;
     }
 
-    /* istanbul ignore next: Sanity code */
+    // Silently skip node types that don't have a visitor method (e.g.
+    // PartialStatement which is produced by the grammar but unsupported
+    // in Glimmer — the Glimmer visitor layer handles the error).
     if (!this[object.type]) {
-      throw new Exception('Unknown type: ' + object.type, object);
+      return;
     }
 
     if (this.current) {
@@ -83,17 +78,8 @@ Visitor.prototype = {
   },
 
   MustacheStatement: visitSubExpression,
-  Decorator: visitSubExpression,
 
   BlockStatement: visitBlock,
-  DecoratorBlock: visitBlock,
-
-  PartialStatement: visitPartial,
-  PartialBlockStatement: function (partial) {
-    visitPartial.call(this, partial);
-
-    this.acceptKey(partial, 'program');
-  },
 
   ContentStatement: function (/* content */) {},
   CommentStatement: function (/* comment */) {},
@@ -127,10 +113,5 @@ function visitBlock(block) {
   this.acceptKey(block, 'program');
   this.acceptKey(block, 'inverse');
 }
-function visitPartial(partial) {
-  this.acceptRequired(partial, 'name');
-  this.acceptArray(partial.params);
-  this.acceptKey(partial, 'hash');
-}
 
 export default Visitor;