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

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

@@ -0,0 +1,95 @@
+/**
+ * @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 lexical references in views (`ir.LexicalReadExpr`) to either a target variable or to
+ * property reads on the top-level component context.
+ *
+ * Also matches `ir.RestoreViewExpr` expressions with the variables of their corresponding saved
+ * views.
+ */
+export function phaseResolveNames(cpl) {
+    for (const [_, view] of cpl.views) {
+        processLexicalScope(view, view.create, null);
+        processLexicalScope(view, view.update, null);
+    }
+}
+function processLexicalScope(view, ops, savedView) {
+    // Maps names defined in the lexical scope of this template to the `ir.XrefId`s of the variable
+    // declarations which represent those values.
+    //
+    // Since variables are generated in each view for the entire lexical scope (including any
+    // identifiers from parent templates) only local variables need be considered here.
+    const scope = new Map();
+    // First, step through the operations list and:
+    // 1) build up the `scope` mapping
+    // 2) recurse into any listener functions
+    for (const op of ops) {
+        switch (op.kind) {
+            case ir.OpKind.Variable:
+                switch (op.variable.kind) {
+                    case ir.SemanticVariableKind.Identifier:
+                        // This variable represents some kind of identifier which can be used in the template.
+                        if (scope.has(op.variable.name)) {
+                            continue;
+                        }
+                        scope.set(op.variable.name, op.xref);
+                        break;
+                    case ir.SemanticVariableKind.SavedView:
+                        // This variable represents a snapshot of the current view context, and can be used to
+                        // restore that context within listener functions.
+                        savedView = {
+                            view: op.variable.view,
+                            variable: op.xref,
+                        };
+                        break;
+                }
+                break;
+            case ir.OpKind.Listener:
+                // Listener functions have separate variable declarations, so process them as a separate
+                // lexical scope.
+                processLexicalScope(view, op.handlerOps, savedView);
+                break;
+        }
+    }
+    // Next, use the `scope` mapping to match `ir.LexicalReadExpr` with defined names in the lexical
+    // scope. Also, look for `ir.RestoreViewExpr`s and match them with the snapshotted view context
+    // variable.
+    for (const op of ops) {
+        ir.transformExpressionsInOp(op, expr => {
+            if (expr instanceof ir.LexicalReadExpr) {
+                // `expr` is a read of a name within the lexical scope of this view.
+                // Either that name is defined within the current view, or it represents a property from the
+                // main component context.
+                if (scope.has(expr.name)) {
+                    // This was a defined variable in the current scope.
+                    return new ir.ReadVariableExpr(scope.get(expr.name));
+                }
+                else {
+                    // Reading from the component context.
+                    return new o.ReadPropExpr(new ir.ContextExpr(view.tpl.root.xref), expr.name);
+                }
+            }
+            else if (expr instanceof ir.RestoreViewExpr && typeof expr.view === 'number') {
+                // `ir.RestoreViewExpr` happens in listener functions and restores a saved view from the
+                // parent creation list. We expect to find that we captured the `savedView` previously, and
+                // that it matches the expected view to be restored.
+                if (savedView === null || savedView.view !== expr.view) {
+                    throw new Error(`AssertionError: no saved view ${expr.view} from view ${view.xref}`);
+                }
+                expr.view = new ir.ReadVariableExpr(savedView.variable);
+                return expr;
+            }
+            else {
+                return expr;
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resolve_names.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/resolve_names.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';\nimport {ComponentCompilation, ViewCompilation} from '../compilation';\n\n/**\n * Resolves lexical references in views (`ir.LexicalReadExpr`) to either a target variable or to\n * property reads on the top-level component context.\n *\n * Also matches `ir.RestoreViewExpr` expressions with the variables of their corresponding saved\n * views.\n */\nexport function phaseResolveNames(cpl: ComponentCompilation): void {\n  for (const [_, view] of cpl.views) {\n    processLexicalScope(view, view.create, null);\n    processLexicalScope(view, view.update, null);\n  }\n}\n\nfunction processLexicalScope(\n    view: ViewCompilation, ops: ir.OpList<ir.CreateOp>|ir.OpList<ir.UpdateOp>,\n    savedView: SavedView|null): void {\n  // Maps names defined in the lexical scope of this template to the `ir.XrefId`s of the variable\n  // declarations which represent those values.\n  //\n  // Since variables are generated in each view for the entire lexical scope (including any\n  // identifiers from parent templates) only local variables need be considered here.\n  const scope = new Map<string, ir.XrefId>();\n\n  // First, step through the operations list and:\n  // 1) build up the `scope` mapping\n  // 2) recurse into any listener functions\n  for (const op of ops) {\n    switch (op.kind) {\n      case ir.OpKind.Variable:\n        switch (op.variable.kind) {\n          case ir.SemanticVariableKind.Identifier:\n            // This variable represents some kind of identifier which can be used in the template.\n            if (scope.has(op.variable.name)) {\n              continue;\n            }\n            scope.set(op.variable.name, op.xref);\n            break;\n          case ir.SemanticVariableKind.SavedView:\n            // This variable represents a snapshot of the current view context, and can be used to\n            // restore that context within listener functions.\n            savedView = {\n              view: op.variable.view,\n              variable: op.xref,\n            };\n            break;\n        }\n        break;\n      case ir.OpKind.Listener:\n        // Listener functions have separate variable declarations, so process them as a separate\n        // lexical scope.\n        processLexicalScope(view, op.handlerOps, savedView);\n        break;\n    }\n  }\n\n  // Next, use the `scope` mapping to match `ir.LexicalReadExpr` with defined names in the lexical\n  // scope. Also, look for `ir.RestoreViewExpr`s and match them with the snapshotted view context\n  // variable.\n  for (const op of ops) {\n    ir.transformExpressionsInOp(op, expr => {\n      if (expr instanceof ir.LexicalReadExpr) {\n        // `expr` is a read of a name within the lexical scope of this view.\n        // Either that name is defined within the current view, or it represents a property from the\n        // main component context.\n        if (scope.has(expr.name)) {\n          // This was a defined variable in the current scope.\n          return new ir.ReadVariableExpr(scope.get(expr.name)!);\n        } else {\n          // Reading from the component context.\n          return new o.ReadPropExpr(new ir.ContextExpr(view.tpl.root.xref), expr.name);\n        }\n      } else if (expr instanceof ir.RestoreViewExpr && typeof expr.view === 'number') {\n        // `ir.RestoreViewExpr` happens in listener functions and restores a saved view from the\n        // parent creation list. We expect to find that we captured the `savedView` previously, and\n        // that it matches the expected view to be restored.\n        if (savedView === null || savedView.view !== expr.view) {\n          throw new Error(`AssertionError: no saved view ${expr.view} from view ${view.xref}`);\n        }\n        expr.view = new ir.ReadVariableExpr(savedView.variable);\n        return expr;\n      } else {\n        return expr;\n      }\n    });\n  }\n}\n\n/**\n * Information about a `SavedView` variable.\n */\ninterface SavedView {\n  /**\n   * The view `ir.XrefId` which was saved into this variable.\n   */\n  view: ir.XrefId;\n\n  /**\n   * The `ir.XrefId` of the variable into which the view was saved.\n   */\n  variable: ir.XrefId;\n}\n"]}

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

@@ -0,0 +1,75 @@
+/**
+ * @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';
+/**
+ * Assign data slots for all operations which implement `ConsumesSlotOpTrait`, and propagate the
+ * assigned data slots of those operations to any expressions which reference them via
+ * `UsesSlotIndexExprTrait`.
+ *
+ * This phase is also responsible for counting the number of slots used for each view (its `decls`)
+ * and propagating that number into the `Template` operations which declare embedded views.
+ */
+export function phaseSlotAllocation(cpl) {
+    // Map of all declarations in all views within the component which require an assigned slot index.
+    // This map needs to be global (across all views within the component) since it's possible to
+    // reference a slot from one view from an expression within another (e.g. local references work
+    // this way).
+    const slotMap = new Map();
+    // Process all views in the component and assign slot indexes.
+    for (const [_, view] of cpl.views) {
+        // Slot indices start at 0 for each view (and are not unique between views).
+        let slotCount = 0;
+        for (const op of view.create) {
+            // Only consider declarations which consume data slots.
+            if (!ir.hasConsumesSlotTrait(op)) {
+                continue;
+            }
+            // Assign slots to this declaration starting at the current `slotCount`.
+            op.slot = slotCount;
+            // And track its assigned slot in the `slotMap`.
+            slotMap.set(op.xref, op.slot);
+            // Each declaration may use more than 1 slot, so increment `slotCount` to reserve the number
+            // of slots required.
+            slotCount += op.numSlotsUsed;
+        }
+        // Record the total number of slots used on the view itself. This will later be propagated into
+        // `ir.TemplateOp`s which declare those views (except for the root view).
+        view.decls = slotCount;
+    }
+    // After slot assignment, `slotMap` now contains slot assignments for every declaration in the
+    // whole template, across all views. Next, look for expressions which implement
+    // `UsesSlotIndexExprTrait` and propagate the assigned slot indexes into them.
+    // Additionally, this second scan allows us to find `ir.TemplateOp`s which declare views and
+    // propagate the number of slots used for each view into the operation which declares it.
+    for (const [_, view] of cpl.views) {
+        for (const op of view.ops()) {
+            if (op.kind === ir.OpKind.Template) {
+                // Record the number of slots used by the view this `ir.TemplateOp` declares in the
+                // operation itself, so it can be emitted later.
+                const childView = cpl.views.get(op.xref);
+                op.decls = childView.decls;
+            }
+            // Process all `ir.Expression`s within this view, and look for `usesSlotIndexExprTrait`.
+            ir.visitExpressionsInOp(op, expr => {
+                if (!ir.hasUsesSlotIndexTrait(expr) || expr.slot !== null) {
+                    return;
+                }
+                // The `UsesSlotIndexExprTrait` indicates that this expression references something declared
+                // in this component template by its slot index. Use the `target` `ir.XrefId` to find the
+                // allocated slot for that declaration in `slotMap`.
+                if (!slotMap.has(expr.target)) {
+                    // We do expect to find a slot allocated for everything which might be referenced.
+                    throw new Error(`AssertionError: no slot allocated for ${expr.constructor.name} target ${expr.target}`);
+                }
+                // Record the allocated slot on the expression.
+                expr.slot = slotMap.get(expr.target);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,60 @@
+/**
+ * @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';
+/**
+ * Counts the number of variable slots used within each view, and stores that on the view itself, as
+ * well as propagates it to the `ir.TemplateOp` for embedded views.
+ */
+export function phaseVarCounting(cpl) {
+    // First, count the vars used in each view, and update the view-level counter.
+    for (const [_, view] of cpl.views) {
+        let varCount = 0;
+        for (const op of view.ops()) {
+            if (ir.hasConsumesVarsTrait(op)) {
+                varCount += varsUsedByOp(op);
+            }
+            ir.visitExpressionsInOp(op, expr => {
+                if (ir.hasConsumesVarsTrait(expr)) {
+                    varCount += varsUsedByIrExpression(expr);
+                }
+            });
+        }
+        view.vars = varCount;
+    }
+    // Add var counts for each view to the `ir.TemplateOp` which declares that view (if the view is an
+    // embedded view).
+    for (const [_, view] of cpl.views) {
+        for (const op of view.create) {
+            if (op.kind !== ir.OpKind.Template) {
+                continue;
+            }
+            const childView = cpl.views.get(op.xref);
+            op.vars = childView.vars;
+        }
+    }
+}
+/**
+ * Different operations that implement `ir.UsesVarsTrait` use different numbers of variables, so
+ * count the variables used by any particular `op`.
+ */
+function varsUsedByOp(op) {
+    switch (op.kind) {
+        case ir.OpKind.Property:
+            // Property bindings use 1 variable slot.
+            return 1;
+        case ir.OpKind.InterpolateText:
+            // `ir.InterpolateTextOp`s use a variable slot for each dynamic expression.
+            return op.expressions.length;
+        default:
+            throw new Error(`Unhandled op: ${ir.OpKind[op.kind]}`);
+    }
+}
+function varsUsedByIrExpression(expr) {
+    return 0;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/template/pipeline/switch/index.mjs

@@ -0,0 +1,2 @@
+export const USE_TEMPLATE_PIPELINE = false;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci9zcmMvdGVtcGxhdGUvcGlwZWxpbmUvc3dpdGNoL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLEtBQUssQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBVU0VfVEVNUExBVEVfUElQRUxJTkUgPSBmYWxzZTtcbiJdfQ==

package/esm2022/src/version.mjs

@@ -11,5 +11,5 @@
  * Entry point for all public APIs of the compiler package.
  */
 import { Version } from './util';
-export const VERSION = new Version('16.0.0-next.7');
+export const VERSION = new Version('16.0.0-rc.0');
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sUUFBUSxDQUFDO0FBRS9CLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxJQUFJLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8qKlxuICogQG1vZHVsZVxuICogQGRlc2NyaXB0aW9uXG4gKiBFbnRyeSBwb2ludCBmb3IgYWxsIHB1YmxpYyBBUElzIG9mIHRoZSBjb21waWxlciBwYWNrYWdlLlxuICovXG5cbmltcG9ydCB7VmVyc2lvbn0gZnJvbSAnLi91dGlsJztcblxuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBuZXcgVmVyc2lvbignMC4wLjAtUExBQ0VIT0xERVInKTtcbiJdfQ==