@handlebars/parser 2.1.0 → 2.2.1

package/spec/parser.js

@@ -1,386 +1,413 @@
-import { parse, print } from '../dist/esm';
-import { equals, shouldThrow } from './utils';
+import { parse, print } from '../dist/esm/index.js';
+import { equals, equalsAst, shouldThrow } from './utils.js';
 
-describe('parser', function() {
+describe('parser', function () {
   function astFor(template) {
     let ast = parse(template);
     return print(ast);
   }
 
-  it('parses simple mustaches', function() {
-    equals(astFor('{{123}}'), '{{ NUMBER{123} [] }}\n');
-    equals(astFor('{{"foo"}}'), '{{ "foo" [] }}\n');
-    equals(astFor('{{false}}'), '{{ BOOLEAN{false} [] }}\n');
-    equals(astFor('{{true}}'), '{{ BOOLEAN{true} [] }}\n');
-    equals(astFor('{{foo}}'), '{{ PATH:foo [] }}\n');
-    equals(astFor('{{foo?}}'), '{{ PATH:foo? [] }}\n');
-    equals(astFor('{{foo_}}'), '{{ PATH:foo_ [] }}\n');
-    equals(astFor('{{foo-}}'), '{{ PATH:foo- [] }}\n');
-    equals(astFor('{{foo:}}'), '{{ PATH:foo: [] }}\n');
+  it('parses simple mustaches', function () {
+    equalsAst('{{123}}', '{{ n%123 }}');
+    equalsAst('{{"foo"}}', '{{ "foo" }}');
+    equalsAst('{{false}}', '{{ b%false }}');
+    equalsAst('{{true}}', '{{ b%true }}');
+    equalsAst('{{foo}}', '{{ p%foo }}');
+    equalsAst('{{foo?}}', '{{ p%foo? }}');
+    equalsAst('{{foo_}}', '{{ p%foo_ }}');
+    equalsAst('{{foo-}}', '{{ p%foo- }}');
+    equalsAst('{{foo:}}', '{{ p%foo: }}');
   });
 
-  it('parses simple mustaches with data', function() {
-    equals(astFor('{{@foo}}'), '{{ @PATH:foo [] }}\n');
+  it('parses simple mustaches with data', function () {
+    equalsAst('{{@foo}}', '{{ p%@foo }}');
   });
 
-  it('parses simple mustaches with data paths', function() {
-    equals(astFor('{{@../foo}}'), '{{ @PATH:foo [] }}\n');
+  it('parses simple mustaches with data paths', function () {
+    equalsAst('{{@../foo}}', '{{ p%@foo }}');
   });
 
-  it('parses mustaches with paths', function() {
-    equals(astFor('{{foo/bar}}'), '{{ PATH:foo/bar [] }}\n');
+  it('parses mustaches with paths', function () {
+    equalsAst('{{foo/bar}}', '{{ p%foo/bar }}');
+    equalsAst('{{foo.bar}}', '{{ p%foo/bar }}');
+    equalsAst('{{foo.#bar}}', '{{ p%foo/#bar }}');
+    equalsAst('{{@foo.#bar}}', '{{ p%@foo/#bar }}');
+
+    equalsAst('{{this/foo}}', '{{ p%foo }}');
+    equalsAst('{{this.foo}}', '{{ p%this.foo }}');
+    equalsAst('{{this.#foo}}', '{{ p%this.#foo }}');
   });
 
-  it('parses mustaches with this/foo', function() {
-    equals(astFor('{{this/foo}}'), '{{ PATH:foo [] }}\n');
+  it('parses mustaches with - in a path', function () {
+    equalsAst('{{foo-bar}}', '{{ p%foo-bar }}');
   });
 
-  it('parses mustaches with - in a path', function() {
-    equals(astFor('{{foo-bar}}'), '{{ PATH:foo-bar [] }}\n');
+  it('parses mustaches with escaped [] in a path', function () {
+    equalsAst('{{[foo[\\]]}}', '{{ p%foo[] }}');
   });
-  it('parses mustaches with escaped [] in a path', function() {
-    equals(astFor('{{[foo[\\]]}}'), '{{ PATH:foo[] [] }}\n');
+
+  it('parses escaped \\\\ in path', function () {
+    equalsAst('{{[foo\\\\]}}', '{{ p%foo\\ }}');
   });
-  it('parses escaped \\\\ in path', function() {
-    equals(astFor('{{[foo\\\\]}}'), '{{ PATH:foo\\ [] }}\n');
+
+  it('parses hash literals', function () {
+    equalsAst('{{(foo=bar)}}', '{{ Hash{foo=p%bar} }}');
+    equalsAst('{{(foo=bar)}}', '{{ p%@hello }}', {
+      options: {
+        syntax: {
+          hash: (hash, loc, { yy }) => {
+            return yy.preparePath(
+              true,
+              false,
+              [{ part: yy.id('hello'), original: 'hello' }],
+              loc
+            );
+          },
+        },
+      },
+    });
   });
 
-  it('parses mustaches with parameters', function() {
-    equals(astFor('{{foo bar}}'), '{{ PATH:foo [PATH:bar] }}\n');
+  it('parses array literals', function () {
+    equalsAst('{{[foo bar]}}', '{{ Array[p%foo, p%bar] }}', {
+      options: { syntax: { square: 'node' } },
+    });
+
+    equalsAst('{{[foo bar].baz}}', '{{ p%[Array[p%foo, p%bar]]/baz }}', {
+      options: { syntax: { square: 'node' } },
+    });
   });
 
-  it('parses mustaches with string parameters', function() {
-    equals(astFor('{{foo bar "baz" }}'), '{{ PATH:foo [PATH:bar, "baz"] }}\n');
+  it('parses mustaches that are hash literals', function () {
+    equalsAst('{{foo=bar}}', '{{ Hash{foo=p%bar} }}');
+    equalsAst('{{foo=bar}}', `{{ "HASH{foo=p%bar}" }}`, {
+      options: {
+        syntax: {
+          hash: (hash, loc) => {
+            return {
+              type: 'StringLiteral',
+              original: print(hash),
+              value: print(hash),
+              loc,
+            };
+          },
+        },
+      },
+    });
   });
 
-  it('parses mustaches with NUMBER parameters', function() {
-    equals(astFor('{{foo 1}}'), '{{ PATH:foo [NUMBER{1}] }}\n');
+  it('parses mustaches with parameters', function () {
+    equalsAst('{{foo bar}}', '{{ p%foo [p%bar] }}');
+    equalsAst('{{this.foo bar}}', '{{ p%this.foo [p%bar] }}');
+    equalsAst('{{this.foo this.bar}}', '{{ p%this.foo [p%this.bar] }}');
+    equalsAst('{{this.#foo this.#bar}}', '{{ p%this.#foo [p%this.#bar] }}');
+    equalsAst('{{foo.#bar foo.#baz}}', '{{ p%foo/#bar [p%foo/#baz] }}');
+    equalsAst('{{@foo.#bar @foo.#baz}}', '{{ p%@foo/#bar [p%@foo/#baz] }}');
   });
 
-  it('parses mustaches with BOOLEAN parameters', function() {
-    equals(astFor('{{foo true}}'), '{{ PATH:foo [BOOLEAN{true}] }}\n');
-    equals(astFor('{{foo false}}'), '{{ PATH:foo [BOOLEAN{false}] }}\n');
+  it('parses mustaches with string parameters', function () {
+    equalsAst('{{foo bar "baz" }}', '{{ p%foo [p%bar, "baz"] }}');
+    equalsAst('{{this.foo bar "baz" }}', '{{ p%this.foo [p%bar, "baz"] }}');
+    equalsAst('{{this.#foo bar "baz" }}', '{{ p%this.#foo [p%bar, "baz"] }}');
+    equalsAst('{{@item.#foo bar "baz" }}', '{{ p%@item/#foo [p%bar, "baz"] }}');
   });
 
-  it('parses mustaches with undefined and null paths', function() {
-    equals(astFor('{{undefined}}'), '{{ UNDEFINED [] }}\n');
-    equals(astFor('{{null}}'), '{{ NULL [] }}\n');
+  it('parses mustaches with NUMBER parameters', function () {
+    equalsAst('{{foo 1}}', '{{ p%foo [n%1] }}');
+    equalsAst('{{this.foo 1}}', '{{ p%this.foo [n%1] }}');
+    equalsAst('{{this.#foo 1}}', '{{ p%this.#foo [n%1] }}');
   });
-  it('parses mustaches with undefined and null parameters', function() {
-    equals(
-      astFor('{{foo undefined null}}'),
-      '{{ PATH:foo [UNDEFINED, NULL] }}\n'
-    );
+
+  it('parses mustaches with BOOLEAN parameters', function () {
+    equalsAst('{{foo true}}', '{{ p%foo [b%true] }}');
+    equalsAst('{{foo false}}', '{{ p%foo [b%false] }}');
   });
 
-  it('parses mustaches with DATA parameters', function() {
-    equals(astFor('{{foo @bar}}'), '{{ PATH:foo [@PATH:bar] }}\n');
+  it('parses mustaches with undefined and null paths', function () {
+    equalsAst('{{undefined}}', '{{ UNDEFINED }}');
+    equalsAst('{{null}}', '{{ NULL }}');
   });
 
-  it('parses mustaches with hash arguments', function() {
-    equals(astFor('{{foo bar=baz}}'), '{{ PATH:foo [] HASH{bar=PATH:baz} }}\n');
-    equals(astFor('{{foo bar=1}}'), '{{ PATH:foo [] HASH{bar=NUMBER{1}} }}\n');
-    equals(
-      astFor('{{foo bar=true}}'),
-      '{{ PATH:foo [] HASH{bar=BOOLEAN{true}} }}\n'
-    );
-    equals(
-      astFor('{{foo bar=false}}'),
-      '{{ PATH:foo [] HASH{bar=BOOLEAN{false}} }}\n'
-    );
-    equals(
-      astFor('{{foo bar=@baz}}'),
-      '{{ PATH:foo [] HASH{bar=@PATH:baz} }}\n'
-    );
+  it('parses mustaches with undefined and null parameters', function () {
+    equalsAst('{{foo undefined null}}', '{{ p%foo [UNDEFINED, NULL] }}');
+  });
 
-    equals(
-      astFor('{{foo bar=baz bat=bam}}'),
-      '{{ PATH:foo [] HASH{bar=PATH:baz, bat=PATH:bam} }}\n'
+  it('parses mustaches with DATA parameters', function () {
+    equalsAst('{{foo @bar}}', '{{ p%foo [p%@bar] }}');
+  });
+
+  it('parses mustaches with hash arguments', function () {
+    equalsAst('{{foo bar=baz}}', '{{ p%foo HASH{bar=p%baz} }}');
+    equalsAst('{{foo bar=1}}', '{{ p%foo HASH{bar=n%1} }}');
+    equalsAst('{{foo bar=true}}', '{{ p%foo HASH{bar=b%true} }}');
+    equalsAst('{{foo bar=false}}', '{{ p%foo HASH{bar=b%false} }}');
+    equalsAst('{{foo bar=@baz}}', '{{ p%foo HASH{bar=p%@baz} }}');
+
+    equalsAst(
+      '{{foo bar=baz bat=bam}}',
+      '{{ p%foo HASH{bar=p%baz bat=p%bam} }}'
     );
-    equals(
-      astFor('{{foo bar=baz bat="bam"}}'),
-      '{{ PATH:foo [] HASH{bar=PATH:baz, bat="bam"} }}\n'
+    equalsAst(
+      '{{foo bar=baz bat="bam"}}',
+      '{{ p%foo HASH{bar=p%baz bat="bam"} }}'
     );
 
-    equals(astFor("{{foo bat='bam'}}"), '{{ PATH:foo [] HASH{bat="bam"} }}\n');
+    equalsAst("{{foo bat='bam'}}", '{{ p%foo HASH{bat="bam"} }}');
 
-    equals(
-      astFor('{{foo omg bar=baz bat="bam"}}'),
-      '{{ PATH:foo [PATH:omg] HASH{bar=PATH:baz, bat="bam"} }}\n'
+    equalsAst(
+      '{{foo omg bar=baz bat="bam"}}',
+      '{{ p%foo [p%omg] HASH{bar=p%baz bat="bam"} }}'
     );
-    equals(
-      astFor('{{foo omg bar=baz bat="bam" baz=1}}'),
-      '{{ PATH:foo [PATH:omg] HASH{bar=PATH:baz, bat="bam", baz=NUMBER{1}} }}\n'
+    equalsAst(
+      '{{foo omg bar=baz bat="bam" baz=1}}',
+      '{{ p%foo [p%omg] HASH{bar=p%baz bat="bam" baz=n%1} }}'
     );
-    equals(
-      astFor('{{foo omg bar=baz bat="bam" baz=true}}'),
-      '{{ PATH:foo [PATH:omg] HASH{bar=PATH:baz, bat="bam", baz=BOOLEAN{true}} }}\n'
+    equalsAst(
+      '{{foo omg bar=baz bat="bam" baz=true}}',
+      '{{ p%foo [p%omg] HASH{bar=p%baz bat="bam" baz=b%true} }}'
     );
-    equals(
-      astFor('{{foo omg bar=baz bat="bam" baz=false}}'),
-      '{{ PATH:foo [PATH:omg] HASH{bar=PATH:baz, bat="bam", baz=BOOLEAN{false}} }}\n'
+    equalsAst(
+      '{{foo omg bar=baz bat="bam" baz=false}}',
+      '{{ p%foo [p%omg] HASH{bar=p%baz bat="bam" baz=b%false} }}'
     );
   });
 
-  it('parses contents followed by a mustache', function() {
-    equals(
-      astFor('foo bar {{baz}}'),
-      "CONTENT[ 'foo bar ' ]\n{{ PATH:baz [] }}\n"
-    );
+  it('parses contents followed by a mustache', function () {
+    equalsAst('foo bar {{baz}}', "CONTENT[ 'foo bar ' ]\n{{ p%baz }}");
   });
 
-  it('parses a partial', function() {
-    equals(astFor('{{> foo }}'), '{{> PARTIAL:foo }}\n');
-    equals(astFor('{{> "foo" }}'), '{{> PARTIAL:foo }}\n');
-    equals(astFor('{{> 1 }}'), '{{> PARTIAL:1 }}\n');
+  it('parses a partial', function () {
+    equalsAst('{{> foo }}', '{{> PARTIAL:foo }}');
+    equalsAst('{{> "foo" }}', '{{> PARTIAL:foo }}');
+    equalsAst('{{> 1 }}', '{{> PARTIAL:1 }}');
   });
 
-  it('parses a partial with context', function() {
-    equals(astFor('{{> foo bar}}'), '{{> PARTIAL:foo PATH:bar }}\n');
+  it('parses a partial with context', function () {
+    equalsAst('{{> foo bar}}', '{{> PARTIAL:foo p%bar }}');
   });
 
-  it('parses a partial with hash', function() {
-    equals(
-      astFor('{{> foo bar=bat}}'),
-      '{{> PARTIAL:foo HASH{bar=PATH:bat} }}\n'
-    );
+  it('parses a partial with hash', function () {
+    equalsAst('{{> foo bar=bat}}', '{{> PARTIAL:foo HASH{bar=p%bat} }}');
   });
 
-  it('parses a partial with context and hash', function() {
-    equals(
-      astFor('{{> foo bar bat=baz}}'),
-      '{{> PARTIAL:foo PATH:bar HASH{bat=PATH:baz} }}\n'
+  it('parses a partial with context and hash', function () {
+    equalsAst(
+      '{{> foo bar bat=baz}}',
+      '{{> PARTIAL:foo p%bar HASH{bat=p%baz} }}'
     );
   });
 
-  it('parses a partial with a complex name', function() {
-    equals(
-      astFor('{{> shared/partial?.bar}}'),
-      '{{> PARTIAL:shared/partial?.bar }}\n'
+  it('parses a partial with a complex name', function () {
+    equalsAst(
+      '{{> shared/partial?.bar}}',
+      '{{> PARTIAL:shared/partial?.bar }}'
     );
   });
 
-  it('parsers partial blocks', function() {
-    equals(
-      astFor('{{#> foo}}bar{{/foo}}'),
-      "{{> PARTIAL BLOCK:foo PROGRAM:\n  CONTENT[ 'bar' ]\n }}\n"
+  it('parsers partial blocks', function () {
+    equalsAst(
+      '{{#> foo}}bar{{/foo}}',
+      "{{> PARTIAL BLOCK:foo PROGRAM:\n  CONTENT[ 'bar' ]\n }}"
     );
   });
-  it('should handle parser block mismatch', function() {
+  it('should handle parser block mismatch', function () {
     shouldThrow(
-      function() {
+      function () {
         astFor('{{#> goodbyes}}{{/hellos}}');
       },
       Error,
       /goodbyes doesn't match hellos/
     );
   });
-  it('parsers partial blocks with arguments', function() {
-    equals(
-      astFor('{{#> foo context hash=value}}bar{{/foo}}'),
-      "{{> PARTIAL BLOCK:foo PATH:context HASH{hash=PATH:value} PROGRAM:\n  CONTENT[ 'bar' ]\n }}\n"
+  it('parsers partial blocks with arguments', function () {
+    equalsAst(
+      '{{#> foo context hash=value}}bar{{/foo}}',
+      "{{> PARTIAL BLOCK:foo p%context HASH{hash=p%value} PROGRAM:\n  CONTENT[ 'bar' ]\n }}"
     );
   });
 
-  it('parses a comment', function() {
-    equals(
-      astFor('{{! this is a comment }}'),
-      "{{! ' this is a comment ' }}\n"
-    );
+  it('parses a comment', function () {
+    equalsAst('{{! this is a comment }}', "{{! ' this is a comment ' }}");
   });
 
-  it('parses a multi-line comment', function() {
-    equals(
-      astFor('{{!\nthis is a multi-line comment\n}}'),
-      "{{! '\nthis is a multi-line comment\n' }}\n"
+  it('parses a multi-line comment', function () {
+    equalsAst(
+      '{{!\nthis is a multi-line comment\n}}',
+      "{{! '\nthis is a multi-line comment\n' }}"
     );
   });
 
-  it('parses an inverse section', function() {
-    equals(
-      astFor('{{#foo}} bar {{^}} baz {{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    CONTENT[ ' baz ' ]\n"
+  it('parses an inverse section', function () {
+    equalsAst(
+      '{{#foo}} bar {{^}} baz {{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    CONTENT[ ' baz ' ]"
     );
   });
 
-  it('parses an inverse (else-style) section', function() {
-    equals(
-      astFor('{{#foo}} bar {{else}} baz {{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    CONTENT[ ' baz ' ]\n"
+  it('parses an inverse (else-style) section', function () {
+    equalsAst(
+      '{{#foo}} bar {{else}} baz {{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    CONTENT[ ' baz ' ]"
     );
   });
 
-  it('parses multiple inverse sections', function() {
-    equals(
-      astFor('{{#foo}} bar {{else if bar}}{{else}} baz {{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    BLOCK:\n      PATH:if [PATH:bar]\n      PROGRAM:\n      {{^}}\n        CONTENT[ ' baz ' ]\n"
+  it('parses multiple inverse sections', function () {
+    equalsAst(
+      '{{#foo}} bar {{else if bar}}{{else}} baz {{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n    BLOCK:\n      p%if [p%bar]\n      PROGRAM:\n      {{^}}\n        CONTENT[ ' baz ' ]"
     );
   });
 
-  it('parses empty blocks', function() {
-    equals(astFor('{{#foo}}{{/foo}}'), 'BLOCK:\n  PATH:foo []\n  PROGRAM:\n');
+  it('parses empty blocks', function () {
+    equalsAst('{{#foo}}{{/foo}}', 'BLOCK:\n  p%foo\n  PROGRAM:');
   });
 
-  it('parses empty blocks with empty inverse section', function() {
-    equals(
-      astFor('{{#foo}}{{^}}{{/foo}}'),
-      'BLOCK:\n  PATH:foo []\n  PROGRAM:\n  {{^}}\n'
-    );
+  it('parses empty blocks with empty inverse section', function () {
+    equalsAst('{{#foo}}{{^}}{{/foo}}', 'BLOCK:\n  p%foo\n  PROGRAM:\n  {{^}}');
   });
 
-  it('parses empty blocks with empty inverse (else-style) section', function() {
-    equals(
-      astFor('{{#foo}}{{else}}{{/foo}}'),
-      'BLOCK:\n  PATH:foo []\n  PROGRAM:\n  {{^}}\n'
+  it('parses empty blocks with empty inverse (else-style) section', function () {
+    equalsAst(
+      '{{#foo}}{{else}}{{/foo}}',
+      'BLOCK:\n  p%foo\n  PROGRAM:\n  {{^}}'
     );
   });
 
-  it('parses non-empty blocks with empty inverse section', function() {
-    equals(
-      astFor('{{#foo}} bar {{^}}{{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n"
+  it('parses non-empty blocks with empty inverse section', function () {
+    equalsAst(
+      '{{#foo}} bar {{^}}{{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}"
     );
   });
 
-  it('parses non-empty blocks with empty inverse (else-style) section', function() {
-    equals(
-      astFor('{{#foo}} bar {{else}}{{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}\n"
+  it('parses non-empty blocks with empty inverse (else-style) section', function () {
+    equalsAst(
+      '{{#foo}} bar {{else}}{{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n    CONTENT[ ' bar ' ]\n  {{^}}"
     );
   });
 
-  it('parses empty blocks with non-empty inverse section', function() {
-    equals(
-      astFor('{{#foo}}{{^}} bar {{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n  {{^}}\n    CONTENT[ ' bar ' ]\n"
+  it('parses empty blocks with non-empty inverse section', function () {
+    equalsAst(
+      '{{#foo}}{{^}} bar {{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n  {{^}}\n    CONTENT[ ' bar ' ]"
     );
   });
 
-  it('parses empty blocks with non-empty inverse (else-style) section', function() {
-    equals(
-      astFor('{{#foo}}{{else}} bar {{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n  {{^}}\n    CONTENT[ ' bar ' ]\n"
+  it('parses empty blocks with non-empty inverse (else-style) section', function () {
+    equalsAst(
+      '{{#foo}}{{else}} bar {{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n  {{^}}\n    CONTENT[ ' bar ' ]"
     );
   });
 
-  it('parses a standalone inverse section', function() {
-    equals(
-      astFor('{{^foo}}bar{{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  {{^}}\n    CONTENT[ 'bar' ]\n"
+  it('parses a standalone inverse section', function () {
+    equalsAst(
+      '{{^foo}}bar{{/foo}}',
+      "BLOCK:\n  p%foo\n  {{^}}\n    CONTENT[ 'bar' ]"
     );
   });
-  it('throws on old inverse section', function() {
-    shouldThrow(function() {
+
+  it('throws on old inverse section', function () {
+    shouldThrow(function () {
       astFor('{{else foo}}bar{{/foo}}');
     }, Error);
   });
 
-  it('parses block with block params', function() {
-    equals(
-      astFor('{{#foo as |bar baz|}}content{{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n    BLOCK PARAMS: [ bar baz ]\n    CONTENT[ 'content' ]\n"
+  it('parses block with block params', function () {
+    equalsAst(
+      '{{#foo as |bar baz|}}content{{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n    BLOCK PARAMS: [ bar baz ]\n    CONTENT[ 'content' ]"
     );
   });
 
-  it('parses mustaches with sub-expressions as the callable', function() {
-    equals(
-      astFor('{{(my-helper foo)}}'),
-      '{{ PATH:my-helper [PATH:foo] [] }}\n'
-    );
+  it('parses mustaches with sub-expressions as the callable', function () {
+    equalsAst('{{(my-helper foo)}}', '{{ (p%my-helper [p%foo]) }}');
   });
 
-  it('parses mustaches with sub-expressions as the callable (with args)', function() {
-    equals(
-      astFor('{{(my-helper foo) bar}}'),
-      '{{ PATH:my-helper [PATH:foo] [PATH:bar] }}\n'
-    );
+  it('parses mustaches with sub-expressions as the callable (with args)', function () {
+    equalsAst('{{(my-helper foo) bar}}', '{{ (p%my-helper [p%foo]) [p%bar] }}');
   });
 
-  it('parses sub-expressions with a sub-expression as the callable', function() {
-    equals(
-      astFor('{{((my-helper foo))}}'),
-      '{{ PATH:my-helper [PATH:foo] [] [] }}\n'
-    );
+  it('parses sub-expressions with a sub-expression as the callable', function () {
+    equalsAst('{{((my-helper foo))}}', '{{ ((p%my-helper [p%foo])) }}');
   });
 
-  it('parses sub-expressions with a sub-expression as the callable (with args)', function() {
-    equals(
-      astFor('{{((my-helper foo) bar)}}'),
-      '{{ PATH:my-helper [PATH:foo] [PATH:bar] [] }}\n'
+  it('parses sub-expressions with a sub-expression as the callable (with args)', function () {
+    equalsAst(
+      '{{((my-helper foo) bar)}}',
+      '{{ ((p%my-helper [p%foo]) [p%bar]) }}'
     );
   });
 
-  it('parses arguments with a sub-expression as the callable (with args)', function() {
-    equals(
-      astFor('{{my-helper ((foo) bar) baz=((foo bar))}}'),
-      '{{ PATH:my-helper [PATH:foo [] [PATH:bar]] HASH{baz=PATH:foo [PATH:bar] []} }}\n'
+  it('parses arguments with a sub-expression as the callable (with args)', function () {
+    equalsAst(
+      '{{my-helper ((foo) bar) baz=((foo bar))}}',
+      '{{ p%my-helper [((p%foo) [p%bar])] HASH{baz=((p%foo [p%bar]))} }}'
     );
   });
 
-  it('parses paths with sub-expressions as the root', function() {
-    equals(
-      astFor('{{(my-helper foo).bar}}'),
-      '{{ PATH:[PATH:my-helper [PATH:foo]]/bar [] }}\n'
-    );
+  it('parses paths with sub-expressions as the root', function () {
+    equalsAst('{{(my-helper foo).bar}}', '{{ p%[(p%my-helper [p%foo])]/bar }}');
   });
 
-  it('parses paths with sub-expressions as the root as a callable', function() {
-    equals(
-      astFor('{{((my-helper foo).bar baz)}}'),
-      '{{ PATH:[PATH:my-helper [PATH:foo]]/bar [PATH:baz] [] }}\n'
+  it('parses paths with sub-expressions as the root as a callable', function () {
+    equalsAst(
+      '{{((my-helper foo).bar baz)}}',
+      '{{ (p%[(p%my-helper [p%foo])]/bar [p%baz]) }}'
     );
   });
 
-  it('parses paths with sub-expressions as the root as an argument', function() {
-    equals(
-      astFor('{{(foo (my-helper bar).baz)}}'),
-      '{{ PATH:foo [PATH:[PATH:my-helper [PATH:bar]]/baz] [] }}\n'
+  it('parses paths with sub-expressions as the root as an argument', function () {
+    equalsAst(
+      '{{(foo (my-helper bar).baz)}}',
+      '{{ (p%foo [p%[(p%my-helper [p%bar])]/baz]) }}'
     );
   });
 
-  it('parses paths with sub-expressions as the root as a named argument', function() {
-    equals(
-      astFor('{{(foo bar=(my-helper baz).qux)}}'),
-      '{{ PATH:foo [] HASH{bar=PATH:[PATH:my-helper [PATH:baz]]/qux} [] }}\n'
+  it('parses paths with sub-expressions as the root as a named argument', function () {
+    equalsAst(
+      '{{(foo bar=(my-helper baz).qux)}}',
+      '{{ (p%foo HASH{bar=p%[(p%my-helper [p%baz])]/qux}) }}'
     );
   });
 
-  it('parses inverse block with block params', function() {
-    equals(
-      astFor('{{^foo as |bar baz|}}content{{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  {{^}}\n    BLOCK PARAMS: [ bar baz ]\n    CONTENT[ 'content' ]\n"
+  it('parses inverse block with block params', function () {
+    equalsAst(
+      '{{^foo as |bar baz|}}content{{/foo}}',
+      "BLOCK:\n  p%foo\n  {{^}}\n    BLOCK PARAMS: [ bar baz ]\n    CONTENT[ 'content' ]"
     );
   });
-  it('parses chained inverse block with block params', function() {
-    equals(
-      astFor('{{#foo}}{{else foo as |bar baz|}}content{{/foo}}'),
-      "BLOCK:\n  PATH:foo []\n  PROGRAM:\n  {{^}}\n    BLOCK:\n      PATH:foo []\n      PROGRAM:\n        BLOCK PARAMS: [ bar baz ]\n        CONTENT[ 'content' ]\n"
+  it('parses chained inverse block with block params', function () {
+    equalsAst(
+      '{{#foo}}{{else foo as |bar baz|}}content{{/foo}}',
+      "BLOCK:\n  p%foo\n  PROGRAM:\n  {{^}}\n    BLOCK:\n      p%foo\n      PROGRAM:\n        BLOCK PARAMS: [ bar baz ]\n        CONTENT[ 'content' ]"
     );
   });
-  it("raises if there's a Parse error", function() {
+  it("raises if there's a Parse error", function () {
     shouldThrow(
-      function() {
+      function () {
         astFor('foo{{^}}bar');
       },
       Error,
       /Parse error on line 1/
     );
     shouldThrow(
-      function() {
+      function () {
         astFor('{{foo}');
       },
       Error,
       /Parse error on line 1/
     );
     shouldThrow(
-      function() {
+      function () {
         astFor('{{foo &}}');
       },
       Error,
       /Parse error on line 1/
     );
     shouldThrow(
-      function() {
+      function () {
         astFor('{{#goodbyes}}{{/hellos}}');
       },
       Error,
@@ -388,7 +415,7 @@ describe('parser', function() {
     );
 
     shouldThrow(
-      function() {
+      function () {
         astFor('{{{{goodbyes}}}} {{{{/hellos}}}}');
       },
       Error,
@@ -396,23 +423,23 @@ describe('parser', function() {
     );
   });
 
-  it('should handle invalid paths', function() {
+  it('should handle invalid paths', function () {
     shouldThrow(
-      function() {
+      function () {
         astFor('{{foo/../bar}}');
       },
       Error,
       /Invalid path: foo\/\.\. - 1:2/
     );
     shouldThrow(
-      function() {
+      function () {
         astFor('{{foo/./bar}}');
       },
       Error,
       /Invalid path: foo\/\. - 1:2/
     );
     shouldThrow(
-      function() {
+      function () {
         astFor('{{foo/this/bar}}');
       },
       Error,
@@ -420,16 +447,16 @@ describe('parser', function() {
     );
   });
 
-  it('knows how to report the correct line number in errors', function() {
+  it('knows how to report the correct line number in errors', function () {
     shouldThrow(
-      function() {
+      function () {
         astFor('hello\nmy\n{{foo}');
       },
       Error,
       /Parse error on line 3/
     );
     shouldThrow(
-      function() {
+      function () {
         astFor('hello\n\nmy\n\n{{foo}');
       },
       Error,
@@ -437,9 +464,9 @@ describe('parser', function() {
     );
   });
 
-  it('knows how to report the correct line number in errors when the first character is a newline', function() {
+  it('knows how to report the correct line number in errors when the first character is a newline', function () {
     shouldThrow(
-      function() {
+      function () {
         astFor('\n\nhello\n\nmy\n\n{{foo}');
       },
       Error,
@@ -447,31 +474,28 @@ describe('parser', function() {
     );
   });
 
-  describe('externally compiled AST', function() {
-    it('can pass through an already-compiled AST', function() {
+  describe('externally compiled AST', function () {
+    it('can pass through an already-compiled AST', function () {
       equals(
         astFor({
           type: 'Program',
-          body: [{ type: 'ContentStatement', value: 'Hello' }]
+          body: [{ type: 'ContentStatement', value: 'Hello' }],
         }),
         "CONTENT[ 'Hello' ]\n"
       );
     });
   });
 
-  describe('directives', function() {
-    it('should parse block directives', function() {
-      equals(
-        astFor('{{#* foo}}{{/foo}}'),
-        'DIRECTIVE BLOCK:\n  PATH:foo []\n  PROGRAM:\n'
-      );
+  describe('directives', function () {
+    it('should parse block directives', function () {
+      equalsAst('{{#* foo}}{{/foo}}', 'DIRECTIVE BLOCK:\n  p%foo\n  PROGRAM:');
     });
-    it('should parse directives', function() {
-      equals(astFor('{{* foo}}'), '{{ DIRECTIVE PATH:foo [] }}\n');
+    it('should parse directives', function () {
+      equalsAst('{{* foo}}', '{{ DIRECTIVE p%foo }}');
     });
-    it('should fail if directives have inverse', function() {
+    it('should fail if directives have inverse', function () {
       shouldThrow(
-        function() {
+        function () {
           astFor('{{#* foo}}{{^}}{{/foo}}');
         },
         Error,
@@ -480,7 +504,7 @@ describe('parser', function() {
     });
   });
 
-  it('GH1024 - should track program location properly', function() {
+  it('GH1024 - should track program location properly', function () {
     let p = parse(
       '\n' +
         '  {{#if foo}}\n' +
@@ -496,21 +520,21 @@ describe('parser', function() {
       JSON.stringify(p.loc),
       JSON.stringify({
         start: { line: 1, column: 0 },
-        end: { line: 7, column: 4 }
+        end: { line: 7, column: 4 },
       })
     );
     equals(
       JSON.stringify(p.body[1].program.loc),
       JSON.stringify({
         start: { line: 2, column: 13 },
-        end: { line: 4, column: 7 }
+        end: { line: 4, column: 7 },
       })
     );
     equals(
       JSON.stringify(p.body[1].inverse.loc),
       JSON.stringify({
         start: { line: 4, column: 15 },
-        end: { line: 6, column: 5 }
+        end: { line: 6, column: 5 },
       })
     );
   });