Refactored syntax validation tracking

glimmerjs · Feb 23, 2025 · 0683762 · 0683762
1 parent c13ab39
commit 0683762
Show file tree

Hide file tree

Showing 29 changed files with 1,271 additions and 705 deletions.
diff --git a/packages/@glimmer-workspace/integration-tests/lib/harness/tweaks.css b/packages/@glimmer-workspace/integration-tests/lib/harness/tweaks.css
@@ -0,0 +1,4 @@
+pre {
+  line-height: 1.2;
+  font-family: ui-monospace, 'Cascadia Mono', 'Segoe UI Mono', 'Noto Sans Mono', monospace;
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/setup-harness.ts b/packages/@glimmer-workspace/integration-tests/lib/setup-harness.ts
@@ -33,6 +33,7 @@ export async function bootQunit(
 export async function setupQunit() {
   const qunitLib: QUnit = await import('qunit');
   await import('qunit/qunit/qunit.css');
+  await import('./harness/tweaks.css');
 
   const testing = Testing.withConfig(
     {

diff --git a/packages/@glimmer-workspace/integration-tests/test/modifiers/dynamic-modifiers-test.ts b/packages/@glimmer-workspace/integration-tests/test/modifiers/dynamic-modifiers-test.ts
@@ -151,7 +151,7 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
 
   @test
   'Cannot invoke a modifier definition based on this fallback lookup in resolution mode'() {
-    this.registerComponent('TemplateOnly', 'Bar', '<div {{x.foo}}></div>');
+    this.registerComponent('TemplateOnly', 'Bar', `<div\n  {{x.foo}}></div>`);
 
     this.assert.throws(
       () => {

diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts
@@ -1,9 +1,6 @@
 import { CURRIED_COMPONENT, CURRIED_HELPER } from '@glimmer/constants';
 import { ASTv2, generateSyntaxError, src } from '@glimmer/syntax';
 
-import type { NormalizationState } from '../context';
-import type { ContentKeywordMatch } from './impl';
-
 import { Err, Ok, Result } from '../../../shared/result';
 import * as mir from '../../2-encoding/mir';
 import { visitCurlyArgs, visitExpr, visitPositional } from '../visitors/expressions';
@@ -51,19 +48,11 @@ export const APPEND_KEYWORDS = keywords('Append')
       }
     },
 
-    translate(
-      { node, state }: { node: ContentKeywordMatch; state: NormalizationState },
-      {
-        target,
-        positional,
-      }: {
-        target: src.SourceSlice;
-        positional: ASTv2.PositionalArguments;
-      }
-    ): Result<mir.Content> {
+    translate({ node, keyword, state }, { target, positional }): Result<mir.Content> {
       return visitPositional(positional, state).mapOk(
         (positional) =>
           new mir.Yield({
+            keyword,
             loc: node.loc,
             target,
             to: state.scope.allocateBlock(target.chars),
@@ -89,15 +78,15 @@ export const APPEND_KEYWORDS = keywords('Append')
       }
     },
 
-    translate({ node, state: { scope } }): Result<mir.Content> {
-      return Ok(new mir.Debugger({ loc: node.loc, scope }));
+    translate({ node, keyword, state: { scope } }): Result<mir.Content> {
+      return Ok(new mir.Debugger({ keyword, loc: node.loc, scope }));
     },
   })
   .kw('component', {
     assert: assertCurryKeyword(CURRIED_COMPONENT),
 
     translate(
-      { node, state },
+      { node, keyword, state },
       { definition, args }
     ): Result<mir.InvokeComponentKeyword | mir.InvokeResolvedComponentKeyword> {
       let definitionResult = visitExpr(definition, state);
@@ -116,6 +105,7 @@ export const APPEND_KEYWORDS = keywords('Append')
 
           return Ok(
             new mir.InvokeResolvedComponentKeyword({
+              keyword,
               loc: node.loc,
               definition: definition.value,
               args,
@@ -125,6 +115,7 @@ export const APPEND_KEYWORDS = keywords('Append')
 
         return Ok(
           new mir.InvokeComponentKeyword({
+            keyword,
             loc: node.loc,
             definition,
             args,

diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/block.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/block.ts
@@ -6,8 +6,8 @@ import { Err, Ok, Result } from '../../../shared/result';
 import * as mir from '../../2-encoding/mir';
 import {
   visitCurlyArgs,
+  visitCurlyNamedArguments,
   visitExpr,
-  visitNamedArguments,
   visitPositional,
 } from '../visitors/expressions';
 import { visitNamedBlock, visitNamedBlocks } from '../visitors/statements';
@@ -17,7 +17,7 @@ import { assertCurryKeyword } from './utils/curry';
 export const BLOCK_KEYWORDS = keywords('Block')
   .kw('in-element', {
     assert(node): Result<{
-      insertBefore: ASTv2.ExpressionValueNode | null;
+      insertBefore: ASTv2.CurlyArgument | null;
       destination: ASTv2.ExpressionValueNode;
     }> {
       let { args } = node;
@@ -28,7 +28,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
         return Err(generateSyntaxError(`Cannot pass \`guid\` to \`{{#in-element}}\``, guid.loc));
       }
 
-      let insertBefore = args.get('insertBefore');
+      let insertBefore = args.getNode('insertBefore');
       let destination = args.nth(0);
 
       if (destination === null) {
@@ -45,7 +45,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
       return Ok({ insertBefore, destination });
     },
 
-    translate({ node, state }, { insertBefore, destination }): Result<mir.InElement> {
+    translate({ node, keyword, state }, { insertBefore, destination }): Result<mir.InElement> {
       let named = node.blocks.get('default');
       let body = visitNamedBlock(named, state);
       let destinationResult = visitExpr(destination, state);
@@ -55,13 +55,13 @@ export const BLOCK_KEYWORDS = keywords('Block')
           ([body, destination]): Result<{
             body: mir.NamedBlock;
             destination: mir.ExpressionValueNode;
-            insertBefore: mir.ExpressionValueNode | mir.Missing;
+            insertBefore: mir.CustomNamedArgument<mir.ExpressionValueNode> | mir.Missing;
           }> => {
             if (insertBefore) {
-              return visitExpr(insertBefore, state).mapOk((insertBefore) => ({
+              return visitExpr(insertBefore.value, state).mapOk((insertBeforeValue) => ({
                 body,
                 destination,
-                insertBefore,
+                insertBefore: mir.CustomNamedArgument.from(insertBefore, insertBeforeValue),
               }));
             } else {
               return Ok({
@@ -77,6 +77,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
         .mapOk(
           ({ body, destination, insertBefore }) =>
             new mir.InElement({
+              keyword,
               loc: node.loc,
               block: body,
               insertBefore,
@@ -126,7 +127,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
       return Ok({ condition });
     },
 
-    translate({ node, state }, { condition }): Result<mir.IfContent> {
+    translate({ node, keyword, state }, { condition }): Result<mir.IfContent> {
       let block = node.blocks.get('default');
       let inverse = node.blocks.get('else');
 
@@ -137,6 +138,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
       return Result.all(conditionResult, blockResult, inverseResult).mapOk(
         ([condition, block, inverse]) =>
           new mir.IfContent({
+            keyword,
             loc: node.loc,
             condition,
             block,
@@ -185,7 +187,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
       return Ok({ condition });
     },
 
-    translate({ node, state }, { condition }): Result<mir.IfContent> {
+    translate({ node, keyword, state }, { condition }): Result<mir.IfContent> {
       let block = node.blocks.get('default');
       let inverse = node.blocks.get('else');
 
@@ -196,6 +198,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
       return Result.all(conditionResult, blockResult, inverseResult).mapOk(
         ([condition, block, inverse]) =>
           new mir.IfContent({
+            keyword,
             loc: node.loc,
             condition: new mir.Not({ value: condition, loc: node.loc }),
             block,
@@ -207,7 +210,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
   .kw('each', {
     assert(node): Result<{
       value: ASTv2.ExpressionValueNode;
-      key: ASTv2.ExpressionValueNode | null;
+      key: ASTv2.CurlyArgument | null;
     }> {
       let { args } = node;
 
@@ -233,7 +236,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
       }
 
       let value = args.nth(0);
-      let key = args.get('key');
+      let key = args.getNode('key');
 
       if (value === null) {
         return Err(
@@ -247,22 +250,24 @@ export const BLOCK_KEYWORDS = keywords('Block')
       return Ok({ value, key });
     },
 
-    translate({ node, state }, { value, key }): Result<mir.Each> {
+    translate({ node, keyword, state }, { value, key }): Result<mir.Each> {
       let block = node.blocks.get('default');
       let inverse = node.blocks.get('else');
 
       let valueResult = visitExpr(value, state);
-      let keyResult = key ? visitExpr(key, state) : Ok(null);
+      let keyResult = key ? visitExpr(key.value, state) : Ok(null);
 
       let blockResult = visitNamedBlock(block, state);
       let inverseResult = inverse ? visitNamedBlock(inverse, state) : Ok(null);
 
       return Result.all(valueResult, keyResult, blockResult, inverseResult).mapOk(
-        ([value, key, block, inverse]) =>
+        ([value, keyExpr, block, inverse]) =>
           new mir.Each({
+            keyword,
             loc: node.loc,
             value,
-            key,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            key: keyExpr ? mir.CustomNamedArgument.from(key!, keyExpr) : null,
             block,
             inverse,
           })
@@ -304,7 +309,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
       return Ok({ positional });
     },
 
-    translate({ node, state }, { positional }): Result<mir.Let> {
+    translate({ node, keyword, state }, { positional }): Result<mir.Let> {
       let block = node.blocks.get('default');
 
       let positionalResult = visitPositional(positional, state);
@@ -313,6 +318,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
       return Result.all(positionalResult, blockResult).mapOk(
         ([positional, block]) =>
           new mir.Let({
+            keyword,
             loc: node.loc,
             positional,
             block,
@@ -333,15 +339,16 @@ export const BLOCK_KEYWORDS = keywords('Block')
       }
     },
 
-    translate({ node, state }, { named }): Result<mir.WithDynamicVars> {
+    translate({ node, keyword, state }, { named }): Result<mir.WithDynamicVars> {
       let block = node.blocks.get('default');
 
-      let namedResult = visitNamedArguments(named, state);
+      let namedResult = visitCurlyNamedArguments(named, state);
       let blockResult = visitNamedBlock(block, state);
 
       return Result.all(namedResult, blockResult).mapOk(
         ([named, block]) =>
           new mir.WithDynamicVars({
+            keyword,
             loc: node.loc,
             named,
             block,
@@ -353,7 +360,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
     assert: assertCurryKeyword(CURRIED_COMPONENT),
 
     translate(
-      { node, state },
+      { node, keyword, state },
       { definition, args }
     ): Result<mir.InvokeComponentKeyword | mir.InvokeResolvedComponentKeyword> {
       let definitionResult = visitExpr(definition, state);
@@ -374,6 +381,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
 
             return Ok(
               new mir.InvokeResolvedComponentKeyword({
+                keyword,
                 loc: node.loc,
                 definition: definition.value,
                 args,
@@ -384,6 +392,7 @@ export const BLOCK_KEYWORDS = keywords('Block')
 
           return Ok(
             new mir.InvokeComponentKeyword({
+              keyword,
               loc: node.loc,
               definition,
               args,

diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts
@@ -10,6 +10,7 @@ import { Err } from '../../../shared/result';
 export interface KeywordInfo<Match extends KeywordMatch> {
   node: Match;
   loc: SourceSpan;
+  keyword: SourceSpan;
   state: NormalizationState;
   args: ASTv2.CurlyArgs;
 }
@@ -60,9 +61,10 @@ class KeywordImpl<
   translate(node: KeywordMatches[K], state: NormalizationState): Result<Out> | null {
     if (this.match(node)) {
       const args = getKeywordArgs(node);
-      let param = this.delegate.assert({ node, loc: node.loc, state, args });
+      const keyword = node.resolved.loc;
+      let param = this.delegate.assert({ node, keyword, loc: node.loc, state, args });
       return param.andThen((param) =>
-        this.delegate.translate({ node, loc: node.loc, state, args }, param)
+        this.delegate.translate({ node, keyword, loc: node.loc, state, args }, param)
       );
     } else {
       return null;

diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/curry.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/curry.ts
@@ -2,8 +2,12 @@ import type { CurriedType } from '@glimmer/interfaces';
 import { CURRIED_COMPONENT, CURRIED_HELPER, CURRIED_MODIFIER } from '@glimmer/constants';
 import { ASTv2, generateSyntaxError } from '@glimmer/syntax';
 
-import type { NormalizationState } from '../../context';
-import type { ContentKeywordMatch, KeywordDelegate, KeywordInfo } from '../impl';
+import type {
+  ContentKeywordInfo,
+  ContentKeywordMatch,
+  KeywordDelegate,
+  KeywordInfo,
+} from '../impl';
 
 import { Err, Ok, Result } from '../../../../shared/result';
 import * as mir from '../../../2-encoding/mir';
@@ -82,7 +86,7 @@ export function assertCurryKeyword(curriedType: CurriedType): ({
 
 function translateCurryKeyword(curriedType: CurriedType) {
   return (
-    { node, state }: { node: ContentKeywordMatch; state: NormalizationState },
+    { node, keyword, state }: ContentKeywordInfo,
     { definition, args }: { definition: ASTv2.ExpressionValueNode; args: ASTv2.CurlyArgs }
   ): Result<mir.Curry> => {
     let definitionResult = visitExpr(definition, state);
@@ -91,6 +95,7 @@ function translateCurryKeyword(curriedType: CurriedType) {
     return Result.all(definitionResult, argsResult).mapOk(
       ([definition, args]) =>
         new mir.Curry({
+          keyword,
           loc: node.loc,
           curriedType,
           definition,

diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/dynamic-vars.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/dynamic-vars.ts
@@ -2,8 +2,7 @@ import type { ASTv2 } from '@glimmer/syntax';
 import { generateSyntaxError } from '@glimmer/syntax';
 
 import type { Result } from '../../../../shared/result';
-import type { NormalizationState } from '../../context';
-import type { InvokeKeywordMatch, InvokeKeywordInfo, KeywordDelegate } from '../impl';
+import type { InvokeKeywordInfo, InvokeKeywordMatch, KeywordDelegate } from '../impl';
 
 import { Err, Ok } from '../../../../shared/result';
 import * as mir from '../../../2-encoding/mir';
@@ -37,10 +36,12 @@ function assertGetDynamicVarKeyword({
 }
 
 function translateGetDynamicVarKeyword(
-  { node, state }: { node: InvokeKeywordMatch; state: NormalizationState },
+  { node, keyword, state }: InvokeKeywordInfo,
   name: ASTv2.ExpressionValueNode
 ): Result<mir.GetDynamicVar> {
-  return visitExpr(name, state).mapOk((name) => new mir.GetDynamicVar({ name, loc: node.loc }));
+  return visitExpr(name, state).mapOk(
+    (name) => new mir.GetDynamicVar({ keyword, name, loc: node.loc })
+  );
 }
 
 export const getDynamicVarKeyword: KeywordDelegate<