@angular/compiler 16.0.0-next.7 → 16.0.0-rc.1

package/esm2022/src/template/pipeline/src/phases/generate_variables.mjs

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+/**
+ * Generate a preamble sequence for each view creation block and listener function which declares
+ * any variables that be referenced in other operations in the block.
+ *
+ * Variables generated include:
+ *   * a saved view context to be used to restore the current view in event listeners.
+ *   * the context of the restored view within event listener handlers.
+ *   * context variables from the current view as well as all parent views (including the root
+ *     context if needed).
+ *   * local references from elements within the current view and any lexical parents.
+ *
+ * Variables are generated here unconditionally, and may optimized away in future operations if it
+ * turns out their values (and any side effects) are unused.
+ */
+export function phaseGenerateVariables(cpl) {
+    recursivelyProcessView(cpl.root, /* there is no parent scope for the root view */ null);
+}
+/**
+ * Process the given `ViewCompilation` and generate preambles for it and any listeners that it
+ * declares.
+ *
+ * @param `parentScope` a scope extracted from the parent view which captures any variables which
+ *     should be inherited by this view. `null` if the current view is the root view.
+ */
+function recursivelyProcessView(view, parentScope) {
+    // Extract a `Scope` from this view.
+    const scope = getScopeForView(view, parentScope);
+    // Start the view creation block with an operation to save the current view context. This may be
+    // used to restore the view context in any listeners that may be present.
+    view.create.prepend([
+        ir.createVariableOp(view.tpl.allocateXrefId(), {
+            kind: ir.SemanticVariableKind.SavedView,
+            view: view.xref,
+        }, new ir.GetCurrentViewExpr()),
+    ]);
+    for (const op of view.create) {
+        switch (op.kind) {
+            case ir.OpKind.Template:
+                // Descend into child embedded views.
+                recursivelyProcessView(view.tpl.views.get(op.xref), scope);
+                break;
+            case ir.OpKind.Listener:
+                // Listeners get a preamble which starts with a call to restore the view.
+                const preambleOps = [
+                    ir.createVariableOp(view.tpl.allocateXrefId(), {
+                        kind: ir.SemanticVariableKind.Context,
+                        view: view.xref,
+                    }, new ir.RestoreViewExpr(view.xref)),
+                    // And includes all variables available to this view.
+                    ...generateVariablesInScopeForView(view, scope)
+                ];
+                op.handlerOps.prepend(preambleOps);
+                // The "restore view" operation in listeners requires a call to `resetView` to reset the
+                // context prior to returning from the listener operation. Find any `return` statements in
+                // the listener body and wrap them in a call to reset the view.
+                for (const handlerOp of op.handlerOps) {
+                    if (handlerOp.kind === ir.OpKind.Statement &&
+                        handlerOp.statement instanceof o.ReturnStatement) {
+                        handlerOp.statement.value = new ir.ResetViewExpr(handlerOp.statement.value);
+                    }
+                }
+                break;
+        }
+    }
+    // Prepend the declarations for all available variables in scope to the `update` block.
+    const preambleOps = generateVariablesInScopeForView(view, scope);
+    view.update.prepend(preambleOps);
+}
+/**
+ * Process a view and generate a `Scope` representing the variables available for reference within
+ * that view.
+ */
+function getScopeForView(view, parent) {
+    const scope = {
+        view: view.xref,
+        references: [],
+        parent,
+    };
+    for (const op of view.create) {
+        switch (op.kind) {
+            case ir.OpKind.Element:
+            case ir.OpKind.ElementStart:
+            case ir.OpKind.Template:
+                if (!Array.isArray(op.localRefs)) {
+                    throw new Error(`AssertionError: expected localRefs to be an array`);
+                }
+                // Record available local references from this element.
+                for (let offset = 0; offset < op.localRefs.length; offset++) {
+                    scope.references.push({
+                        name: op.localRefs[offset].name,
+                        targetId: op.xref,
+                        offset,
+                    });
+                }
+                break;
+        }
+    }
+    return scope;
+}
+/**
+ * Generate declarations for all variables that are in scope for a given view.
+ *
+ * This is a recursive process, as views inherit variables available from their parent view, which
+ * itself may have inherited variables, etc.
+ */
+function generateVariablesInScopeForView(view, scope) {
+    const newOps = [];
+    if (scope.view !== view.xref) {
+        // Before generating variables for a parent view, we need to switch to the context of the parent
+        // view with a `nextContext` expression. This context switching operation itself declares a
+        // variable, because the context of the view may be referenced directly.
+        newOps.push(ir.createVariableOp(view.tpl.allocateXrefId(), {
+            kind: ir.SemanticVariableKind.Context,
+            view: scope.view,
+        }, new ir.NextContextExpr()));
+    }
+    // Add variables for all context variables available in this scope's view.
+    for (const [name, value] of view.tpl.views.get(scope.view).contextVariables) {
+        newOps.push(ir.createVariableOp(view.tpl.allocateXrefId(), {
+            kind: ir.SemanticVariableKind.Identifier,
+            name,
+        }, new o.ReadPropExpr(new ir.ContextExpr(view.xref), value)));
+    }
+    // Add variables for all local references declared for elements in this scope.
+    for (const ref of scope.references) {
+        newOps.push(ir.createVariableOp(view.tpl.allocateXrefId(), {
+            kind: ir.SemanticVariableKind.Identifier,
+            name: ref.name,
+        }, new ir.ReferenceExpr(ref.targetId, ref.offset)));
+    }
+    if (scope.parent !== null) {
+        // Recursively add variables from the parent scope.
+        newOps.push(...generateVariablesInScopeForView(view, scope.parent));
+    }
+    return newOps;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate_variables.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/generate_variables.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as o from '../../../../output/output_ast';\nimport * as ir from '../../ir';\n\nimport type {ComponentCompilation, ViewCompilation} from '../compilation';\n\n/**\n * Generate a preamble sequence for each view creation block and listener function which declares\n * any variables that be referenced in other operations in the block.\n *\n * Variables generated include:\n *   * a saved view context to be used to restore the current view in event listeners.\n *   * the context of the restored view within event listener handlers.\n *   * context variables from the current view as well as all parent views (including the root\n *     context if needed).\n *   * local references from elements within the current view and any lexical parents.\n *\n * Variables are generated here unconditionally, and may optimized away in future operations if it\n * turns out their values (and any side effects) are unused.\n */\nexport function phaseGenerateVariables(cpl: ComponentCompilation): void {\n  recursivelyProcessView(cpl.root, /* there is no parent scope for the root view */ null);\n}\n\n/**\n * Process the given `ViewCompilation` and generate preambles for it and any listeners that it\n * declares.\n *\n * @param `parentScope` a scope extracted from the parent view which captures any variables which\n *     should be inherited by this view. `null` if the current view is the root view.\n */\nfunction recursivelyProcessView(view: ViewCompilation, parentScope: Scope|null): void {\n  // Extract a `Scope` from this view.\n  const scope = getScopeForView(view, parentScope);\n\n  // Start the view creation block with an operation to save the current view context. This may be\n  // used to restore the view context in any listeners that may be present.\n  view.create.prepend([\n    ir.createVariableOp<ir.CreateOp>(\n        view.tpl.allocateXrefId(), {\n          kind: ir.SemanticVariableKind.SavedView,\n          view: view.xref,\n        },\n        new ir.GetCurrentViewExpr()),\n  ]);\n\n  for (const op of view.create) {\n    switch (op.kind) {\n      case ir.OpKind.Template:\n        // Descend into child embedded views.\n        recursivelyProcessView(view.tpl.views.get(op.xref)!, scope);\n        break;\n      case ir.OpKind.Listener:\n        // Listeners get a preamble which starts with a call to restore the view.\n        const preambleOps = [\n          ir.createVariableOp<ir.UpdateOp>(\n              view.tpl.allocateXrefId(), {\n                kind: ir.SemanticVariableKind.Context,\n                view: view.xref,\n              },\n              new ir.RestoreViewExpr(view.xref)),\n          // And includes all variables available to this view.\n          ...generateVariablesInScopeForView(view, scope)\n        ];\n\n        op.handlerOps.prepend(preambleOps);\n\n        // The \"restore view\" operation in listeners requires a call to `resetView` to reset the\n        // context prior to returning from the listener operation. Find any `return` statements in\n        // the listener body and wrap them in a call to reset the view.\n        for (const handlerOp of op.handlerOps) {\n          if (handlerOp.kind === ir.OpKind.Statement &&\n              handlerOp.statement instanceof o.ReturnStatement) {\n            handlerOp.statement.value = new ir.ResetViewExpr(handlerOp.statement.value);\n          }\n        }\n        break;\n    }\n  }\n\n  // Prepend the declarations for all available variables in scope to the `update` block.\n  const preambleOps = generateVariablesInScopeForView(view, scope);\n  view.update.prepend(preambleOps);\n}\n\n/**\n * Lexical scope of a view, including a reference to its parent view's scope, if any.\n */\ninterface Scope {\n  /**\n   * `XrefId` of the view to which this scope corresponds.\n   */\n  view: ir.XrefId;\n\n  /**\n   * Local references collected from elements within the view.\n   */\n  references: Reference[];\n\n  /**\n   * `Scope` of the parent view, if any.\n   */\n  parent: Scope|null;\n}\n\n/**\n * Information needed about a local reference collected from an element within a view.\n */\ninterface Reference {\n  /**\n   * Name given to the local reference variable within the template.\n   *\n   * This is not the name which will be used for the variable declaration in the generated\n   * template code.\n   */\n  name: string;\n\n  /**\n   * `XrefId` of the element-like node which this reference targets.\n   *\n   * The reference may be either to the element (or template) itself, or to a directive on it.\n   */\n  targetId: ir.XrefId;\n\n  /**\n   * A generated offset of this reference among all the references on a specific element.\n   */\n  offset: number;\n}\n\n/**\n * Process a view and generate a `Scope` representing the variables available for reference within\n * that view.\n */\nfunction getScopeForView(view: ViewCompilation, parent: Scope|null): Scope {\n  const scope: Scope = {\n    view: view.xref,\n    references: [],\n    parent,\n  };\n\n  for (const op of view.create) {\n    switch (op.kind) {\n      case ir.OpKind.Element:\n      case ir.OpKind.ElementStart:\n      case ir.OpKind.Template:\n        if (!Array.isArray(op.localRefs)) {\n          throw new Error(`AssertionError: expected localRefs to be an array`);\n        }\n\n        // Record available local references from this element.\n        for (let offset = 0; offset < op.localRefs.length; offset++) {\n          scope.references.push({\n            name: op.localRefs[offset].name,\n            targetId: op.xref,\n            offset,\n          });\n        }\n        break;\n    }\n  }\n\n  return scope;\n}\n\n/**\n * Generate declarations for all variables that are in scope for a given view.\n *\n * This is a recursive process, as views inherit variables available from their parent view, which\n * itself may have inherited variables, etc.\n */\nfunction generateVariablesInScopeForView(\n    view: ViewCompilation, scope: Scope): ir.VariableOp<ir.UpdateOp>[] {\n  const newOps: ir.VariableOp<ir.UpdateOp>[] = [];\n\n  if (scope.view !== view.xref) {\n    // Before generating variables for a parent view, we need to switch to the context of the parent\n    // view with a `nextContext` expression. This context switching operation itself declares a\n    // variable, because the context of the view may be referenced directly.\n    newOps.push(ir.createVariableOp(\n        view.tpl.allocateXrefId(), {\n          kind: ir.SemanticVariableKind.Context,\n          view: scope.view,\n        },\n        new ir.NextContextExpr()));\n  }\n\n  // Add variables for all context variables available in this scope's view.\n  for (const [name, value] of view.tpl.views.get(scope.view)!.contextVariables) {\n    newOps.push(ir.createVariableOp(\n        view.tpl.allocateXrefId(), {\n          kind: ir.SemanticVariableKind.Identifier,\n          name,\n        },\n        new o.ReadPropExpr(new ir.ContextExpr(view.xref), value)));\n  }\n\n  // Add variables for all local references declared for elements in this scope.\n  for (const ref of scope.references) {\n    newOps.push(ir.createVariableOp(\n        view.tpl.allocateXrefId(), {\n          kind: ir.SemanticVariableKind.Identifier,\n          name: ref.name,\n        },\n        new ir.ReferenceExpr(ref.targetId, ref.offset)));\n  }\n\n  if (scope.parent !== null) {\n    // Recursively add variables from the parent scope.\n    newOps.push(...generateVariablesInScopeForView(view, scope.parent));\n  }\n  return newOps;\n}\n"]}

package/esm2022/src/template/pipeline/src/phases/local_refs.mjs

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+/**
+ * Lifts local reference declarations on element-like structures within each view into an entry in
+ * the `consts` array for the whole component.
+ */
+export function phaseLocalRefs(cpl) {
+    for (const view of cpl.views.values()) {
+        for (const op of view.create) {
+            switch (op.kind) {
+                case ir.OpKind.ElementStart:
+                case ir.OpKind.Element:
+                case ir.OpKind.Template:
+                    if (!Array.isArray(op.localRefs)) {
+                        throw new Error(`AssertionError: expected localRefs to be an array still`);
+                    }
+                    op.numSlotsUsed += op.localRefs.length;
+                    if (op.localRefs.length > 0) {
+                        const localRefs = serializeLocalRefs(op.localRefs);
+                        op.localRefs = cpl.addConst(localRefs);
+                    }
+                    else {
+                        op.localRefs = null;
+                    }
+                    break;
+            }
+        }
+    }
+}
+function serializeLocalRefs(refs) {
+    const constRefs = [];
+    for (const ref of refs) {
+        constRefs.push(o.literal(ref.name), o.literal(ref.target));
+    }
+    return o.literalArr(constRefs);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/src/phases/naming.mjs

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as ir from '../../ir';
+/**
+ * Generate names for functions and variables across all views.
+ *
+ * This includes propagating those names into any `ir.ReadVariableExpr`s of those variables, so that
+ * the reads can be emitted correctly.
+ */
+export function phaseNaming(cpl) {
+    // TODO(alxhub): convert this temporary name to match how the `TemplateDefinitionBuilder`
+    // names the main component template function.
+    cpl.root.fnName = `${cpl.componentName}_Template`;
+    for (const [id, view] of cpl.views) {
+        let vIndex = 0;
+        if (view.fnName === null) {
+            // TODO(alxhub): convert this temporary name to match how the `TemplateDefinitionBuilder`
+            // names embedded view functions.
+            view.fnName = `${cpl.componentName}_EmbeddedView_${id}`;
+        }
+        // Keep track of the names we assign to variables in the view. We'll need to propagate these
+        // into reads of those variables afterwards.
+        const varNames = new Map();
+        for (const op of view.ops()) {
+            switch (op.kind) {
+                case ir.OpKind.Listener:
+                    if (op.handlerFnName === null) {
+                        // TODO(alxhub): convert this temporary name to match how the
+                        // `TemplateDefinitionBuilder` names listener functions.
+                        op.handlerFnName = `${view.fnName}_${op.name}_listener`;
+                    }
+                    break;
+                case ir.OpKind.Variable:
+                    if (op.name === null) {
+                        op.name = `_r${vIndex++}`;
+                        varNames.set(op.xref, op.name);
+                    }
+                    break;
+            }
+        }
+        // Having named all variables declared in the view, now we can push those names into the
+        // `ir.ReadVariableExpr` expressions which represent reads of those variables.
+        for (const op of view.ops()) {
+            ir.visitExpressionsInOp(op, expr => {
+                if (!(expr instanceof ir.ReadVariableExpr) || expr.name !== null) {
+                    return;
+                }
+                if (!varNames.has(expr.xref)) {
+                    throw new Error(`Variable ${expr.xref} not yet named`);
+                }
+                expr.name = varNames.get(expr.xref);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/src/phases/reify.mjs

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+import * as ng from '../instruction';
+/**
+ * Compiles semantic operations across all views and generates output `o.Statement`s with actual
+ * runtime calls in their place.
+ *
+ * Reification replaces semantic operations with selected Ivy instructions and other generated code
+ * structures. After reification, the create/update operation lists of all views should only contain
+ * `ir.StatementOp`s (which wrap generated `o.Statement`s).
+ */
+export function phaseReify(cpl) {
+    for (const [_, view] of cpl.views) {
+        reifyCreateOperations(view, view.create);
+        reifyUpdateOperations(view, view.update);
+    }
+}
+function reifyCreateOperations(view, ops) {
+    for (const op of ops) {
+        ir.transformExpressionsInOp(op, reifyIrExpression);
+        switch (op.kind) {
+            case ir.OpKind.Text:
+                ir.OpList.replace(op, ng.text(op.slot, op.initialValue));
+                break;
+            case ir.OpKind.ElementStart:
+                ir.OpList.replace(op, ng.elementStart(op.slot, op.tag, op.attributes, op.localRefs));
+                break;
+            case ir.OpKind.Element:
+                ir.OpList.replace(op, ng.element(op.slot, op.tag, op.attributes, op.localRefs));
+                break;
+            case ir.OpKind.ElementEnd:
+                ir.OpList.replace(op, ng.elementEnd());
+                break;
+            case ir.OpKind.Template:
+                const childView = view.tpl.views.get(op.xref);
+                ir.OpList.replace(op, ng.template(op.slot, o.variable(childView.fnName), childView.decls, childView.vars, op.tag, op.localRefs));
+                break;
+            case ir.OpKind.Listener:
+                const listenerFn = reifyListenerHandler(view, op.handlerFnName, op.handlerOps);
+                ir.OpList.replace(op, ng.listener(op.name, listenerFn));
+                break;
+            case ir.OpKind.Variable:
+                if (op.name === null) {
+                    throw new Error(`AssertionError: unnamed variable ${op.xref}`);
+                }
+                ir.OpList.replace(op, ir.createStatementOp(new o.DeclareVarStmt(op.name, op.initializer)));
+                break;
+            case ir.OpKind.Statement:
+                // Pass statement operations directly through.
+                break;
+            default:
+                throw new Error(`AssertionError: Unsupported reification of create op ${ir.OpKind[op.kind]}`);
+        }
+    }
+}
+function reifyUpdateOperations(_view, ops) {
+    for (const op of ops) {
+        ir.transformExpressionsInOp(op, reifyIrExpression);
+        switch (op.kind) {
+            case ir.OpKind.Advance:
+                ir.OpList.replace(op, ng.advance(op.delta));
+                break;
+            case ir.OpKind.Property:
+                ir.OpList.replace(op, ng.property(op.name, op.expression));
+                break;
+            case ir.OpKind.InterpolateText:
+                ir.OpList.replace(op, ng.textInterpolate(op.strings, op.expressions));
+                break;
+            case ir.OpKind.Variable:
+                if (op.name === null) {
+                    throw new Error(`AssertionError: unnamed variable ${op.xref}`);
+                }
+                ir.OpList.replace(op, ir.createStatementOp(new o.DeclareVarStmt(op.name, op.initializer)));
+                break;
+            case ir.OpKind.Statement:
+                // Pass statement operations directly through.
+                break;
+            default:
+                throw new Error(`AssertionError: Unsupported reification of update op ${ir.OpKind[op.kind]}`);
+        }
+    }
+}
+function reifyIrExpression(expr) {
+    switch (expr.kind) {
+        case ir.ExpressionKind.NextContext:
+            return ng.nextContext();
+        case ir.ExpressionKind.Reference:
+            return ng.reference(expr.slot + 1 + expr.offset);
+        case ir.ExpressionKind.LexicalRead:
+            throw new Error(`AssertionError: unresolved LexicalRead of ${expr.name}`);
+        case ir.ExpressionKind.RestoreView:
+            if (typeof expr.view === 'number') {
+                throw new Error(`AssertionError: unresolved RestoreView`);
+            }
+            return ng.restoreView(expr.view);
+        case ir.ExpressionKind.ResetView:
+            return ng.resetView(expr.expr);
+        case ir.ExpressionKind.GetCurrentView:
+            return ng.getCurrentView();
+        case ir.ExpressionKind.ReadVariable:
+            if (expr.name === null) {
+                throw new Error(`Read of unnamed variable ${expr.xref}`);
+            }
+            return o.variable(expr.name);
+        default:
+            throw new Error(`AssertionError: Unsupported reification of ir.Expression kind: ${ir.ExpressionKind[expr.kind]}`);
+    }
+}
+/**
+ * Listeners get turned into a function expression, which may or may not have the `$event`
+ * parameter defined.
+ */
+function reifyListenerHandler(view, name, handlerOps) {
+    const lookForEvent = new LookForEventVisitor();
+    // First, reify all instruction calls within `handlerOps`.
+    reifyUpdateOperations(view, handlerOps);
+    // Next, extract all the `o.Statement`s from the reified operations. We can expect that at this
+    // point, all operations have been converted to statements.
+    const handlerStmts = [];
+    for (const op of handlerOps) {
+        if (op.kind !== ir.OpKind.Statement) {
+            throw new Error(`AssertionError: expected reified statements, but found op ${ir.OpKind[op.kind]}`);
+        }
+        handlerStmts.push(op.statement);
+    }
+    // Scan the statement list for usages of `$event`. If referenced, we need to generate it as a
+    // parameter.
+    lookForEvent.visitAllStatements(handlerStmts, null);
+    const params = [];
+    if (lookForEvent.seenEventRead) {
+        // We need the `$event` parameter.
+        params.push(new o.FnParam('$event'));
+    }
+    return o.fn(params, handlerStmts, undefined, undefined, name);
+}
+/**
+ * Visitor which scans for reads of the `$event` special variable.
+ */
+class LookForEventVisitor extends o.RecursiveAstVisitor {
+    constructor() {
+        super(...arguments);
+        this.seenEventRead = false;
+    }
+    visitReadVarExpr(ast, context) {
+        if (ast.name === '$event') {
+            this.seenEventRead = true;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reify.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/reify.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,CAAC,MAAM,+BAA+B,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAG/B,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAErC;;;;;;;GAOG;AACH,MAAM,UAAU,UAAU,CAAC,GAAyB;IAClD,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE;QACjC,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACzC,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;KAC1C;AACH,CAAC;AAED,SAAS,qBAAqB,CAAC,IAAqB,EAAE,GAA2B;IAC/E,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;QACpB,EAAE,CAAC,wBAAwB,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAC;QAEnD,QAAQ,EAAE,CAAC,IAAI,EAAE;YACf,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI;gBACjB,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAK,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;gBAC1D,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,YAAY;gBACzB,EAAE,CAAC,MAAM,CAAC,OAAO,CACb,EAAE,EACF,EAAE,CAAC,YAAY,CACX,EAAE,CAAC,IAAK,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,UAA2B,EAAE,EAAE,CAAC,SAA0B,CAAC,CAAC,CAAC;gBAC1F,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,OAAO;gBACpB,EAAE,CAAC,MAAM,CAAC,OAAO,CACb,EAAE,EACF,EAAE,CAAC,OAAO,CACN,EAAE,CAAC,IAAK,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,UAA2B,EAAE,EAAE,CAAC,SAA0B,CAAC,CAAC,CAAC;gBAC1F,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,UAAU;gBACvB,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,EAAE,CAAC,CAAC;gBACvC,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ;gBACrB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAE,CAAC;gBAC/C,EAAE,CAAC,MAAM,CAAC,OAAO,CACb,EAAE,EACF,EAAE,CAAC,QAAQ,CACP,EAAE,CAAC,IAAK,EACR,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAO,CAAC,EAC7B,SAAS,CAAC,KAAM,EAChB,SAAS,CAAC,IAAK,EACf,EAAE,CAAC,GAAG,EACN,EAAE,CAAC,SAAmB,CACrB,CACR,CAAC;gBACF,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ;gBACrB,MAAM,UAAU,GAAG,oBAAoB,CAAC,IAAI,EAAE,EAAE,CAAC,aAAc,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC;gBAChF,EAAE,CAAC,MAAM,CAAC,OAAO,CACb,EAAE,EACF,EAAE,CAAC,QAAQ,CACP,EAAE,CAAC,IAAI,EACP,UAAU,CACT,CAAC,CAAC;gBACX,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ;gBACrB,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE;oBACpB,MAAM,IAAI,KAAK,CAAC,oCAAoC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;iBAChE;gBACD,EAAE,CAAC,MAAM,CAAC,OAAO,CACb,EAAE,EAAE,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;gBAC7E,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,SAAS;gBACtB,8CAA8C;gBAC9C,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CACX,wDAAwD,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACrF;KACF;AACH,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAsB,EAAE,GAA2B;IAChF,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE;QACpB,EAAE,CAAC,wBAAwB,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAC;QAEnD,QAAQ,EAAE,CAAC,IAAI,EAAE;YACf,KAAK,EAAE,CAAC,MAAM,CAAC,OAAO;gBACpB,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC5C,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ;gBACrB,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;gBAC3D,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,eAAe;gBAC5B,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;gBACtE,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ;gBACrB,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE;oBACpB,MAAM,IAAI,KAAK,CAAC,oCAAoC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;iBAChE;gBACD,EAAE,CAAC,MAAM,CAAC,OAAO,CACb,EAAE,EAAE,EAAE,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;gBAC7E,MAAM;YACR,KAAK,EAAE,CAAC,MAAM,CAAC,SAAS;gBACtB,8CAA8C;gBAC9C,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CACX,wDAAwD,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACrF;KACF;AACH,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAmB;IAC5C,QAAQ,IAAI,CAAC,IAAI,EAAE;QACjB,KAAK,EAAE,CAAC,cAAc,CAAC,WAAW;YAChC,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC;QAC1B,KAAK,EAAE,CAAC,cAAc,CAAC,SAAS;YAC9B,OAAO,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAK,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QACpD,KAAK,EAAE,CAAC,cAAc,CAAC,WAAW;YAChC,MAAM,IAAI,KAAK,CAAC,6CAA6C,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QAC5E,KAAK,EAAE,CAAC,cAAc,CAAC,WAAW;YAChC,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE;gBACjC,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;aAC3D;YACD,OAAO,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnC,KAAK,EAAE,CAAC,cAAc,CAAC,SAAS;YAC9B,OAAO,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjC,KAAK,EAAE,CAAC,cAAc,CAAC,cAAc;YACnC,OAAO,EAAE,CAAC,cAAc,EAAE,CAAC;QAC7B,KAAK,EAAE,CAAC,cAAc,CAAC,YAAY;YACjC,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;gBACtB,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;aAC1D;YACD,OAAO,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B;YACE,MAAM,IAAI,KAAK,CAAC,kEACZ,EAAE,CAAC,cAAc,CAAE,IAAsB,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;KAC1D;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CACzB,IAAqB,EAAE,IAAY,EAAE,UAAkC;IACzE,MAAM,YAAY,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAE/C,0DAA0D;IAC1D,qBAAqB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAExC,+FAA+F;IAC/F,2DAA2D;IAC3D,MAAM,YAAY,GAAkB,EAAE,CAAC;IACvC,KAAK,MAAM,EAAE,IAAI,UAAU,EAAE;QAC3B,IAAI,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,MAAM,CAAC,SAAS,EAAE;YACnC,MAAM,IAAI,KAAK,CACX,6DAA6D,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACxF;QACD,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;KACjC;IAED,6FAA6F;IAC7F,aAAa;IACb,YAAY,CAAC,kBAAkB,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;IAEpD,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,IAAI,YAAY,CAAC,aAAa,EAAE;QAC9B,kCAAkC;QAClC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;KACtC;IAED,OAAO,CAAC,CAAC,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;AAChE,CAAC;AAED;;GAEG;AACH,MAAM,mBAAoB,SAAQ,CAAC,CAAC,mBAAmB;IAAvD;;QACE,kBAAa,GAAG,KAAK,CAAC;IAOxB,CAAC;IALU,gBAAgB,CAAC,GAAkB,EAAE,OAAY;QACxD,IAAI,GAAG,CAAC,IAAI,KAAK,QAAQ,EAAE;YACzB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;SAC3B;IACH,CAAC;CACF","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as o from '../../../../output/output_ast';\nimport * as ir from '../../ir';\n\nimport type {ComponentCompilation, ViewCompilation} from '../compilation';\nimport * as ng from '../instruction';\n\n/**\n * Compiles semantic operations across all views and generates output `o.Statement`s with actual\n * runtime calls in their place.\n *\n * Reification replaces semantic operations with selected Ivy instructions and other generated code\n * structures. After reification, the create/update operation lists of all views should only contain\n * `ir.StatementOp`s (which wrap generated `o.Statement`s).\n */\nexport function phaseReify(cpl: ComponentCompilation): void {\n  for (const [_, view] of cpl.views) {\n    reifyCreateOperations(view, view.create);\n    reifyUpdateOperations(view, view.update);\n  }\n}\n\nfunction reifyCreateOperations(view: ViewCompilation, ops: ir.OpList<ir.CreateOp>): void {\n  for (const op of ops) {\n    ir.transformExpressionsInOp(op, reifyIrExpression);\n\n    switch (op.kind) {\n      case ir.OpKind.Text:\n        ir.OpList.replace(op, ng.text(op.slot!, op.initialValue));\n        break;\n      case ir.OpKind.ElementStart:\n        ir.OpList.replace(\n            op,\n            ng.elementStart(\n                op.slot!, op.tag, op.attributes as number | null, op.localRefs as number | null));\n        break;\n      case ir.OpKind.Element:\n        ir.OpList.replace(\n            op,\n            ng.element(\n                op.slot!, op.tag, op.attributes as number | null, op.localRefs as number | null));\n        break;\n      case ir.OpKind.ElementEnd:\n        ir.OpList.replace(op, ng.elementEnd());\n        break;\n      case ir.OpKind.Template:\n        const childView = view.tpl.views.get(op.xref)!;\n        ir.OpList.replace(\n            op,\n            ng.template(\n                op.slot!,\n                o.variable(childView.fnName!),\n                childView.decls!,\n                childView.vars!,\n                op.tag,\n                op.localRefs as number,\n                ),\n        );\n        break;\n      case ir.OpKind.Listener:\n        const listenerFn = reifyListenerHandler(view, op.handlerFnName!, op.handlerOps);\n        ir.OpList.replace(\n            op,\n            ng.listener(\n                op.name,\n                listenerFn,\n                ));\n        break;\n      case ir.OpKind.Variable:\n        if (op.name === null) {\n          throw new Error(`AssertionError: unnamed variable ${op.xref}`);\n        }\n        ir.OpList.replace<ir.CreateOp>(\n            op, ir.createStatementOp(new o.DeclareVarStmt(op.name, op.initializer)));\n        break;\n      case ir.OpKind.Statement:\n        // Pass statement operations directly through.\n        break;\n      default:\n        throw new Error(\n            `AssertionError: Unsupported reification of create op ${ir.OpKind[op.kind]}`);\n    }\n  }\n}\n\nfunction reifyUpdateOperations(_view: ViewCompilation, ops: ir.OpList<ir.UpdateOp>): void {\n  for (const op of ops) {\n    ir.transformExpressionsInOp(op, reifyIrExpression);\n\n    switch (op.kind) {\n      case ir.OpKind.Advance:\n        ir.OpList.replace(op, ng.advance(op.delta));\n        break;\n      case ir.OpKind.Property:\n        ir.OpList.replace(op, ng.property(op.name, op.expression));\n        break;\n      case ir.OpKind.InterpolateText:\n        ir.OpList.replace(op, ng.textInterpolate(op.strings, op.expressions));\n        break;\n      case ir.OpKind.Variable:\n        if (op.name === null) {\n          throw new Error(`AssertionError: unnamed variable ${op.xref}`);\n        }\n        ir.OpList.replace<ir.UpdateOp>(\n            op, ir.createStatementOp(new o.DeclareVarStmt(op.name, op.initializer)));\n        break;\n      case ir.OpKind.Statement:\n        // Pass statement operations directly through.\n        break;\n      default:\n        throw new Error(\n            `AssertionError: Unsupported reification of update op ${ir.OpKind[op.kind]}`);\n    }\n  }\n}\n\nfunction reifyIrExpression(expr: ir.Expression): o.Expression {\n  switch (expr.kind) {\n    case ir.ExpressionKind.NextContext:\n      return ng.nextContext();\n    case ir.ExpressionKind.Reference:\n      return ng.reference(expr.slot! + 1 + expr.offset);\n    case ir.ExpressionKind.LexicalRead:\n      throw new Error(`AssertionError: unresolved LexicalRead of ${expr.name}`);\n    case ir.ExpressionKind.RestoreView:\n      if (typeof expr.view === 'number') {\n        throw new Error(`AssertionError: unresolved RestoreView`);\n      }\n      return ng.restoreView(expr.view);\n    case ir.ExpressionKind.ResetView:\n      return ng.resetView(expr.expr);\n    case ir.ExpressionKind.GetCurrentView:\n      return ng.getCurrentView();\n    case ir.ExpressionKind.ReadVariable:\n      if (expr.name === null) {\n        throw new Error(`Read of unnamed variable ${expr.xref}`);\n      }\n      return o.variable(expr.name);\n    default:\n      throw new Error(`AssertionError: Unsupported reification of ir.Expression kind: ${\n          ir.ExpressionKind[(expr as ir.Expression).kind]}`);\n  }\n}\n\n/**\n * Listeners get turned into a function expression, which may or may not have the `$event`\n * parameter defined.\n */\nfunction reifyListenerHandler(\n    view: ViewCompilation, name: string, handlerOps: ir.OpList<ir.UpdateOp>): o.FunctionExpr {\n  const lookForEvent = new LookForEventVisitor();\n\n  // First, reify all instruction calls within `handlerOps`.\n  reifyUpdateOperations(view, handlerOps);\n\n  // Next, extract all the `o.Statement`s from the reified operations. We can expect that at this\n  // point, all operations have been converted to statements.\n  const handlerStmts: o.Statement[] = [];\n  for (const op of handlerOps) {\n    if (op.kind !== ir.OpKind.Statement) {\n      throw new Error(\n          `AssertionError: expected reified statements, but found op ${ir.OpKind[op.kind]}`);\n    }\n    handlerStmts.push(op.statement);\n  }\n\n  // Scan the statement list for usages of `$event`. If referenced, we need to generate it as a\n  // parameter.\n  lookForEvent.visitAllStatements(handlerStmts, null);\n\n  const params: o.FnParam[] = [];\n  if (lookForEvent.seenEventRead) {\n    // We need the `$event` parameter.\n    params.push(new o.FnParam('$event'));\n  }\n\n  return o.fn(params, handlerStmts, undefined, undefined, name);\n}\n\n/**\n * Visitor which scans for reads of the `$event` special variable.\n */\nclass LookForEventVisitor extends o.RecursiveAstVisitor {\n  seenEventRead = false;\n\n  override visitReadVarExpr(ast: o.ReadVarExpr, context: any) {\n    if (ast.name === '$event') {\n      this.seenEventRead = true;\n    }\n  }\n}\n"]}

package/esm2022/src/template/pipeline/src/phases/resolve_contexts.mjs

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import * as o from '../../../../output/output_ast';
+import * as ir from '../../ir';
+/**
+ * Resolves `ir.ContextExpr` expressions (which represent embedded view or component contexts) to
+ * either the `ctx` parameter to component functions (for the current view context) or to variables
+ * that store those contexts (for contexts accessed via the `nextContext()` instruction).
+ */
+export function phaseResolveContexts(cpl) {
+    for (const view of cpl.views.values()) {
+        processLexicalScope(view, view.create);
+        processLexicalScope(view, view.update);
+    }
+}
+function processLexicalScope(view, ops) {
+    // Track the expressions used to access all available contexts within the current view, by the
+    // view `ir.XrefId`.
+    const scope = new Map();
+    // The current view's context is accessible via the `ctx` parameter.
+    scope.set(view.xref, o.variable('ctx'));
+    for (const op of ops) {
+        switch (op.kind) {
+            case ir.OpKind.Variable:
+                switch (op.variable.kind) {
+                    case ir.SemanticVariableKind.Context:
+                        scope.set(op.variable.view, new ir.ReadVariableExpr(op.xref));
+                        break;
+                }
+                break;
+            case ir.OpKind.Listener:
+                processLexicalScope(view, op.handlerOps);
+                break;
+        }
+    }
+    for (const op of ops) {
+        ir.transformExpressionsInOp(op, expr => {
+            if (expr instanceof ir.ContextExpr) {
+                if (!scope.has(expr.view)) {
+                    throw new Error(`No context found for reference to view ${expr.view} from view ${view.xref}`);
+                }
+                return scope.get(expr.view);
+            }
+            else {
+                return expr;
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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