refactor(compiler): template type-checking support for '@boundary'

Author: alxhub

packages/compiler/src/render3/r3_boundaries.ts

@@ -77,6 +77,29 @@ export function createBoundaryBlock(
           continue;
         }
 
+        const aliasMatch = param.expression.match(
+          /^([$A-Z_][0-9A-Z_$]*)\s*=\s*([$A-Z_][0-9A-Z_$]*)$/i,
+        );
+        if (aliasMatch) {
+          const name = aliasMatch[1];
+          const variableName = aliasMatch[2];
+
+          if (variableName !== '$error' && variableName !== '$retry') {
+            errors.push(
+              new ParseError(
+                param.sourceSpan,
+                `Unknown context variable "${variableName}". Only "$error" and "$retry" are allowed`,
+              ),
+            );
+          } else if (contextVariables.some((v) => v.name === name)) {
+            errors.push(new ParseError(param.sourceSpan, `Duplicate parameter variable "${name}"`));
+          } else {
+            const varSpan = param.sourceSpan;
+            contextVariables.push(new t.Variable(name, variableName, varSpan, varSpan));
+          }
+          continue;
+        }
+
         const whenMatch = param.expression.match(WHEN_PATTERN);
         if (whenMatch) {
           if (expression !== null) {

packages/compiler/src/template/pipeline/ir/src/enums.ts

@@ -89,6 +89,11 @@ export enum OpKind {
    */
   BoundaryCreate,
 
+  /**
+   * Create a boundary error branch creation instruction op.
+   */
+  BoundaryErrorCreate,
+
   /**
    * An op to validate and handle errors in a template.
    */

packages/compiler/src/template/pipeline/ir/src/expression.ts

@@ -1344,6 +1344,7 @@ export function transformExpressionsInOp(
     case OpKind.Control:
     case OpKind.ControlCreate:
     case OpKind.BoundaryCreate:
+    case OpKind.BoundaryErrorCreate:
       // These operations contain no expressions.
       break;
     default:
@@ -1438,6 +1439,10 @@ export function transformExpressionsInExpression(
     expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
   } else if (expr instanceof o.SpreadElementExpr) {
     expr.expression = transformExpressionsInExpression(expr.expression, transform, flags);
+  } else if (expr instanceof o.FunctionExpr) {
+    for (let i = 0; i < expr.statements.length; i++) {
+      transformExpressionsInStatement(expr.statements[i], transform, flags);
+    }
   } else if (
     expr instanceof o.ReadVarExpr ||
     expr instanceof o.ExternalExpr ||

packages/compiler/src/template/pipeline/ir/src/ops/create.ts

@@ -10,6 +10,7 @@ import {SecurityContext} from '../../../../../core';
 import * as i18n from '../../../../../i18n/i18n_ast';
 import * as o from '../../../../../output/output_ast';
 import {ParseSourceSpan} from '../../../../../parse_util';
+import * as t from '../../../../../render3/r3_ast';
 import {
   AnimationKind,
   BindingKind,
@@ -80,7 +81,8 @@ export type CreateOp =
   | AnimationOp
   | SourceLocationOp
   | ControlCreateOp
-  | BoundaryCreateOp;
+  | BoundaryCreateOp
+  | BoundaryErrorCreateOp;
 
 /**
  * An operation representing the creation of an element or container.
@@ -504,6 +506,67 @@ export function createBoundaryCreateOp(
   };
 }
 
+/**
+ * An op that creates a boundary error block.
+ */
+export interface BoundaryErrorCreateOp extends Op<CreateOp>, ConsumesSlotOpTrait {
+  kind: OpKind.BoundaryErrorCreate;
+
+  templateKind: TemplateKind;
+
+  decls: number | null;
+
+  vars: number | null;
+
+  functionNameSuffix: string;
+
+  i18nPlaceholder?: i18n.TagPlaceholder | i18n.BlockPlaceholder;
+
+  /**
+   * The Xref of the BoundaryCreate op that this error branch belongs to.
+   */
+  boundaryXref: XrefId;
+
+  contextVariables: t.Variable[];
+
+  /**
+   * The handle to the slot allocated for this element.
+   */
+  handle: SlotHandle;
+
+  startSourceSpan: ParseSourceSpan;
+
+  wholeSourceSpan: ParseSourceSpan;
+}
+
+export function createBoundaryErrorCreateOp(
+  xref: XrefId,
+  templateKind: TemplateKind,
+  functionNameSuffix: string,
+  i18nPlaceholder: i18n.TagPlaceholder | i18n.BlockPlaceholder | undefined,
+  startSourceSpan: ParseSourceSpan,
+  wholeSourceSpan: ParseSourceSpan,
+  boundaryXref: XrefId,
+  contextVariables: t.Variable[],
+): BoundaryErrorCreateOp {
+  return {
+    kind: OpKind.BoundaryErrorCreate,
+    xref,
+    templateKind,
+    handle: new SlotHandle(),
+    functionNameSuffix,
+    decls: null,
+    vars: null,
+    i18nPlaceholder,
+    startSourceSpan,
+    wholeSourceSpan,
+    boundaryXref,
+    contextVariables,
+    ...TRAIT_CONSUMES_SLOT,
+    ...NEW_OP,
+  };
+}
+
 /**
  * An op that creates a repeater (e.g. a for loop).
  */

packages/compiler/src/template/pipeline/ir/src/ops/update.ts

@@ -736,6 +736,11 @@ export interface BoundaryOp extends Op<UpdateOp>, DependsOnSlotContextOpTrait, C
    */
   primaryTarget: XrefId;
 
+  /**
+   * The primary branch (guarded by the no-error condition).
+   */
+  guarded: ConditionalCaseExpr;
+
   /**
    * Each possible error fallback view that could be displayed.
    */
@@ -761,13 +766,15 @@ export interface BoundaryOp extends Op<UpdateOp>, DependsOnSlotContextOpTrait, C
 export function createBoundaryOp(
   target: XrefId,
   primaryTarget: XrefId,
+  guarded: ConditionalCaseExpr,
   conditions: Array<ConditionalCaseExpr>,
   sourceSpan: ParseSourceSpan,
 ): BoundaryOp {
   return {
     kind: OpKind.Boundary,
     target,
     primaryTarget,
+    guarded,
     conditions,
     processed: null,
     sourceSpan,

packages/compiler/src/template/pipeline/src/ingest.ts

@@ -595,15 +595,15 @@ function ingestBoundaryBlock(unit: ViewCompilationUnit, boundaryBlock: t.Boundar
     const tagName = ingestControlFlowInsertionPoint(unit, errorView.xref, errorBlock);
 
     // Create branch creation operation
-    const branchCreateOp = ir.createConditionalBranchCreateOp(
+    const branchCreateOp = ir.createBoundaryErrorCreateOp(
       errorView.xref,
       ir.TemplateKind.Block,
-      tagName,
       'Error',
-      ir.Namespace.HTML,
       undefined,
       errorBlock.startSourceSpan,
       errorBlock.sourceSpan,
+      createOp.xref,
+      errorBlock.contextVariables,
     );
     unit.create.push(branchCreateOp);
 
@@ -612,11 +612,13 @@ function ingestBoundaryBlock(unit: ViewCompilationUnit, boundaryBlock: t.Boundar
       ? convertAst(errorBlock.expression, unit.job, null)
       : null;
 
+    const errorVar = errorBlock.contextVariables.find((v) => v.value === '$error');
+
     const conditionalCaseExpr = new ir.ConditionalCaseExpr(
       caseExpr,
       branchCreateOp.xref,
       branchCreateOp.handle,
-      null,
+      errorVar || null,
     );
     conditions.push(conditionalCaseExpr);
 
@@ -637,11 +639,17 @@ function ingestBoundaryBlock(unit: ViewCompilationUnit, boundaryBlock: t.Boundar
     primaryCreateOp.handle,
     null,
   );
-  conditions.push(primaryCaseExpr);
+
   ingestNodes(primaryView, boundaryBlock.children);
 
   unit.update.push(
-    ir.createBoundaryOp(createOp.xref, primaryCreateOp.xref, conditions, boundaryBlock.sourceSpan),
+    ir.createBoundaryOp(
+      createOp.xref,
+      primaryCreateOp.xref,
+      primaryCaseExpr,
+      conditions,
+      boundaryBlock.sourceSpan,
+    ),
   );
 }
 

packages/compiler/src/template/pipeline/src/phases/boundary_conditions.ts

@@ -37,17 +37,33 @@ export function generateBoundaryConditions(job: ComponentCompilationJob): void {
           console.log('  Condition target:', c.target);
         }
 
-        const primaryBranch = op.conditions.find((c) => c.target === op.primaryTarget);
-        const errorBranch = op.conditions.find((c) => c.target !== op.primaryTarget);
+        const errorBranches = op.conditions;
+        const fallbackBranch = errorBranches.find((c) => c.expr === null);
+        let errorResultExpr: o.Expression = fallbackBranch
+          ? new ir.SlotLiteralExpr(fallbackBranch.targetSlot)
+          : o.literal(-1);
 
-        if (!primaryBranch || !errorBranch) {
-          throw new Error(`Boundary must have both primary and error branches`);
+        // Iterate in reverse order over error branches WITH conditions
+        const conditionalBranches = errorBranches.filter((c) => c.expr !== null);
+        for (let i = conditionalBranches.length - 1; i >= 0; i--) {
+          const branch = conditionalBranches[i];
+
+          let conditionExpr = branch.expr!;
+
+          // The alias variable for the condition is generated in generate_variables.ts
+          // and resolved by resolve_names.
+
+          errorResultExpr = new o.ConditionalExpr(
+            conditionExpr,
+            new ir.SlotLiteralExpr(branch.targetSlot),
+            errorResultExpr,
+          );
         }
 
         op.processed = new o.ConditionalExpr(
           condition,
-          new ir.SlotLiteralExpr(primaryBranch.targetSlot),
-          new ir.SlotLiteralExpr(errorBranch.targetSlot),
+          new ir.SlotLiteralExpr(op.guarded.targetSlot),
+          errorResultExpr,
         );
       }
     }

packages/compiler/src/template/pipeline/src/phases/conditionals.ts

@@ -16,7 +16,7 @@ import {ComponentCompilationJob} from '../compilation';
 export function generateConditionalExpressions(job: ComponentCompilationJob): void {
   for (const unit of job.units) {
     for (const op of unit.ops()) {
-      if (op.kind !== ir.OpKind.Conditional && op.kind !== ir.OpKind.Boundary) {
+      if (op.kind !== ir.OpKind.Conditional) {
         continue;
       }
 

packages/compiler/src/template/pipeline/src/phases/generate_variables.ts

@@ -45,6 +45,7 @@ function recursivelyProcessView(view: ViewCompilationUnit, parentScope: Scope |
     switch (op.kind) {
       case ir.OpKind.ConditionalCreate:
       case ir.OpKind.ConditionalBranchCreate:
+      case ir.OpKind.BoundaryErrorCreate:
       case ir.OpKind.Template:
         // Descend into child embedded views.
         recursivelyProcessView(view.job.views.get(op.xref)!, scope);
@@ -238,6 +239,22 @@ function getScopeForView(view: ViewCompilationUnit, parent: Scope | null): Scope
           },
         });
         break;
+
+      case ir.OpKind.BoundaryErrorCreate:
+        const boundaryStateExpr = new ir.BoundaryStateExpr(op.boundaryXref);
+        const errorProp = new o.ReadPropExpr(boundaryStateExpr, 'error');
+
+        for (const variable of op.contextVariables) {
+          if (variable.value === '$error') {
+            view.aliases.add({
+              kind: ir.SemanticVariableKind.Alias,
+              name: null,
+              identifier: variable.name,
+              expression: errorProp,
+            });
+          }
+        }
+        break;
     }
   }
 

packages/compiler/src/template/pipeline/src/phases/naming.ts

@@ -143,6 +143,7 @@ function addNamesToView(unit: CompilationUnit, baseName: string, state: {index:
         break;
       case ir.OpKind.ConditionalCreate:
       case ir.OpKind.ConditionalBranchCreate:
+      case ir.OpKind.BoundaryErrorCreate:
       case ir.OpKind.Template:
         if (!(unit instanceof ViewCompilationUnit)) {
           throw new Error(`AssertionError: must be compiling a component`);