@angular/compiler 16.0.0-rc.1 → 16.0.0-rc.3

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

@@ -9,7 +9,7 @@ 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`.
+ * `UsesSlotIndexTrait`.
  *
  * 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.
@@ -54,6 +54,13 @@ export function phaseSlotAllocation(cpl) {
                 const childView = cpl.views.get(op.xref);
                 op.decls = childView.decls;
             }
+            if (ir.hasUsesSlotIndexTrait(op) && op.slot === null) {
+                if (!slotMap.has(op.target)) {
+                    // We do expect to find a slot allocated for everything which might be referenced.
+                    throw new Error(`AssertionError: no slot allocated for ${ir.OpKind[op.kind]} target ${op.target}`);
+                }
+                op.slot = slotMap.get(op.target);
+            }
             // Process all `ir.Expression`s within this view, and look for `usesSlotIndexExprTrait`.
             ir.visitExpressionsInOp(op, expr => {
                 if (!ir.hasUsesSlotIndexTrait(expr) || expr.slot !== null) {
@@ -72,4 +79,4 @@ export function phaseSlotAllocation(cpl) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slot_allocation.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/slot_allocation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,UAAU,CAAC;AAG/B;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAyB;IAC3D,kGAAkG;IAClG,6FAA6F;IAC7F,+FAA+F;IAC/F,aAAa;IACb,MAAM,OAAO,GAAG,IAAI,GAAG,EAAqB,CAAC;IAE7C,8DAA8D;IAC9D,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE;QACjC,4EAA4E;QAC5E,IAAI,SAAS,GAAG,CAAC,CAAC;QAElB,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE;YAC5B,uDAAuD;YACvD,IAAI,CAAC,EAAE,CAAC,oBAAoB,CAAC,EAAE,CAAC,EAAE;gBAChC,SAAS;aACV;YAED,wEAAwE;YACxE,EAAE,CAAC,IAAI,GAAG,SAAS,CAAC;YAEpB,gDAAgD;YAChD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;YAE9B,4FAA4F;YAC5F,qBAAqB;YACrB,SAAS,IAAI,EAAE,CAAC,YAAY,CAAC;SAC9B;QAED,+FAA+F;QAC/F,yEAAyE;QACzE,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;KACxB;IAED,8FAA8F;IAC9F,+EAA+E;IAC/E,8EAA8E;IAC9E,4FAA4F;IAC5F,yFAAyF;IACzF,KAAK,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE;QACjC,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,EAAE;YAC3B,IAAI,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE;gBAClC,mFAAmF;gBACnF,gDAAgD;gBAChD,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAE,CAAC;gBAC1C,EAAE,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;aAC5B;YAED,IAAI,EAAE,CAAC,qBAAqB,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE;gBACpD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE;oBAC3B,kFAAkF;oBAClF,MAAM,IAAI,KAAK,CACX,yCAAyC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC;iBACxF;gBAED,EAAE,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAE,CAAC;aACnC;YAED,wFAAwF;YACxF,EAAE,CAAC,oBAAoB,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE;gBACjC,IAAI,CAAC,EAAE,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;oBACzD,OAAO;iBACR;gBAED,4FAA4F;gBAC5F,yFAAyF;gBACzF,oDAAoD;gBAEpD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;oBAC7B,kFAAkF;oBAClF,MAAM,IAAI,KAAK,CAAC,yCAAyC,IAAI,CAAC,WAAW,CAAC,IAAI,WAC1E,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;iBACpB;gBAED,+CAA+C;gBAC/C,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAE,CAAC;YACxC,CAAC,CAAC,CAAC;SACJ;KACF;AACH,CAAC","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 ir from '../../ir';\nimport type {ComponentCompilation} from '../compilation';\n\n/**\n * Assign data slots for all operations which implement `ConsumesSlotOpTrait`, and propagate the\n * assigned data slots of those operations to any expressions which reference them via\n * `UsesSlotIndexTrait`.\n *\n * This phase is also responsible for counting the number of slots used for each view (its `decls`)\n * and propagating that number into the `Template` operations which declare embedded views.\n */\nexport function phaseSlotAllocation(cpl: ComponentCompilation): void {\n  // Map of all declarations in all views within the component which require an assigned slot index.\n  // This map needs to be global (across all views within the component) since it's possible to\n  // reference a slot from one view from an expression within another (e.g. local references work\n  // this way).\n  const slotMap = new Map<ir.XrefId, number>();\n\n  // Process all views in the component and assign slot indexes.\n  for (const [_, view] of cpl.views) {\n    // Slot indices start at 0 for each view (and are not unique between views).\n    let slotCount = 0;\n\n    for (const op of view.create) {\n      // Only consider declarations which consume data slots.\n      if (!ir.hasConsumesSlotTrait(op)) {\n        continue;\n      }\n\n      // Assign slots to this declaration starting at the current `slotCount`.\n      op.slot = slotCount;\n\n      // And track its assigned slot in the `slotMap`.\n      slotMap.set(op.xref, op.slot);\n\n      // Each declaration may use more than 1 slot, so increment `slotCount` to reserve the number\n      // of slots required.\n      slotCount += op.numSlotsUsed;\n    }\n\n    // Record the total number of slots used on the view itself. This will later be propagated into\n    // `ir.TemplateOp`s which declare those views (except for the root view).\n    view.decls = slotCount;\n  }\n\n  // After slot assignment, `slotMap` now contains slot assignments for every declaration in the\n  // whole template, across all views. Next, look for expressions which implement\n  // `UsesSlotIndexExprTrait` and propagate the assigned slot indexes into them.\n  // Additionally, this second scan allows us to find `ir.TemplateOp`s which declare views and\n  // propagate the number of slots used for each view into the operation which declares it.\n  for (const [_, view] of cpl.views) {\n    for (const op of view.ops()) {\n      if (op.kind === ir.OpKind.Template) {\n        // Record the number of slots used by the view this `ir.TemplateOp` declares in the\n        // operation itself, so it can be emitted later.\n        const childView = cpl.views.get(op.xref)!;\n        op.decls = childView.decls;\n      }\n\n      if (ir.hasUsesSlotIndexTrait(op) && op.slot === null) {\n        if (!slotMap.has(op.target)) {\n          // We do expect to find a slot allocated for everything which might be referenced.\n          throw new Error(\n              `AssertionError: no slot allocated for ${ir.OpKind[op.kind]} target ${op.target}`);\n        }\n\n        op.slot = slotMap.get(op.target)!;\n      }\n\n      // Process all `ir.Expression`s within this view, and look for `usesSlotIndexExprTrait`.\n      ir.visitExpressionsInOp(op, expr => {\n        if (!ir.hasUsesSlotIndexTrait(expr) || expr.slot !== null) {\n          return;\n        }\n\n        // The `UsesSlotIndexExprTrait` indicates that this expression references something declared\n        // in this component template by its slot index. Use the `target` `ir.XrefId` to find the\n        // allocated slot for that declaration in `slotMap`.\n\n        if (!slotMap.has(expr.target)) {\n          // We do expect to find a slot allocated for everything which might be referenced.\n          throw new Error(`AssertionError: no slot allocated for ${expr.constructor.name} target ${\n              expr.target}`);\n        }\n\n        // Record the allocated slot on the expression.\n        expr.slot = slotMap.get(expr.target)!;\n      });\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,359 @@
+/**
+ * @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';
+/**
+ * Optimize variables declared and used in the IR.
+ *
+ * Variables are eagerly generated by pipeline stages for all possible values that could be
+ * referenced. This stage processes the list of declared variables and all variable usages,
+ * and optimizes where possible. It performs 3 main optimizations:
+ *
+ *   * It transforms variable declarations to side effectful expressions when the
+ *     variable is not used, but its initializer has global effects which other
+ *     operations rely upon.
+ *   * It removes variable declarations if those variables are not referenced and
+ *     either they do not have global effects, or nothing relies on them.
+ *   * It inlines variable declarations when those variables are only used once
+ *     and the inlining is semantically safe.
+ *
+ * To guarantee correctness, analysis of "fences" in the instruction lists is used to determine
+ * which optimizations are safe to perform.
+ */
+export function phaseVariableOptimization(cpl, options) {
+    for (const [_, view] of cpl.views) {
+        optimizeVariablesInOpList(view.create, options);
+        optimizeVariablesInOpList(view.update, options);
+        for (const op of view.create) {
+            if (op.kind === ir.OpKind.Listener) {
+                optimizeVariablesInOpList(op.handlerOps, options);
+            }
+        }
+    }
+}
+/**
+ * A [fence](https://en.wikipedia.org/wiki/Memory_barrier) flag for an expression which indicates
+ * how that expression can be optimized in relation to other expressions or instructions.
+ *
+ * `Fence`s are a bitfield, so multiple flags may be set on a single expression.
+ */
+var Fence;
+(function (Fence) {
+    /**
+     * Empty flag (no fence exists).
+     */
+    Fence[Fence["None"] = 0] = "None";
+    /**
+     * A context read fence, meaning that the expression in question reads from the "current view"
+     * context of the runtime.
+     */
+    Fence[Fence["ViewContextRead"] = 1] = "ViewContextRead";
+    /**
+     * A context write fence, meaning that the expression in question writes to the "current view"
+     * context of the runtime.
+     *
+     * Note that all `ContextWrite` fences are implicitly `ContextRead` fences as operations which
+     * change the view context do so based on the current one.
+     */
+    Fence[Fence["ViewContextWrite"] = 3] = "ViewContextWrite";
+    /**
+     * Indicates that a call is required for its side-effects, even if nothing reads its result.
+     *
+     * This is also true of `ViewContextWrite` operations **if** they are followed by a
+     * `ViewContextRead`.
+     */
+    Fence[Fence["SideEffectful"] = 4] = "SideEffectful";
+})(Fence || (Fence = {}));
+/**
+ * Process a list of operations and optimize variables within that list.
+ */
+function optimizeVariablesInOpList(ops, options) {
+    const varDecls = new Map();
+    const varUsages = new Map();
+    // Track variables that are used outside of the immediate operation list. For example, within
+    // `ListenerOp` handler operations of listeners in the current operation list.
+    const varRemoteUsages = new Set();
+    const opMap = new Map();
+    // First, extract information about variables declared or used within the whole list.
+    for (const op of ops) {
+        if (op.kind === ir.OpKind.Variable) {
+            if (varDecls.has(op.xref) || varUsages.has(op.xref)) {
+                throw new Error(`Should not see two declarations of the same variable: ${op.xref}`);
+            }
+            varDecls.set(op.xref, op);
+            varUsages.set(op.xref, 0);
+        }
+        opMap.set(op, collectOpInfo(op));
+        countVariableUsages(op, varUsages, varRemoteUsages);
+    }
+    // The next step is to remove any variable declarations for variables that aren't used. The
+    // variable initializer expressions may be side-effectful, so they may need to be retained as
+    // expression statements.
+    // Track whether we've seen an operation which reads from the view context yet. This is used to
+    // determine whether a write to the view context in a variable initializer can be observed.
+    let contextIsUsed = false;
+    // Note that iteration through the list happens in reverse, which guarantees that we'll process
+    // all reads of a variable prior to processing its declaration.
+    for (const op of ops.reversed()) {
+        const opInfo = opMap.get(op);
+        if (op.kind === ir.OpKind.Variable && varUsages.get(op.xref) === 0) {
+            // This variable is unused and can be removed. We might need to keep the initializer around,
+            // though, if something depends on it running.
+            if ((contextIsUsed && opInfo.fences & Fence.ViewContextWrite) ||
+                (opInfo.fences & Fence.SideEffectful)) {
+                // This variable initializer has a side effect which must be retained. Either:
+                //  * it writes to the view context, and we know there is a future operation which depends
+                //    on that write, or
+                //  * it's an operation which is inherently side-effectful.
+                // We can't remove the initializer, but we can remove the variable declaration itself and
+                // replace it with a side-effectful statement.
+                const stmtOp = ir.createStatementOp(op.initializer.toStmt());
+                opMap.set(stmtOp, opInfo);
+                ir.OpList.replace(op, stmtOp);
+            }
+            else {
+                // It's safe to delete this entire variable declaration as nothing depends on it, even
+                // side-effectfully. Note that doing this might make other variables unused. Since we're
+                // iterating in reverse order, we should always be processing usages before declarations
+                // and therefore by the time we get to a declaration, all removable usages will have been
+                // removed.
+                uncountVariableUsages(op, varUsages);
+                ir.OpList.remove(op);
+            }
+            opMap.delete(op);
+            varDecls.delete(op.xref);
+            varUsages.delete(op.xref);
+            continue;
+        }
+        // Does this operation depend on the view context?
+        if (opInfo.fences & Fence.ViewContextRead) {
+            contextIsUsed = true;
+        }
+    }
+    // Next, inline any remaining variables with exactly one usage.
+    const toInline = [];
+    for (const [id, count] of varUsages) {
+        // We can inline variables that:
+        //  - are used once
+        //  - are not used remotely
+        if (count !== 1) {
+            // We can't inline this variable as it's used more than once.
+            continue;
+        }
+        if (varRemoteUsages.has(id)) {
+            // This variable is used once, but across an operation boundary, so it can't be inlined.
+            continue;
+        }
+        toInline.push(id);
+    }
+    let candidate;
+    while (candidate = toInline.pop()) {
+        // We will attempt to inline this variable. If inlining fails (due to fences for example),
+        // no future operation will make inlining legal.
+        const decl = varDecls.get(candidate);
+        const varInfo = opMap.get(decl);
+        // Scan operations following the variable declaration and look for the point where that variable
+        // is used. There should only be one usage given the precondition above.
+        for (let targetOp = decl.next; targetOp.kind !== ir.OpKind.ListEnd; targetOp = targetOp.next) {
+            const opInfo = opMap.get(targetOp);
+            // Is the variable used in this operation?
+            if (opInfo.variablesUsed.has(candidate)) {
+                if (options.conservative && !allowConservativeInlining(decl, targetOp)) {
+                    // We're in conservative mode, and this variable is not eligible for inlining into the
+                    // target operation in this mode.
+                    break;
+                }
+                // Yes, try to inline it. Inlining may not be successful if fences in this operation before
+                // the variable's usage cannot be safely crossed.
+                if (tryInlineVariableInitializer(candidate, decl.initializer, targetOp, varInfo.fences)) {
+                    // Inlining was successful! Update the tracking structures to reflect the inlined
+                    // variable.
+                    opInfo.variablesUsed.delete(candidate);
+                    // Add all variables used in the variable's initializer to its new usage site.
+                    for (const id of varInfo.variablesUsed) {
+                        opInfo.variablesUsed.add(id);
+                    }
+                    // Merge fences in the variable's initializer into its new usage site.
+                    opInfo.fences |= varInfo.fences;
+                    // Delete tracking info related to the declaration.
+                    varDecls.delete(candidate);
+                    varUsages.delete(candidate);
+                    opMap.delete(decl);
+                    // And finally, delete the original declaration from the operation list.
+                    ir.OpList.remove(decl);
+                }
+                // Whether inlining succeeded or failed, we're done processing this variable.
+                break;
+            }
+            // If the variable is not used in this operation, then we'd need to inline across it. Check if
+            // that's safe to do.
+            if (!safeToInlinePastFences(opInfo.fences, varInfo.fences)) {
+                // We can't safely inline this variable beyond this operation, so don't proceed with
+                // inlining this variable.
+                break;
+            }
+        }
+    }
+}
+/**
+ * Given an `ir.Expression`, returns the `Fence` flags for that expression type.
+ */
+function fencesForIrExpression(expr) {
+    switch (expr.kind) {
+        case ir.ExpressionKind.NextContext:
+            return Fence.ViewContextWrite;
+        case ir.ExpressionKind.RestoreView:
+            return Fence.ViewContextWrite | Fence.SideEffectful;
+        case ir.ExpressionKind.Reference:
+            return Fence.ViewContextRead;
+        default:
+            return Fence.None;
+    }
+}
+/**
+ * Build the `OpInfo` structure for the given `op`. This performs two operations:
+ *
+ *  * It tracks which variables are used in the operation's expressions.
+ *  * It rolls up fence flags for expressions within the operation.
+ */
+function collectOpInfo(op) {
+    let fences = Fence.None;
+    const variablesUsed = new Set();
+    ir.visitExpressionsInOp(op, expr => {
+        switch (expr.kind) {
+            case ir.ExpressionKind.ReadVariable:
+                variablesUsed.add(expr.xref);
+                break;
+            default:
+                fences |= fencesForIrExpression(expr);
+        }
+    });
+    return { fences, variablesUsed };
+}
+/**
+ * Count the number of usages of each variable, being careful to track whether those usages are
+ * local or remote.
+ */
+function countVariableUsages(op, varUsages, varRemoteUsage) {
+    ir.visitExpressionsInOp(op, (expr, flags) => {
+        if (expr.kind !== ir.ExpressionKind.ReadVariable) {
+            return;
+        }
+        const count = varUsages.get(expr.xref);
+        if (count === undefined) {
+            // This variable is declared outside the current scope of optimization.
+            return;
+        }
+        varUsages.set(expr.xref, count + 1);
+        if (flags & ir.VisitorContextFlag.InChildOperation) {
+            varRemoteUsage.add(expr.xref);
+        }
+    });
+}
+/**
+ * Remove usages of a variable in `op` from the `varUsages` tracking.
+ */
+function uncountVariableUsages(op, varUsages) {
+    ir.visitExpressionsInOp(op, expr => {
+        if (expr.kind !== ir.ExpressionKind.ReadVariable) {
+            return;
+        }
+        const count = varUsages.get(expr.xref);
+        if (count === undefined) {
+            // This variable is declared outside the current scope of optimization.
+            return;
+        }
+        else if (count === 0) {
+            throw new Error(`Inaccurate variable count: ${expr.xref} - found another read but count is already 0`);
+        }
+        varUsages.set(expr.xref, count - 1);
+    });
+}
+/**
+ * Checks whether it's safe to inline a variable across a particular operation.
+ *
+ * @param fences the fences of the operation which the inlining will cross
+ * @param declFences the fences of the variable being inlined.
+ */
+function safeToInlinePastFences(fences, declFences) {
+    if (fences & Fence.ViewContextWrite) {
+        // It's not safe to inline context reads across context writes.
+        if (declFences & Fence.ViewContextRead) {
+            return false;
+        }
+    }
+    else if (fences & Fence.ViewContextRead) {
+        // It's not safe to inline context writes across context reads.
+        if (declFences & Fence.ViewContextWrite) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Attempt to inline the initializer of a variable into a target operation's expressions.
+ *
+ * This may or may not be safe to do. For example, the variable could be read following the
+ * execution of an expression with fences that don't permit the variable to be inlined across them.
+ */
+function tryInlineVariableInitializer(id, initializer, target, declFences) {
+    // We use `ir.transformExpressionsInOp` to walk the expressions and inline the variable if
+    // possible. Since this operation is callback-based, once inlining succeeds or fails we can't
+    // "stop" the expression processing, and have to keep track of whether inlining has succeeded or
+    // is no longer allowed.
+    let inlined = false;
+    let inliningAllowed = true;
+    ir.transformExpressionsInOp(target, (expr, flags) => {
+        if (inlined || !inliningAllowed) {
+            // Either the inlining has already succeeded, or we've passed a fence that disallows inlining
+            // at this point, so don't try.
+            return expr;
+        }
+        else if ((flags & ir.VisitorContextFlag.InChildOperation) && (declFences & Fence.ViewContextRead)) {
+            // We cannot inline variables that are sensitive to the current context across operation
+            // boundaries.
+            return expr;
+        }
+        switch (expr.kind) {
+            case ir.ExpressionKind.ReadVariable:
+                if (expr.xref === id) {
+                    // This is the usage site of the variable. Since nothing has disallowed inlining, it's
+                    // safe to inline the initializer here.
+                    inlined = true;
+                    return initializer;
+                }
+                break;
+            default:
+                // For other types of `ir.Expression`s, whether inlining is allowed depends on their fences.
+                const exprFences = fencesForIrExpression(expr);
+                inliningAllowed = inliningAllowed && safeToInlinePastFences(exprFences, declFences);
+                break;
+        }
+        return expr;
+    }, ir.VisitorContextFlag.None);
+    return inlined;
+}
+/**
+ * Determines whether inlining of `decl` should be allowed in "conservative" mode.
+ *
+ * In conservative mode, inlining behavior is limited to those operations which the
+ * `TemplateDefinitionBuilder` supported, with the goal of producing equivalent output.
+ */
+function allowConservativeInlining(decl, target) {
+    // TODO(alxhub): understand exactly how TemplateDefinitionBuilder approaches inlining, and record
+    // that behavior here.
+    switch (decl.variable.kind) {
+        case ir.SemanticVariableKind.Identifier:
+            return false;
+        case ir.SemanticVariableKind.Context:
+            // Context can only be inlined into other variables.
+            return target.kind === ir.OpKind.Variable;
+        default:
+            return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"variable_optimization.js","sourceRoot":"","sources":["../../../../../../../../../../packages/compiler/src/template/pipeline/src/phases/variable_optimization.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} from '../compilation';\n\nexport interface VariableOptimizationOptions {\n  conservative: boolean;\n}\n\n/**\n * Optimize variables declared and used in the IR.\n *\n * Variables are eagerly generated by pipeline stages for all possible values that could be\n * referenced. This stage processes the list of declared variables and all variable usages,\n * and optimizes where possible. It performs 3 main optimizations:\n *\n *   * It transforms variable declarations to side effectful expressions when the\n *     variable is not used, but its initializer has global effects which other\n *     operations rely upon.\n *   * It removes variable declarations if those variables are not referenced and\n *     either they do not have global effects, or nothing relies on them.\n *   * It inlines variable declarations when those variables are only used once\n *     and the inlining is semantically safe.\n *\n * To guarantee correctness, analysis of \"fences\" in the instruction lists is used to determine\n * which optimizations are safe to perform.\n */\nexport function phaseVariableOptimization(\n    cpl: ComponentCompilation, options: VariableOptimizationOptions): void {\n  for (const [_, view] of cpl.views) {\n    optimizeVariablesInOpList(view.create, options);\n    optimizeVariablesInOpList(view.update, options);\n\n    for (const op of view.create) {\n      if (op.kind === ir.OpKind.Listener) {\n        optimizeVariablesInOpList(op.handlerOps, options);\n      }\n    }\n  }\n}\n\n/**\n * A [fence](https://en.wikipedia.org/wiki/Memory_barrier) flag for an expression which indicates\n * how that expression can be optimized in relation to other expressions or instructions.\n *\n * `Fence`s are a bitfield, so multiple flags may be set on a single expression.\n */\nenum Fence {\n  /**\n   * Empty flag (no fence exists).\n   */\n  None = 0b000,\n\n  /**\n   * A context read fence, meaning that the expression in question reads from the \"current view\"\n   * context of the runtime.\n   */\n  ViewContextRead = 0b001,\n\n  /**\n   * A context write fence, meaning that the expression in question writes to the \"current view\"\n   * context of the runtime.\n   *\n   * Note that all `ContextWrite` fences are implicitly `ContextRead` fences as operations which\n   * change the view context do so based on the current one.\n   */\n  ViewContextWrite = 0b011,\n\n  /**\n   * Indicates that a call is required for its side-effects, even if nothing reads its result.\n   *\n   * This is also true of `ViewContextWrite` operations **if** they are followed by a\n   * `ViewContextRead`.\n   */\n  SideEffectful = 0b100,\n}\n\n/**\n * Summary data collected for each `Op` in a list.\n *\n * Tracking this data per operation allows the optimizer to process operations at a higher level\n * than always scanning expressions.\n */\ninterface OpInfo {\n  /**\n   * A `Set` of variables referenced by expressions in this operation.\n   */\n  variablesUsed: Set<ir.XrefId>;\n\n  /**\n   * Flags indicating any `Fence`s present for this operation.\n   */\n  fences: Fence;\n}\n\n/**\n * Process a list of operations and optimize variables within that list.\n */\nfunction optimizeVariablesInOpList(\n    ops: ir.OpList<ir.CreateOp|ir.UpdateOp>, options: VariableOptimizationOptions): void {\n  const varDecls = new Map<ir.XrefId, ir.VariableOp<ir.CreateOp|ir.UpdateOp>>();\n  const varUsages = new Map<ir.XrefId, number>();\n\n  // Track variables that are used outside of the immediate operation list. For example, within\n  // `ListenerOp` handler operations of listeners in the current operation list.\n  const varRemoteUsages = new Set<ir.XrefId>();\n  const opMap = new Map<ir.CreateOp|ir.UpdateOp, OpInfo>();\n\n  // First, extract information about variables declared or used within the whole list.\n  for (const op of ops) {\n    if (op.kind === ir.OpKind.Variable) {\n      if (varDecls.has(op.xref) || varUsages.has(op.xref)) {\n        throw new Error(`Should not see two declarations of the same variable: ${op.xref}`);\n      }\n      varDecls.set(op.xref, op);\n      varUsages.set(op.xref, 0);\n    }\n\n    opMap.set(op, collectOpInfo(op));\n    countVariableUsages(op, varUsages, varRemoteUsages);\n  }\n\n  // The next step is to remove any variable declarations for variables that aren't used. The\n  // variable initializer expressions may be side-effectful, so they may need to be retained as\n  // expression statements.\n\n  // Track whether we've seen an operation which reads from the view context yet. This is used to\n  // determine whether a write to the view context in a variable initializer can be observed.\n  let contextIsUsed = false;\n\n  // Note that iteration through the list happens in reverse, which guarantees that we'll process\n  // all reads of a variable prior to processing its declaration.\n  for (const op of ops.reversed()) {\n    const opInfo = opMap.get(op)!;\n\n    if (op.kind === ir.OpKind.Variable && varUsages.get(op.xref)! === 0) {\n      // This variable is unused and can be removed. We might need to keep the initializer around,\n      // though, if something depends on it running.\n      if ((contextIsUsed && opInfo.fences & Fence.ViewContextWrite) ||\n          (opInfo.fences & Fence.SideEffectful)) {\n        // This variable initializer has a side effect which must be retained. Either:\n        //  * it writes to the view context, and we know there is a future operation which depends\n        //    on that write, or\n        //  * it's an operation which is inherently side-effectful.\n        // We can't remove the initializer, but we can remove the variable declaration itself and\n        // replace it with a side-effectful statement.\n        const stmtOp = ir.createStatementOp(op.initializer.toStmt()) as ir.UpdateOp;\n        opMap.set(stmtOp, opInfo);\n        ir.OpList.replace(op as ir.UpdateOp, stmtOp);\n      } else {\n        // It's safe to delete this entire variable declaration as nothing depends on it, even\n        // side-effectfully. Note that doing this might make other variables unused. Since we're\n        // iterating in reverse order, we should always be processing usages before declarations\n        // and therefore by the time we get to a declaration, all removable usages will have been\n        // removed.\n        uncountVariableUsages(op, varUsages);\n        ir.OpList.remove(op as ir.UpdateOp);\n      }\n\n      opMap.delete(op);\n      varDecls.delete(op.xref);\n      varUsages.delete(op.xref);\n      continue;\n    }\n\n    // Does this operation depend on the view context?\n    if (opInfo.fences & Fence.ViewContextRead) {\n      contextIsUsed = true;\n    }\n  }\n\n  // Next, inline any remaining variables with exactly one usage.\n  const toInline: ir.XrefId[] = [];\n  for (const [id, count] of varUsages) {\n    // We can inline variables that:\n    //  - are used once\n    //  - are not used remotely\n    if (count !== 1) {\n      // We can't inline this variable as it's used more than once.\n      continue;\n    }\n\n    if (varRemoteUsages.has(id)) {\n      // This variable is used once, but across an operation boundary, so it can't be inlined.\n      continue;\n    }\n\n    toInline.push(id);\n  }\n\n  let candidate: ir.XrefId|undefined;\n  while (candidate = toInline.pop()) {\n    // We will attempt to inline this variable. If inlining fails (due to fences for example),\n    // no future operation will make inlining legal.\n    const decl = varDecls.get(candidate)!;\n    const varInfo = opMap.get(decl as ir.CreateOp | ir.UpdateOp)!;\n\n    // Scan operations following the variable declaration and look for the point where that variable\n    // is used. There should only be one usage given the precondition above.\n    for (let targetOp = decl.next!; targetOp.kind !== ir.OpKind.ListEnd;\n         targetOp = targetOp.next!) {\n      const opInfo = opMap.get(targetOp)!;\n\n      // Is the variable used in this operation?\n      if (opInfo.variablesUsed.has(candidate)) {\n        if (options.conservative && !allowConservativeInlining(decl, targetOp)) {\n          // We're in conservative mode, and this variable is not eligible for inlining into the\n          // target operation in this mode.\n          break;\n        }\n\n        // Yes, try to inline it. Inlining may not be successful if fences in this operation before\n        // the variable's usage cannot be safely crossed.\n        if (tryInlineVariableInitializer(candidate, decl.initializer, targetOp, varInfo.fences)) {\n          // Inlining was successful! Update the tracking structures to reflect the inlined\n          // variable.\n          opInfo.variablesUsed.delete(candidate);\n\n          // Add all variables used in the variable's initializer to its new usage site.\n          for (const id of varInfo.variablesUsed) {\n            opInfo.variablesUsed.add(id);\n          }\n\n          // Merge fences in the variable's initializer into its new usage site.\n          opInfo.fences |= varInfo.fences;\n\n          // Delete tracking info related to the declaration.\n          varDecls.delete(candidate);\n          varUsages.delete(candidate);\n          opMap.delete(decl as ir.CreateOp | ir.UpdateOp);\n\n          // And finally, delete the original declaration from the operation list.\n          ir.OpList.remove(decl as ir.UpdateOp);\n        }\n\n        // Whether inlining succeeded or failed, we're done processing this variable.\n        break;\n      }\n\n      // If the variable is not used in this operation, then we'd need to inline across it. Check if\n      // that's safe to do.\n      if (!safeToInlinePastFences(opInfo.fences, varInfo.fences)) {\n        // We can't safely inline this variable beyond this operation, so don't proceed with\n        // inlining this variable.\n        break;\n      }\n    }\n  }\n}\n\n/**\n * Given an `ir.Expression`, returns the `Fence` flags for that expression type.\n */\nfunction fencesForIrExpression(expr: ir.Expression): Fence {\n  switch (expr.kind) {\n    case ir.ExpressionKind.NextContext:\n      return Fence.ViewContextWrite;\n    case ir.ExpressionKind.RestoreView:\n      return Fence.ViewContextWrite | Fence.SideEffectful;\n    case ir.ExpressionKind.Reference:\n      return Fence.ViewContextRead;\n    default:\n      return Fence.None;\n  }\n}\n\n/**\n * Build the `OpInfo` structure for the given `op`. This performs two operations:\n *\n *  * It tracks which variables are used in the operation's expressions.\n *  * It rolls up fence flags for expressions within the operation.\n */\nfunction collectOpInfo(op: ir.CreateOp|ir.UpdateOp): OpInfo {\n  let fences = Fence.None;\n  const variablesUsed = new Set<ir.XrefId>();\n  ir.visitExpressionsInOp(op, expr => {\n    switch (expr.kind) {\n      case ir.ExpressionKind.ReadVariable:\n        variablesUsed.add(expr.xref);\n        break;\n      default:\n        fences |= fencesForIrExpression(expr);\n    }\n  });\n  return {fences, variablesUsed};\n}\n\n/**\n * Count the number of usages of each variable, being careful to track whether those usages are\n * local or remote.\n */\nfunction countVariableUsages(\n    op: ir.CreateOp|ir.UpdateOp, varUsages: Map<ir.XrefId, number>,\n    varRemoteUsage: Set<ir.XrefId>): void {\n  ir.visitExpressionsInOp(op, (expr, flags) => {\n    if (expr.kind !== ir.ExpressionKind.ReadVariable) {\n      return;\n    }\n\n    const count = varUsages.get(expr.xref);\n    if (count === undefined) {\n      // This variable is declared outside the current scope of optimization.\n      return;\n    }\n    varUsages.set(expr.xref, count + 1);\n\n    if (flags & ir.VisitorContextFlag.InChildOperation) {\n      varRemoteUsage.add(expr.xref);\n    }\n  });\n}\n\n/**\n * Remove usages of a variable in `op` from the `varUsages` tracking.\n */\nfunction uncountVariableUsages(\n    op: ir.CreateOp|ir.UpdateOp, varUsages: Map<ir.XrefId, number>): void {\n  ir.visitExpressionsInOp(op, expr => {\n    if (expr.kind !== ir.ExpressionKind.ReadVariable) {\n      return;\n    }\n\n    const count = varUsages.get(expr.xref);\n    if (count === undefined) {\n      // This variable is declared outside the current scope of optimization.\n      return;\n    } else if (count === 0) {\n      throw new Error(\n          `Inaccurate variable count: ${expr.xref} - found another read but count is already 0`);\n    }\n    varUsages.set(expr.xref, count - 1);\n  });\n}\n\n/**\n * Checks whether it's safe to inline a variable across a particular operation.\n *\n * @param fences the fences of the operation which the inlining will cross\n * @param declFences the fences of the variable being inlined.\n */\nfunction safeToInlinePastFences(fences: Fence, declFences: Fence): boolean {\n  if (fences & Fence.ViewContextWrite) {\n    // It's not safe to inline context reads across context writes.\n    if (declFences & Fence.ViewContextRead) {\n      return false;\n    }\n  } else if (fences & Fence.ViewContextRead) {\n    // It's not safe to inline context writes across context reads.\n    if (declFences & Fence.ViewContextWrite) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Attempt to inline the initializer of a variable into a target operation's expressions.\n *\n * This may or may not be safe to do. For example, the variable could be read following the\n * execution of an expression with fences that don't permit the variable to be inlined across them.\n */\nfunction tryInlineVariableInitializer(\n    id: ir.XrefId, initializer: o.Expression, target: ir.CreateOp|ir.UpdateOp,\n    declFences: Fence): boolean {\n  // We use `ir.transformExpressionsInOp` to walk the expressions and inline the variable if\n  // possible. Since this operation is callback-based, once inlining succeeds or fails we can't\n  // \"stop\" the expression processing, and have to keep track of whether inlining has succeeded or\n  // is no longer allowed.\n  let inlined = false;\n  let inliningAllowed = true;\n\n  ir.transformExpressionsInOp(target, (expr, flags) => {\n    if (inlined || !inliningAllowed) {\n      // Either the inlining has already succeeded, or we've passed a fence that disallows inlining\n      // at this point, so don't try.\n      return expr;\n    } else if (\n        (flags & ir.VisitorContextFlag.InChildOperation) && (declFences & Fence.ViewContextRead)) {\n      // We cannot inline variables that are sensitive to the current context across operation\n      // boundaries.\n      return expr;\n    }\n\n    switch (expr.kind) {\n      case ir.ExpressionKind.ReadVariable:\n        if (expr.xref === id) {\n          // This is the usage site of the variable. Since nothing has disallowed inlining, it's\n          // safe to inline the initializer here.\n          inlined = true;\n          return initializer;\n        }\n        break;\n      default:\n        // For other types of `ir.Expression`s, whether inlining is allowed depends on their fences.\n        const exprFences = fencesForIrExpression(expr);\n        inliningAllowed = inliningAllowed && safeToInlinePastFences(exprFences, declFences);\n        break;\n    }\n    return expr;\n  }, ir.VisitorContextFlag.None);\n  return inlined;\n}\n\n/**\n * Determines whether inlining of `decl` should be allowed in \"conservative\" mode.\n *\n * In conservative mode, inlining behavior is limited to those operations which the\n * `TemplateDefinitionBuilder` supported, with the goal of producing equivalent output.\n */\nfunction allowConservativeInlining(\n    decl: ir.VariableOp<ir.CreateOp|ir.UpdateOp>, target: ir.Op<ir.CreateOp|ir.UpdateOp>): boolean {\n  // TODO(alxhub): understand exactly how TemplateDefinitionBuilder approaches inlining, and record\n  // that behavior here.\n  switch (decl.variable.kind) {\n    case ir.SemanticVariableKind.Identifier:\n      return false;\n    case ir.SemanticVariableKind.Context:\n      // Context can only be inlined into other variables.\n      return target.kind === ir.OpKind.Variable;\n    default:\n      return true;\n  }\n}\n"]}

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-rc.1');
+export const VERSION = new Version('16.0.0-rc.3');
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sUUFBUSxDQUFDO0FBRS9CLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxJQUFJLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8qKlxuICogQG1vZHVsZVxuICogQGRlc2NyaXB0aW9uXG4gKiBFbnRyeSBwb2ludCBmb3IgYWxsIHB1YmxpYyBBUElzIG9mIHRoZSBjb21waWxlciBwYWNrYWdlLlxuICovXG5cbmltcG9ydCB7VmVyc2lvbn0gZnJvbSAnLi91dGlsJztcblxuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBuZXcgVmVyc2lvbignMC4wLjAtUExBQ0VIT0xERVInKTtcbiJdfQ==