@angular/compiler 17.1.0-next.4 → 17.1.0-next.5

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.1.0-next.4
+ * @license Angular v17.1.0-next.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2308,7 +2308,9 @@ class ConstantPool {
             }))));
         }
     }
-    getSharedFunctionReference(fn, prefix) {
+    // TODO: useUniqueName(false) is necessary for naming compatibility with
+    // TemplateDefinitionBuilder, but should be removed once Template Pipeline is the default.
+    getSharedFunctionReference(fn, prefix, useUniqueName = true) {
         const isArrow = fn instanceof ArrowFunctionExpr;
         for (const current of this.statements) {
             // Arrow functions are saved as variables so we check if the
@@ -2323,7 +2325,7 @@ class ConstantPool {
             }
         }
         // Otherwise declare the function.
-        const name = this.uniqueName(prefix);
+        const name = useUniqueName ? this.uniqueName(prefix) : prefix;
         this.statements.push(fn.toDeclStmt(name, StmtModifier.Final));
         return variable(name);
     }
@@ -3688,13 +3690,18 @@ var TagContentType;
     TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
     TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
 })(TagContentType || (TagContentType = {}));
-function splitNsName(elementName) {
+function splitNsName(elementName, fatal = true) {
     if (elementName[0] != ':') {
         return [null, elementName];
     }
     const colonIndex = elementName.indexOf(':', 1);
     if (colonIndex === -1) {
-        throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+        if (fatal) {
+            throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+        }
+        else {
+            return [null, elementName];
+        }
     }
     return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
 }
@@ -8975,14 +8982,18 @@ var OpKind;
      * An instruction to update an ICU expression.
      */
     OpKind[OpKind["IcuEnd"] = 42] = "IcuEnd";
+    /**
+     * An instruction representing a placeholder in an ICU expression.
+     */
+    OpKind[OpKind["IcuPlaceholder"] = 43] = "IcuPlaceholder";
     /**
      * An i18n context containing information needed to generate an i18n message.
      */
-    OpKind[OpKind["I18nContext"] = 43] = "I18nContext";
+    OpKind[OpKind["I18nContext"] = 44] = "I18nContext";
     /**
      * A creation op that corresponds to i18n attributes on an element.
      */
-    OpKind[OpKind["I18nAttributes"] = 44] = "I18nAttributes";
+    OpKind[OpKind["I18nAttributes"] = 45] = "I18nAttributes";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -9581,12 +9592,13 @@ function createDeferWhenOp(target, expr, prefetch, sourceSpan) {
         sourceSpan,
         ...NEW_OP,
         ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
     };
 }
 /**
  * Create an i18n expression op.
  */
-function createI18nExpressionOp(context, target, i18nOwner, handle, expression, i18nPlaceholder, resolutionTime, usage, name, sourceSpan) {
+function createI18nExpressionOp(context, target, i18nOwner, handle, expression, icuPlaceholder, i18nPlaceholder, resolutionTime, usage, name, sourceSpan) {
     return {
         kind: OpKind.I18nExpression,
         context,
@@ -9594,6 +9606,7 @@ function createI18nExpressionOp(context, target, i18nOwner, handle, expression,
         i18nOwner,
         handle,
         expression,
+        icuPlaceholder,
         i18nPlaceholder,
         resolutionTime,
         usage,
@@ -10363,6 +10376,9 @@ function transformExpressionsInOp(op, transform, flags) {
                 op.placeholderConfig =
                     transformExpressionsInExpression(op.placeholderConfig, transform, flags);
             }
+            if (op.resolverFn !== null) {
+                op.resolverFn = transformExpressionsInExpression(op.resolverFn, transform, flags);
+            }
             break;
         case OpKind.I18nMessage:
             for (const [placeholder, expr] of op.params) {
@@ -10399,6 +10415,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Template:
         case OpKind.Text:
         case OpKind.I18nAttributes:
+        case OpKind.IcuPlaceholder:
             // These operations contain no expressions.
             break;
         default:
@@ -10481,6 +10498,16 @@ function transformExpressionsInExpression(expr, transform, flags) {
         expr.template.expressions =
             expr.template.expressions.map(e => transformExpressionsInExpression(e, transform, flags));
     }
+    else if (expr instanceof ArrowFunctionExpr) {
+        if (Array.isArray(expr.body)) {
+            for (let i = 0; i < expr.body.length; i++) {
+                transformExpressionsInStatement(expr.body[i], transform, flags);
+            }
+        }
+        else {
+            expr.body = transformExpressionsInExpression(expr.body, transform, flags);
+        }
+    }
     else if (expr instanceof WrappedNodeExpr) {
         // TODO: Do we need to transform any TS nodes nested inside of this expression?
     }
@@ -10806,7 +10833,7 @@ function isElementOrContainerOp(op) {
 /**
  * Create an `ElementStartOp`.
  */
-function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan) {
+function createElementStartOp(tag, xref, namespace, i18nPlaceholder, startSourceSpan, wholeSourceSpan) {
     return {
         kind: OpKind.ElementStart,
         xref,
@@ -10817,7 +10844,8 @@ function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan)
         nonBindable: false,
         namespace,
         i18nPlaceholder,
-        sourceSpan,
+        startSourceSpan,
+        wholeSourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
     };
@@ -10825,7 +10853,7 @@ function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan)
 /**
  * Create a `TemplateOp`.
  */
-function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace, i18nPlaceholder, sourceSpan) {
+function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace, i18nPlaceholder, startSourceSpan, wholeSourceSpan) {
     return {
         kind: OpKind.Template,
         xref,
@@ -10840,12 +10868,13 @@ function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace
         nonBindable: false,
         namespace,
         i18nPlaceholder,
-        sourceSpan,
+        startSourceSpan,
+        wholeSourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
     };
 }
-function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, i18nPlaceholder, emptyI18nPlaceholder, sourceSpan) {
+function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, emptyTag, i18nPlaceholder, emptyI18nPlaceholder, startSourceSpan, wholeSourceSpan) {
     return {
         kind: OpKind.RepeaterCreate,
         attributes: null,
@@ -10855,6 +10884,8 @@ function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, i1
         track,
         trackByFn: null,
         tag,
+        emptyTag,
+        emptyAttributes: null,
         functionNameSuffix: 'For',
         namespace: Namespace.HTML,
         nonBindable: false,
@@ -10865,9 +10896,11 @@ function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, i1
         usesComponentInstance: false,
         i18nPlaceholder,
         emptyI18nPlaceholder,
-        sourceSpan,
+        startSourceSpan,
+        wholeSourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
+        ...TRAIT_CONSUMES_VARS,
         numSlotsUsed: emptyView === null ? 2 : 3,
     };
 }
@@ -10899,12 +10932,13 @@ function createEnableBindingsOp(xref) {
 /**
  * Create a `TextOp`.
  */
-function createTextOp(xref, initialValue, sourceSpan) {
+function createTextOp(xref, initialValue, icuPlaceholder, sourceSpan) {
     return {
         kind: OpKind.Text,
         xref,
         handle: new SlotHandle(),
         initialValue,
+        icuPlaceholder,
         sourceSpan,
         ...TRAIT_CONSUMES_SLOT,
         ...NEW_OP,
@@ -10957,7 +10991,7 @@ function createProjectionDefOp(def) {
         ...NEW_OP,
     };
 }
-function createProjectionOp(xref, selector, i18nPlaceholder, attributes, sourceSpan) {
+function createProjectionOp(xref, selector, i18nPlaceholder, sourceSpan) {
     return {
         kind: OpKind.Projection,
         xref,
@@ -10965,7 +10999,7 @@ function createProjectionOp(xref, selector, i18nPlaceholder, attributes, sourceS
         selector,
         i18nPlaceholder,
         projectionSlotIndex: 0,
-        attributes,
+        attributes: null,
         localRefs: [],
         sourceSpan,
         ...NEW_OP,
@@ -11046,7 +11080,7 @@ function createI18nMessageOp(xref, i18nContext, i18nBlock, message, messagePlace
 /**
  * Create an `I18nStartOp`.
  */
-function createI18nStartOp(xref, message, root) {
+function createI18nStartOp(xref, message, root, sourceSpan) {
     return {
         kind: OpKind.I18nStart,
         xref,
@@ -11056,6 +11090,7 @@ function createI18nStartOp(xref, message, root) {
         messageIndex: null,
         subTemplateIndex: null,
         context: null,
+        sourceSpan,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -11063,10 +11098,11 @@ function createI18nStartOp(xref, message, root) {
 /**
  * Create an `I18nEndOp`.
  */
-function createI18nEndOp(xref) {
+function createI18nEndOp(xref, sourceSpan) {
     return {
         kind: OpKind.I18nEnd,
         xref,
+        sourceSpan,
         ...NEW_OP,
     };
 }
@@ -11094,6 +11130,19 @@ function createIcuEndOp(xref) {
         ...NEW_OP,
     };
 }
+/**
+ * Creates an ICU placeholder op.
+ */
+function createIcuPlaceholderOp(xref, name, strings) {
+    return {
+        kind: OpKind.IcuPlaceholder,
+        xref,
+        name,
+        strings,
+        expressionPlaceholders: [],
+        ...NEW_OP,
+    };
+}
 function createI18nContextOp(contextKind, xref, i18nBlock, message, sourceSpan) {
     if (i18nBlock === null && contextKind !== I18nContextKind.Attr) {
         throw new Error('AssertionError: i18nBlock must be provided for non-attribute contexts.');
@@ -11475,6 +11524,13 @@ function createOpXrefMap(unit) {
             continue;
         }
         map.set(op.xref, op);
+        // TODO(dylhunn): `@for` loops with `@empty` blocks need to be special-cased here,
+        // because the slot consumer trait currently only supports one slot per consumer and we
+        // need two. This should be revisited when making the refactors mentioned in:
+        // https://github.com/angular/angular/pull/53620#discussion_r1430918822
+        if (op.kind === OpKind.RepeaterCreate && op.emptyView !== null) {
+            map.set(op.emptyView, op);
+        }
     }
     return map;
 }
@@ -11530,6 +11586,11 @@ function extractAttributes(job) {
                         /* i18nContext */ null, 
                         /* i18nMessage */ null, SecurityContext.NONE);
                         if (job.kind === CompilationJobKind.Host) {
+                            if (job.compatibility) {
+                                // TemplateDefinitionBuilder does not extract listener bindings to the const array
+                                // (which is honestly pretty inconsistent).
+                                break;
+                            }
                             // This attribute will apply to the enclosing host binding compilation unit, so order
                             // doesn't matter.
                             unit.create.push(extractedAttributeOp);
@@ -11560,21 +11621,11 @@ function extractAttributeOp(unit, op, elements) {
     if (op.expression instanceof Interpolation) {
         return;
     }
-    let extractable = op.expression.isConstant();
+    let extractable = op.isTextAttribute || op.expression.isConstant();
     if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
-        // TemplateDefinitionBuilder only extracted attributes that were string literals.
-        extractable = isStringLiteral(op.expression);
-        if (op.name === 'style' || op.name === 'class') {
-            // For style and class attributes, TemplateDefinitionBuilder only extracted them if they were
-            // text attributes. For example, `[attr.class]="'my-class'"` was not extracted despite being a
-            // string literal, because it is not a text attribute.
-            extractable &&= op.isTextAttribute;
-        }
-        if (unit.job.kind === CompilationJobKind.Host) {
-            // TemplateDefinitionBuilder also does not seem to extract string literals if they are part of
-            // a host attribute.
-            extractable &&= op.isTextAttribute;
-        }
+        // TemplateDefinitionBuilder only extracts text attributes. It does not extract attriibute
+        // bindings, even if they are constants.
+        extractable &&= op.isTextAttribute;
     }
     if (extractable) {
         const extractedAttributeOp = createExtractedAttributeOp(op.target, op.isStructuralTemplateAttribute ? BindingKind.Template : BindingKind.Attribute, op.name, op.expression, op.i18nContext, op.i18nMessage, op.securityContext);
@@ -11868,7 +11919,7 @@ function collectElementConsts(job) {
     for (const unit of job.units) {
         for (const op of unit.create) {
             if (op.kind === OpKind.ExtractedAttribute) {
-                const attributes = allElementAttributes.get(op.target) || new ElementAttributes();
+                const attributes = allElementAttributes.get(op.target) || new ElementAttributes(job.compatibility);
                 allElementAttributes.set(op.target, attributes);
                 attributes.add(op.bindingKind, op.name, op.expression, op.trustedValueFn);
                 OpList.remove(op);
@@ -11879,15 +11930,26 @@ function collectElementConsts(job) {
     if (job instanceof ComponentCompilationJob) {
         for (const unit of job.units) {
             for (const op of unit.create) {
-                if (isElementOrContainerOp(op)) {
+                // TODO: Simplify and combine these cases.
+                if (op.kind == OpKind.Projection) {
                     const attributes = allElementAttributes.get(op.xref);
                     if (attributes !== undefined) {
                         const attrArray = serializeAttributes(attributes);
                         if (attrArray.entries.length > 0) {
-                            op.attributes = job.addConst(attrArray);
+                            op.attributes = attrArray;
                         }
                     }
                 }
+                else if (isElementOrContainerOp(op)) {
+                    op.attributes = getConstIndex(job, allElementAttributes, op.xref);
+                    // TODO(dylhunn): `@for` loops with `@empty` blocks need to be special-cased here,
+                    // because the slot consumer trait currently only supports one slot per consumer and we
+                    // need two. This should be revisited when making the refactors mentioned in:
+                    // https://github.com/angular/angular/pull/53620#discussion_r1430918822
+                    if (op.kind === OpKind.RepeaterCreate && op.emptyView !== null) {
+                        op.emptyAttributes = getConstIndex(job, allElementAttributes, op.emptyView);
+                    }
+                }
             }
         }
     }
@@ -11905,6 +11967,16 @@ function collectElementConsts(job) {
         }
     }
 }
+function getConstIndex(job, allElementAttributes, xref) {
+    const attributes = allElementAttributes.get(xref);
+    if (attributes !== undefined) {
+        const attrArray = serializeAttributes(attributes);
+        if (attrArray.entries.length > 0) {
+            return job.addConst(attrArray);
+        }
+    }
+    return null;
+}
 /**
  * Shared instance of an empty array to avoid unnecessary array allocations.
  */
@@ -11913,11 +11985,6 @@ const FLYWEIGHT_ARRAY = Object.freeze([]);
  * Container for all of the various kinds of attributes which are applied on an element.
  */
 class ElementAttributes {
-    constructor() {
-        this.known = new Set();
-        this.byKind = new Map;
-        this.projectAs = null;
-    }
     get attributes() {
         return this.byKind.get(BindingKind.Attribute) ?? FLYWEIGHT_ARRAY;
     }
@@ -11936,11 +12003,31 @@ class ElementAttributes {
     get i18n() {
         return this.byKind.get(BindingKind.I18n) ?? FLYWEIGHT_ARRAY;
     }
+    constructor(compatibility) {
+        this.compatibility = compatibility;
+        this.known = new Map();
+        this.byKind = new Map;
+        this.projectAs = null;
+    }
+    isKnown(kind, name, value) {
+        const nameToValue = this.known.get(kind) ?? new Set();
+        this.known.set(kind, nameToValue);
+        if (nameToValue.has(name)) {
+            return true;
+        }
+        nameToValue.add(name);
+        return false;
+    }
     add(kind, name, value, trustedValueFn) {
-        if (this.known.has(name)) {
+        // TemplateDefinitionBuilder puts duplicate attribute, class, and style values into the consts
+        // array. This seems inefficient, we can probably keep just the first one or the last value
+        // (whichever actually gets applied when multiple values are listed for the same attribute).
+        const allowDuplicates = this.compatibility === CompatibilityMode.TemplateDefinitionBuilder &&
+            (kind === BindingKind.Attribute || kind === BindingKind.ClassName ||
+                kind === BindingKind.StyleProperty);
+        if (!allowDuplicates && this.isKnown(kind, name, value)) {
             return;
         }
-        this.known.add(name);
         // TODO: Can this be its own phase
         if (name === 'ngProjectAs') {
             if (value === null || !(value instanceof LiteralExpr) || (value.value == null) ||
@@ -11979,7 +12066,7 @@ class ElementAttributes {
  * Gets an array of literal expressions representing the attribute's namespaced name.
  */
 function getAttributeNameLiterals$1(name) {
-    const [attributeNamespace, attributeName] = splitNsName(name);
+    const [attributeNamespace, attributeName] = splitNsName(name, false);
     const nameLiteral = literal(attributeName);
     if (attributeNamespace) {
         return [
@@ -12052,7 +12139,7 @@ function convertI18nBindings(job) {
                         if (op.expression.i18nPlaceholders.length !== op.expression.expressions.length) {
                             throw new Error(`AssertionError: An i18n attribute binding instruction requires the same number of expressions and placeholders, but found ${op.expression.i18nPlaceholders.length} placeholders and ${op.expression.expressions.length} expressions`);
                         }
-                        ops.push(createI18nExpressionOp(op.i18nContext, i18nAttributesForElem.target, i18nAttributesForElem.xref, i18nAttributesForElem.handle, expr, op.expression.i18nPlaceholders[i], I18nParamResolutionTime.Creation, I18nExpressionFor.I18nAttribute, op.name, op.sourceSpan));
+                        ops.push(createI18nExpressionOp(op.i18nContext, i18nAttributesForElem.target, i18nAttributesForElem.xref, i18nAttributesForElem.handle, expr, null, op.expression.i18nPlaceholders[i], I18nParamResolutionTime.Creation, I18nExpressionFor.I18nAttribute, op.name, op.sourceSpan));
                     }
                     OpList.replaceWithMany(op, ops);
                     break;
@@ -12089,7 +12176,8 @@ function createDeferDepsFns(job) {
                 if (op.handle.slot === null) {
                     throw new Error('AssertionError: slot must be assigned bfore extracting defer deps functions');
                 }
-                op.resolverFn = job.pool.getSharedFunctionReference(depsFnExpr, `${job.componentName}_Defer_${op.handle.slot}_DepsFn`);
+                op.resolverFn = job.pool.getSharedFunctionReference(depsFnExpr, `${job.componentName}_Defer_${op.handle.slot}_DepsFn`, 
+                /* Don't use unique names for TDB compatibility */ false);
             }
         }
     }
@@ -12106,75 +12194,119 @@ function createDeferDepsFns(job) {
  * message.)
  */
 function createI18nContexts(job) {
-    const rootContexts = new Map();
-    let currentI18nOp = null;
-    let xref;
-    // We use the message instead of the message ID, because placeholder values might differ even
-    // when IDs are the same.
-    const messageToContext = new Map();
+    // Create i18n context ops for i18n attrs.
+    const attrContextByMessage = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            switch (op.kind) {
+                case OpKind.Binding:
+                case OpKind.Property:
+                case OpKind.Attribute:
+                case OpKind.ExtractedAttribute:
+                    if (op.i18nMessage === null) {
+                        continue;
+                    }
+                    if (!attrContextByMessage.has(op.i18nMessage)) {
+                        const i18nContext = createI18nContextOp(I18nContextKind.Attr, job.allocateXrefId(), null, op.i18nMessage, null);
+                        unit.create.push(i18nContext);
+                        attrContextByMessage.set(op.i18nMessage, i18nContext.xref);
+                    }
+                    op.i18nContext = attrContextByMessage.get(op.i18nMessage);
+                    break;
+            }
+        }
+    }
+    // Create i18n context ops for root i18n blocks.
+    const blockContextByI18nBlock = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
-                    currentI18nOp = op;
-                    // Each root i18n block gets its own context, child ones refer to the context for their
-                    // root block.
                     if (op.xref === op.root) {
-                        xref = job.allocateXrefId();
-                        unit.create.push(createI18nContextOp(I18nContextKind.RootI18n, xref, op.xref, op.message, null));
-                        op.context = xref;
-                        rootContexts.set(op.xref, xref);
+                        const contextOp = createI18nContextOp(I18nContextKind.RootI18n, job.allocateXrefId(), op.xref, op.message, null);
+                        unit.create.push(contextOp);
+                        op.context = contextOp.xref;
+                        blockContextByI18nBlock.set(op.xref, contextOp);
                     }
                     break;
+            }
+        }
+    }
+    // Assign i18n contexts for child i18n blocks. These don't need their own conext, instead they
+    // should inherit from their root i18n block.
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.I18nStart && op.xref !== op.root) {
+                const rootContext = blockContextByI18nBlock.get(op.root);
+                if (rootContext === undefined) {
+                    throw Error('AssertionError: Root i18n block i18n context should have been created.');
+                }
+                op.context = rootContext.xref;
+                blockContextByI18nBlock.set(op.xref, rootContext);
+            }
+        }
+    }
+    // Create or assign i18n contexts for ICUs.
+    let currentI18nOp = null;
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            switch (op.kind) {
+                case OpKind.I18nStart:
+                    currentI18nOp = op;
+                    break;
                 case OpKind.I18nEnd:
                     currentI18nOp = null;
                     break;
                 case OpKind.IcuStart:
-                    // If an ICU represents a different message than its containing block, we give it its own
-                    // i18n context.
                     if (currentI18nOp === null) {
-                        throw Error('Unexpected ICU outside of an i18n block.');
+                        throw Error('AssertionError: Unexpected ICU outside of an i18n block.');
                     }
                     if (op.message.id !== currentI18nOp.message.id) {
-                        // There was an enclosing i18n block around this ICU somewhere.
-                        xref = job.allocateXrefId();
-                        unit.create.push(createI18nContextOp(I18nContextKind.Icu, xref, currentI18nOp.xref, op.message, null));
-                        op.context = xref;
+                        // This ICU is a sub-message inside its parent i18n block message. We need to give it
+                        // its own context.
+                        const contextOp = createI18nContextOp(I18nContextKind.Icu, job.allocateXrefId(), currentI18nOp.xref, op.message, null);
+                        unit.create.push(contextOp);
+                        op.context = contextOp.xref;
                     }
                     else {
-                        // The i18n block was generated because of this ICU, OR it was explicit, but the ICU is
-                        // the only localizable content inside of it.
+                        // This ICU is the only translatable content in its parent i18n block. We need to
+                        // convert the parent's context into an ICU context.
                         op.context = currentI18nOp.context;
+                        blockContextByI18nBlock.get(currentI18nOp.xref).contextKind = I18nContextKind.Icu;
                     }
                     break;
             }
         }
-        for (const op of unit.ops()) {
-            switch (op.kind) {
-                case OpKind.Binding:
-                case OpKind.Property:
-                case OpKind.Attribute:
-                case OpKind.ExtractedAttribute:
-                    if (!op.i18nMessage) {
-                        continue;
-                    }
-                    if (!messageToContext.has(op.i18nMessage)) {
-                        // create the context
-                        const i18nContext = job.allocateXrefId();
-                        unit.create.push(createI18nContextOp(I18nContextKind.Attr, i18nContext, null, op.i18nMessage, null));
-                        messageToContext.set(op.i18nMessage, i18nContext);
-                    }
-                    op.i18nContext = messageToContext.get(op.i18nMessage);
-                    break;
-            }
-        }
     }
-    // Assign contexts to child i18n blocks, now that all root i18n blocks have their context
-    // assigned.
+}
+
+/**
+ * Deduplicate text bindings, e.g. <div class="cls1" class="cls2">
+ */
+function deduplicateTextBindings(job) {
+    const seen = new Map();
     for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.I18nStart && op.xref !== op.root) {
-                op.context = rootContexts.get(op.root);
+        for (const op of unit.update.reversed()) {
+            if (op.kind === OpKind.Binding && op.isTextAttribute) {
+                const seenForElement = seen.get(op.target) || new Set();
+                if (seenForElement.has(op.name)) {
+                    if (job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
+                        // For most duplicated attributes, TemplateDefinitionBuilder lists all of the values in
+                        // the consts array. However, for style and class attributes it only keeps the last one.
+                        // We replicate that behavior here since it has actual consequences for apps with
+                        // duplicate class or style attrs.
+                        if (op.name === 'style' || op.name === 'class') {
+                            OpList.remove(op);
+                        }
+                    }
+                    else {
+                        // TODO: Determine the correct behavior. It would probably make sense to merge multiple
+                        // style and class attributes. Alternatively we could just throw an error, as HTML
+                        // doesn't permit duplicate attributes.
+                    }
+                }
+                seenForElement.add(op.name);
+                seen.set(op.target, seenForElement);
             }
         }
     }
@@ -12560,13 +12692,18 @@ const LIST_DELIMITER = '|';
  * used in the final output.
  */
 function extractI18nMessages(job) {
-    // Save the i18n start and i18n context ops for later use.
-    const i18nContexts = new Map();
+    // Create an i18n message for each context.
+    // TODO: Merge the context op with the message op since they're 1:1 anyways.
+    const i18nMessagesByContext = new Map();
     const i18nBlocks = new Map();
+    const i18nContexts = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nContext:
+                    const i18nMessageOp = createI18nMessage(job, op);
+                    unit.create.push(i18nMessageOp);
+                    i18nMessagesByContext.set(op.xref, i18nMessageOp);
                     i18nContexts.set(op.xref, op);
                     break;
                 case OpKind.I18nStart:
@@ -12575,54 +12712,47 @@ function extractI18nMessages(job) {
             }
         }
     }
-    // TODO: Miles and I think that contexts have a 1-to-1 correspondence with extracted messages, so
-    // this phase can probably be simplified.
-    // Extract messages from contexts of i18n attributes.
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind !== OpKind.I18nContext || op.contextKind !== I18nContextKind.Attr) {
-                continue;
-            }
-            const i18nMessageOp = createI18nMessage(job, op);
-            unit.create.push(i18nMessageOp);
-        }
-    }
-    // Extract messages from root i18n blocks.
-    const i18nBlockMessages = new Map();
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.I18nStart && op.xref === op.root) {
-                if (!op.context) {
-                    throw Error('I18n start op should have its context set.');
-                }
-                const i18nMessageOp = createI18nMessage(job, i18nContexts.get(op.context));
-                i18nBlockMessages.set(op.xref, i18nMessageOp);
-                unit.create.push(i18nMessageOp);
-            }
-        }
-    }
-    // Extract messages from ICUs with their own sub-context.
+    // Associate sub-messages for ICUs with their root message. At this point we can also remove the
+    // ICU start/end ops, as they are no longer needed.
+    let currentIcu = null;
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.IcuStart:
-                    if (!op.context) {
-                        throw Error('ICU op should have its context set.');
+                    currentIcu = op;
+                    OpList.remove(op);
+                    // Skip any contexts not associated with an ICU.
+                    const icuContext = i18nContexts.get(op.context);
+                    if (icuContext.contextKind !== I18nContextKind.Icu) {
+                        continue;
                     }
-                    const i18nContext = i18nContexts.get(op.context);
-                    if (i18nContext.contextKind === I18nContextKind.Icu) {
-                        if (i18nContext.i18nBlock === null) {
-                            throw Error('ICU context should have its i18n block set.');
-                        }
-                        const subMessage = createI18nMessage(job, i18nContext, op.messagePlaceholder);
-                        unit.create.push(subMessage);
-                        const rootI18nId = i18nBlocks.get(i18nContext.i18nBlock).root;
-                        const parentMessage = i18nBlockMessages.get(rootI18nId);
-                        parentMessage?.subMessages.push(subMessage.xref);
+                    // Skip ICUs that share a context with their i18n message. These represent root-level
+                    // ICUs, not sub-messages.
+                    const i18nBlock = i18nBlocks.get(icuContext.i18nBlock);
+                    if (i18nBlock.context === icuContext.xref) {
+                        continue;
                     }
-                    OpList.remove(op);
+                    // Find the root message and push this ICUs message as a sub-message.
+                    const rootI18nBlock = i18nBlocks.get(i18nBlock.root);
+                    const rootMessage = i18nMessagesByContext.get(rootI18nBlock.context);
+                    if (rootMessage === undefined) {
+                        throw Error('AssertionError: ICU sub-message should belong to a root message.');
+                    }
+                    const subMessage = i18nMessagesByContext.get(icuContext.xref);
+                    subMessage.messagePlaceholder = op.messagePlaceholder;
+                    rootMessage.subMessages.push(subMessage.xref);
                     break;
                 case OpKind.IcuEnd:
+                    currentIcu = null;
+                    OpList.remove(op);
+                    break;
+                case OpKind.IcuPlaceholder:
+                    // Add ICU placeholders to the message, then remove the ICU placeholder ops.
+                    if (currentIcu === null || currentIcu.context == null) {
+                        throw Error('AssertionError: Unexpected ICU placeholder outside of i18n context');
+                    }
+                    const msg = i18nMessagesByContext.get(currentIcu.context);
+                    msg.postprocessingParams.set(op.name, literal(formatIcuPlaceholder(op)));
                     OpList.remove(op);
                     break;
             }
@@ -12635,14 +12765,19 @@ function extractI18nMessages(job) {
 function createI18nMessage(job, context, messagePlaceholder) {
     let formattedParams = formatParams(context.params);
     const formattedPostprocessingParams = formatParams(context.postprocessingParams);
-    let needsPostprocessing = formattedPostprocessingParams.size > 0;
-    for (const values of context.params.values()) {
-        if (values.length > 1) {
-            needsPostprocessing = true;
-        }
-    }
+    let needsPostprocessing = [...context.params.values()].some(v => v.length > 1);
     return createI18nMessageOp(job.allocateXrefId(), context.xref, context.i18nBlock, context.message, messagePlaceholder ?? null, formattedParams, formattedPostprocessingParams, needsPostprocessing);
 }
+/**
+ * Formats an ICU placeholder into a single string with expression placeholders.
+ */
+function formatIcuPlaceholder(op) {
+    if (op.strings.length !== op.expressionPlaceholders.length + 1) {
+        throw Error(`AsserionError: Invalid ICU placeholder with ${op.strings.length} strings and ${op.expressionPlaceholders.length} expressions`);
+    }
+    const values = op.expressionPlaceholders.map(formatValue);
+    return op.strings.flatMap((str, i) => [str, values[i] || '']).join('');
+}
 /**
  * Formats a map of `I18nParamValue[]` values into a map of `Expression` values.
  */
@@ -12981,7 +13116,7 @@ const BANG_IMPORTANT = '!important';
  */
 function parseHostStyleProperties(job) {
     for (const op of job.root.update) {
-        if (op.kind !== OpKind.Binding) {
+        if (!(op.kind === OpKind.Binding && op.bindingKind === BindingKind.Property)) {
             continue;
         }
         if (op.name.endsWith(BANG_IMPORTANT)) {
@@ -20139,7 +20274,7 @@ function collectMessage(job, fileBasedI18nSuffix, messages, messageOp) {
     let transformFn = undefined;
     // If nescessary, add a post-processing step and resolve any placeholder params that are
     // set in post-processing.
-    if (messageOp.needsPostprocessing) {
+    if (messageOp.needsPostprocessing || messageOp.postprocessingParams.size > 0) {
         // Sort the post-processing params for consistency with TemaplateDefinitionBuilder output.
         const postprocessingParams = Object.fromEntries([...messageOp.postprocessingParams.entries()].sort());
         const formattedPostprocessingParams = formatI18nPlaceholderNamesInMap(postprocessingParams, /* useCamelCase */ false);
@@ -20169,7 +20304,6 @@ function addSubMessageParams(messageOp, subMessagePlaceholders) {
         else {
             messageOp.params.set(placeholder, literal(`${ESCAPE}${I18N_ICU_MAPPING_PREFIX}${placeholder}${ESCAPE}`));
             messageOp.postprocessingParams.set(placeholder, literalArr(subMessages));
-            messageOp.needsPostprocessing = true;
         }
     }
 }
@@ -20255,6 +20389,7 @@ function convertI18nText(job) {
         let currentIcu = null;
         const textNodeI18nBlocks = new Map();
         const textNodeIcus = new Map();
+        const icuPlaceholderByText = new Map();
         for (const op of unit.create) {
             switch (op.kind) {
                 case OpKind.I18nStart:
@@ -20279,7 +20414,19 @@ function convertI18nText(job) {
                     if (currentI18n !== null) {
                         textNodeI18nBlocks.set(op.xref, currentI18n);
                         textNodeIcus.set(op.xref, currentIcu);
-                        OpList.remove(op);
+                        if (op.icuPlaceholder !== null) {
+                            // Create an op to represent the ICU placeholder. Initially set its static text to the
+                            // value of the text op, though this may be overwritten later if this text op is a
+                            // placeholder for an interpolation.
+                            const icuPlaceholderOp = createIcuPlaceholderOp(job.allocateXrefId(), op.icuPlaceholder, [op.initialValue]);
+                            OpList.replace(op, icuPlaceholderOp);
+                            icuPlaceholderByText.set(op.xref, icuPlaceholderOp);
+                        }
+                        else {
+                            // Otherwise just remove the text op, since its value is already accounted for in the
+                            // translated message.
+                            OpList.remove(op);
+                        }
                     }
                     break;
             }
@@ -20294,6 +20441,7 @@ function convertI18nText(job) {
                     }
                     const i18nOp = textNodeI18nBlocks.get(op.target);
                     const icuOp = textNodeIcus.get(op.target);
+                    const icuPlaceholder = icuPlaceholderByText.get(op.target);
                     const contextId = icuOp ? icuOp.context : i18nOp.context;
                     const resolutionTime = icuOp ? I18nParamResolutionTime.Postproccessing :
                         I18nParamResolutionTime.Creation;
@@ -20302,9 +20450,14 @@ function convertI18nText(job) {
                         const expr = op.interpolation.expressions[i];
                         // For now, this i18nExpression depends on the slot context of the enclosing i18n block.
                         // Later, we will modify this, and advance to a different point.
-                        ops.push(createI18nExpressionOp(contextId, i18nOp.xref, i18nOp.xref, i18nOp.handle, expr, op.interpolation.i18nPlaceholders[i], resolutionTime, I18nExpressionFor.I18nText, '', expr.sourceSpan ?? op.sourceSpan));
+                        ops.push(createI18nExpressionOp(contextId, i18nOp.xref, i18nOp.xref, i18nOp.handle, expr, icuPlaceholder?.xref ?? null, op.interpolation.i18nPlaceholders[i] ?? null, resolutionTime, I18nExpressionFor.I18nText, '', expr.sourceSpan ?? op.sourceSpan));
                     }
                     OpList.replaceWithMany(op, ops);
+                    // If this interpolation is part of an ICU placeholder, add the strings and expressions to
+                    // the placeholder.
+                    if (icuPlaceholder !== undefined) {
+                        icuPlaceholder.strings = op.interpolation.strings;
+                    }
                     break;
             }
         }
@@ -20487,7 +20640,7 @@ function addNamesToView(unit, baseName, state, compatibility) {
                 op.handlerFnName = sanitizeIdentifier(op.handlerFnName);
                 break;
             case OpKind.Variable:
-                varNames.set(op.xref, getVariableName(op.variable, state));
+                varNames.set(op.xref, getVariableName(unit, op.variable, state));
                 break;
             case OpKind.RepeaterCreate:
                 if (!(unit instanceof ViewCompilationUnit)) {
@@ -20542,15 +20695,23 @@ function addNamesToView(unit, baseName, state, compatibility) {
         });
     }
 }
-function getVariableName(variable, state) {
+function getVariableName(unit, variable, state) {
     if (variable.name === null) {
         switch (variable.kind) {
             case SemanticVariableKind.Context:
                 variable.name = `ctx_r${state.index++}`;
                 break;
             case SemanticVariableKind.Identifier:
-                // TODO: Prefix increment and `_r` for compatiblity only.
-                variable.name = `${variable.identifier}_r${++state.index}`;
+                if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
+                    // TODO: Prefix increment and `_r` are for compatiblity with the old naming scheme.
+                    // This has the potential to cause collisions when `ctx` is the identifier, so we need a
+                    // special check for that as well.
+                    const compatPrefix = variable.identifier === 'ctx' ? 'i' : '';
+                    variable.name = `${variable.identifier}_${compatPrefix}r${++state.index}`;
+                }
+                else {
+                    variable.name = `${variable.identifier}_i${state.index++}`;
+                }
                 break;
             default:
                 // TODO: Prefix increment for compatibility only.
@@ -20747,17 +20908,27 @@ const CREATE_ORDERING = [
  * op kinds.
  */
 const UPDATE_ORDERING = [
-    { test: kindWithInterpolationTest(OpKind.HostProperty, true) },
-    { test: kindWithInterpolationTest(OpKind.HostProperty, false) },
     { test: kindTest(OpKind.StyleMap), transform: keepLast },
     { test: kindTest(OpKind.ClassMap), transform: keepLast },
     { test: kindTest(OpKind.StyleProp) },
     { test: kindTest(OpKind.ClassProp) },
-    { test: kindWithInterpolationTest(OpKind.Property, true) },
     { test: kindWithInterpolationTest(OpKind.Attribute, true) },
+    { test: kindWithInterpolationTest(OpKind.Property, true) },
     { test: kindWithInterpolationTest(OpKind.Property, false) },
     { test: kindWithInterpolationTest(OpKind.Attribute, false) },
 ];
+/**
+ * Host bindings have their own update ordering.
+ */
+const UPDATE_HOST_ORDERING = [
+    { test: kindWithInterpolationTest(OpKind.HostProperty, true) },
+    { test: kindWithInterpolationTest(OpKind.HostProperty, false) },
+    { test: kindTest(OpKind.Attribute) },
+    { test: kindTest(OpKind.StyleMap), transform: keepLast },
+    { test: kindTest(OpKind.ClassMap), transform: keepLast },
+    { test: kindTest(OpKind.StyleProp) },
+    { test: kindTest(OpKind.ClassProp) },
+];
 /**
  * The set of all op kinds we handle in the reordering phase.
  */
@@ -20778,7 +20949,8 @@ function orderOps(job) {
         // Create mode:
         orderWithin(unit.create, CREATE_ORDERING);
         // Update mode:
-        orderWithin(unit.update, UPDATE_ORDERING);
+        const ordering = unit.job.kind === CompilationJobKind.Host ? UPDATE_HOST_ORDERING : UPDATE_ORDERING;
+        orderWithin(unit.update, ordering);
     }
 }
 /**
@@ -20833,10 +21005,28 @@ function keepLast(ops) {
  * class property.
  */
 function parseExtractedStyles(job) {
+    const elements = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (isElementOrContainerOp(op)) {
+                elements.set(op.xref, op);
+            }
+        }
+    }
     for (const unit of job.units) {
         for (const op of unit.create) {
             if (op.kind === OpKind.ExtractedAttribute && op.bindingKind === BindingKind.Attribute &&
                 isStringLiteral(op.expression)) {
+                const target = elements.get(op.target);
+                if (target !== undefined && target.kind === OpKind.Template &&
+                    target.templateKind === TemplateKind.Structural) {
+                    // TemplateDefinitionBuilder will not apply class and style bindings to structural
+                    // directives; instead, it will leave them as attributes.
+                    // (It's not clear what that would mean, anyway -- classes and styles on a structural
+                    // element should probably be a parse error.)
+                    // TODO: We may be able to remove this once Template Pipeline is the default.
+                    continue;
+                }
                 if (op.name === 'style') {
                     const parsedStyles = parse(op.expression.value);
                     for (let i = 0; i < parsedStyles.length - 1; i += 2) {
@@ -20871,15 +21061,6 @@ function removeContentSelectors(job) {
                         OpList.remove(op);
                     }
                     break;
-                case OpKind.Projection:
-                    // op.attributes is an array of [attr1-name, attr1-value, attr2-name, attr2-value, ...],
-                    // find the "select" attribute and remove its name and corresponding value.
-                    for (let i = op.attributes.length - 2; i >= 0; i -= 2) {
-                        if (isSelectAttribute(op.attributes[i])) {
-                            op.attributes.splice(i, 2);
-                        }
-                    }
-                    break;
             }
         }
     }
@@ -21051,8 +21232,10 @@ function wrapTemplateWithI18n(unit, parentI18n) {
     // Only add i18n ops if they have not already been propagated to this template.
     if (unit.create.head.next?.kind !== OpKind.I18nStart) {
         const id = unit.job.allocateXrefId();
-        OpList.insertAfter(createI18nStartOp(id, parentI18n.message, parentI18n.root), unit.create.head);
-        OpList.insertBefore(createI18nEndOp(id), unit.create.tail);
+        OpList.insertAfter(
+        // Nested ng-template i18n start/end ops should not recieve source spans.
+        createI18nStartOp(id, parentI18n.message, parentI18n.root, null), unit.create.head);
+        OpList.insertBefore(createI18nEndOp(id, null), unit.create.tail);
     }
 }
 
@@ -21313,22 +21496,22 @@ function projectionDef(def) {
 }
 function projection(slot, projectionSlotIndex, attributes, sourceSpan) {
     const args = [literal(slot)];
-    if (projectionSlotIndex !== 0 || attributes.length > 0) {
+    if (projectionSlotIndex !== 0 || attributes !== null) {
         args.push(literal(projectionSlotIndex));
-        if (attributes.length > 0) {
-            args.push(literalArr(attributes.map(attr => literal(attr))));
+        if (attributes !== null) {
+            args.push(attributes);
         }
     }
     return call(Identifiers.projection, args, sourceSpan);
 }
-function i18nStart(slot, constIndex, subTemplateIndex) {
+function i18nStart(slot, constIndex, subTemplateIndex, sourceSpan) {
     const args = [literal(slot), literal(constIndex)];
     if (subTemplateIndex !== null) {
         args.push(literal(subTemplateIndex));
     }
-    return call(Identifiers.i18nStart, args, null);
+    return call(Identifiers.i18nStart, args, sourceSpan);
 }
-function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByFn, trackByUsesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, sourceSpan) {
+function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByFn, trackByUsesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, emptyTag, emptyConstIndex, sourceSpan) {
     const args = [
         literal(slot),
         variable(viewFnName),
@@ -21342,6 +21525,12 @@ function repeaterCreate(slot, viewFnName, decls, vars, tag, constIndex, trackByF
         args.push(literal(trackByUsesComponentInstance));
         if (emptyViewFnName !== null) {
             args.push(variable(emptyViewFnName), literal(emptyDecls), literal(emptyVars));
+            if (emptyTag !== null || emptyConstIndex !== null) {
+                args.push(literal(emptyTag));
+            }
+            if (emptyConstIndex !== null) {
+                args.push(literal(emptyConstIndex));
+            }
         }
     }
     return call(Identifiers.repeaterCreate, args, sourceSpan);
@@ -21352,15 +21541,15 @@ function repeater(collection, sourceSpan) {
 function deferWhen(prefetch, expr, sourceSpan) {
     return call(prefetch ? Identifiers.deferPrefetchWhen : Identifiers.deferWhen, [expr], sourceSpan);
 }
-function i18n(slot, constIndex, subTemplateIndex) {
+function i18n(slot, constIndex, subTemplateIndex, sourceSpan) {
     const args = [literal(slot), literal(constIndex)];
     if (subTemplateIndex) {
         args.push(literal(subTemplateIndex));
     }
-    return call(Identifiers.i18n, args, null);
+    return call(Identifiers.i18n, args, sourceSpan);
 }
-function i18nEnd() {
-    return call(Identifiers.i18nEnd, [], null);
+function i18nEnd(endSourceSpan) {
+    return call(Identifiers.i18nEnd, [], endSourceSpan);
 }
 function i18nAttributes(slot, i18nAttributesConfig) {
     const args = [literal(slot), literal(i18nAttributesConfig)];
@@ -21720,6 +21909,31 @@ function reify(job) {
         reifyUpdateOperations(unit, unit.update);
     }
 }
+/**
+ * This function can be used a sanity check -- it walks every expression in the const pool, and
+ * every expression reachable from an op, and makes sure that there are no IR expressions
+ * left. This is nice to use for debugging mysterious failures where an IR expression cannot be
+ * output from the output AST code.
+ */
+function ensureNoIrForDebug(job) {
+    for (const stmt of job.pool.statements) {
+        transformExpressionsInStatement(stmt, expr => {
+            if (isIrExpression(expr)) {
+                throw new Error(`AssertionError: IR expression found during reify: ${ExpressionKind[expr.kind]}`);
+            }
+            return expr;
+        }, VisitorContextFlag.None);
+    }
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            visitExpressionsInOp(op, expr => {
+                if (isIrExpression(expr)) {
+                    throw new Error(`AssertionError: IR expression found during reify: ${ExpressionKind[expr.kind]}`);
+                }
+            });
+        }
+    }
+}
 function reifyCreateOperations(unit, ops) {
     for (const op of ops) {
         transformExpressionsInOp(op, reifyIrExpression, VisitorContextFlag.None);
@@ -21728,31 +21942,31 @@ function reifyCreateOperations(unit, ops) {
                 OpList.replace(op, text(op.handle.slot, op.initialValue, op.sourceSpan));
                 break;
             case OpKind.ElementStart:
-                OpList.replace(op, elementStart(op.handle.slot, op.tag, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, elementStart(op.handle.slot, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.Element:
-                OpList.replace(op, element(op.handle.slot, op.tag, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, element(op.handle.slot, op.tag, op.attributes, op.localRefs, op.wholeSourceSpan));
                 break;
             case OpKind.ElementEnd:
                 OpList.replace(op, elementEnd(op.sourceSpan));
                 break;
             case OpKind.ContainerStart:
-                OpList.replace(op, elementContainerStart(op.handle.slot, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, elementContainerStart(op.handle.slot, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.Container:
-                OpList.replace(op, elementContainer(op.handle.slot, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, elementContainer(op.handle.slot, op.attributes, op.localRefs, op.wholeSourceSpan));
                 break;
             case OpKind.ContainerEnd:
                 OpList.replace(op, elementContainerEnd());
                 break;
             case OpKind.I18nStart:
-                OpList.replace(op, i18nStart(op.handle.slot, op.messageIndex, op.subTemplateIndex));
+                OpList.replace(op, i18nStart(op.handle.slot, op.messageIndex, op.subTemplateIndex, op.sourceSpan));
                 break;
             case OpKind.I18nEnd:
-                OpList.replace(op, i18nEnd());
+                OpList.replace(op, i18nEnd(op.sourceSpan));
                 break;
             case OpKind.I18n:
-                OpList.replace(op, i18n(op.handle.slot, op.messageIndex, op.subTemplateIndex));
+                OpList.replace(op, i18n(op.handle.slot, op.messageIndex, op.subTemplateIndex, op.sourceSpan));
                 break;
             case OpKind.I18nAttributes:
                 if (op.i18nAttributesConfig === null) {
@@ -21768,7 +21982,7 @@ function reifyCreateOperations(unit, ops) {
                     throw new Error(`AssertionError: local refs array should have been extracted into a constant`);
                 }
                 const childView = unit.job.views.get(op.xref);
-                OpList.replace(op, template(op.handle.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes, op.localRefs, op.sourceSpan));
+                OpList.replace(op, template(op.handle.slot, variable(childView.fnName), childView.decls, childView.vars, op.tag, op.attributes, op.localRefs, op.startSourceSpan));
                 break;
             case OpKind.DisableBindings:
                 OpList.replace(op, disableBindings());
@@ -21783,7 +21997,7 @@ function reifyCreateOperations(unit, ops) {
                 const listenerFn = reifyListenerHandler(unit, op.handlerFnName, op.handlerOps, op.consumesDollarEvent);
                 const eventTargetResolver = op.eventTarget ? GLOBAL_TARGET_RESOLVERS$1.get(op.eventTarget) : null;
                 if (eventTargetResolver === undefined) {
-                    throw new Error(`AssertionError: unknown event target ${op.eventTarget}`);
+                    throw new Error(`Unexpected global target '${op.eventTarget}' defined for '${op.name}' event. Supported list of global targets: window,document,body.`);
                 }
                 OpList.replace(op, listener(op.name, listenerFn, eventTargetResolver, op.hostListener && op.isAnimationListener, op.sourceSpan));
                 break;
@@ -21870,7 +22084,7 @@ function reifyCreateOperations(unit, ops) {
                     emptyDecls = emptyView.decls;
                     emptyVars = emptyView.vars;
                 }
-                OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.sourceSpan));
+                OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.emptyTag, op.emptyAttributes, op.wholeSourceSpan));
                 break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
@@ -22500,6 +22714,7 @@ function resolveI18nExpressionPlaceholders(job) {
     // Record all of the i18n context ops, and the sub-template index for each i18n op.
     const subTemplateIndicies = new Map();
     const i18nContexts = new Map();
+    const icuPlaceholders = new Map();
     for (const unit of job.units) {
         for (const op of unit.create) {
             switch (op.kind) {
@@ -22509,6 +22724,9 @@ function resolveI18nExpressionPlaceholders(job) {
                 case OpKind.I18nContext:
                     i18nContexts.set(op.xref, op);
                     break;
+                case OpKind.IcuPlaceholder:
+                    icuPlaceholders.set(op.xref, op);
+                    break;
             }
         }
     }
@@ -22522,76 +22740,32 @@ function resolveI18nExpressionPlaceholders(job) {
     for (const unit of job.units) {
         for (const op of unit.update) {
             if (op.kind === OpKind.I18nExpression) {
-                const i18nContext = i18nContexts.get(op.context);
                 const index = expressionIndices.get(referenceIndex(op)) || 0;
                 const subTemplateIndex = subTemplateIndicies.get(op.i18nOwner) ?? null;
-                // Add the expression index in the appropriate params map.
-                const params = op.resolutionTime === I18nParamResolutionTime.Creation ?
-                    i18nContext.params :
-                    i18nContext.postprocessingParams;
-                const values = params.get(op.i18nPlaceholder) || [];
-                values.push({
+                const value = {
                     value: index,
                     subTemplateIndex: subTemplateIndex,
                     flags: I18nParamValueFlags.ExpressionIndex
-                });
-                params.set(op.i18nPlaceholder, values);
+                };
+                updatePlaceholder(op, value, i18nContexts, icuPlaceholders);
                 expressionIndices.set(referenceIndex(op), index + 1);
             }
         }
     }
 }
-
-/**
- * Resolves placeholders for element tags inside of an ICU.
- */
-function resolveI18nIcuPlaceholders(job) {
-    for (const unit of job.units) {
-        for (const op of unit.create) {
-            if (op.kind === OpKind.I18nContext && op.contextKind === I18nContextKind.Icu) {
-                for (const node of op.message.nodes) {
-                    node.visit(new ResolveIcuPlaceholdersVisitor(op.postprocessingParams));
-                }
-            }
-        }
-    }
-}
-/**
- * Visitor for i18n AST that resolves ICU params into the given map.
- */
-class ResolveIcuPlaceholdersVisitor extends RecurseVisitor {
-    constructor(params) {
-        super();
-        this.params = params;
+function updatePlaceholder(op, value, i18nContexts, icuPlaceholders) {
+    if (op.i18nPlaceholder !== null) {
+        const i18nContext = i18nContexts.get(op.context);
+        const params = op.resolutionTime === I18nParamResolutionTime.Creation ?
+            i18nContext.params :
+            i18nContext.postprocessingParams;
+        const values = params.get(op.i18nPlaceholder) || [];
+        values.push(value);
+        params.set(op.i18nPlaceholder, values);
     }
-    visitContainerPlaceholder(placeholder) {
-        // Add the start and end source span for container placeholders. These need to be recorded for
-        // elements inside ICUs. The slots for the nodes were recorded separately under the i18n
-        // block's context as part of the `resolveI18nElementPlaceholders` phase.
-        if (placeholder.startName && placeholder.startSourceSpan &&
-            !this.params.has(placeholder.startName)) {
-            this.params.set(placeholder.startName, [{
-                    value: placeholder.startSourceSpan?.toString(),
-                    subTemplateIndex: null,
-                    flags: I18nParamValueFlags.None
-                }]);
-        }
-        if (placeholder.closeName && placeholder.endSourceSpan &&
-            !this.params.has(placeholder.closeName)) {
-            this.params.set(placeholder.closeName, [{
-                    value: placeholder.endSourceSpan?.toString(),
-                    subTemplateIndex: null,
-                    flags: I18nParamValueFlags.None
-                }]);
-        }
-    }
-    visitTagPlaceholder(placeholder) {
-        super.visitTagPlaceholder(placeholder);
-        this.visitContainerPlaceholder(placeholder);
-    }
-    visitBlockPlaceholder(placeholder) {
-        super.visitBlockPlaceholder(placeholder);
-        this.visitContainerPlaceholder(placeholder);
+    if (op.icuPlaceholder !== null) {
+        const icuPlaceholderOp = icuPlaceholders.get(op.icuPlaceholder);
+        icuPlaceholderOp?.expressionPlaceholders.push(value);
     }
 }
 
@@ -23043,6 +23217,9 @@ function generateTrackFns(job) {
             // Find all component context reads.
             let usesComponentContext = false;
             op.track = transformExpressionsInExpression(op.track, expr => {
+                if (expr instanceof PipeBindingExpr || expr instanceof PipeBindingVariadicExpr) {
+                    throw new Error(`Illegal State: Pipes are not allowed in this context`);
+                }
                 if (expr instanceof TrackContextExpr) {
                     usesComponentContext = true;
                     return variable('this');
@@ -23266,7 +23443,14 @@ function varsUsedByOp(op) {
             return op.interpolation.expressions.length;
         case OpKind.I18nExpression:
         case OpKind.Conditional:
+        case OpKind.DeferWhen:
             return 1;
+        case OpKind.RepeaterCreate:
+            // Repeaters may require an extra variable binding slot, if they have an empty view, for the
+            // empty block tracking.
+            // TODO: It's a bit odd to have a create mode instruction consume variable slots. Maybe we can
+            // find a way to use the Repeater update op instead.
+            return op.emptyView ? 1 : 0;
         default:
             throw new Error(`Unhandled op: ${OpKind[op.kind]}`);
     }
@@ -23722,12 +23906,13 @@ function wrapI18nIcus(job) {
                 case OpKind.IcuStart:
                     if (currentI18nOp === null) {
                         addedI18nId = job.allocateXrefId();
-                        OpList.insertBefore(createI18nStartOp(addedI18nId, op.message), op);
+                        // ICU i18n start/end ops should not recieve source spans.
+                        OpList.insertBefore(createI18nStartOp(addedI18nId, op.message, undefined, null), op);
                     }
                     break;
                 case OpKind.IcuEnd:
                     if (addedI18nId !== null) {
-                        OpList.insertAfter(createI18nEndOp(addedI18nId), op);
+                        OpList.insertAfter(createI18nEndOp(addedI18nId, null), op);
                         addedI18nId = null;
                     }
                     break;
@@ -23750,6 +23935,7 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: emitNamespaceChanges },
     { kind: CompilationJobKind.Tmpl, fn: propagateI18nBlocks },
     { kind: CompilationJobKind.Tmpl, fn: wrapI18nIcus },
+    { kind: CompilationJobKind.Both, fn: deduplicateTextBindings },
     { kind: CompilationJobKind.Both, fn: specializeStyleBindings },
     { kind: CompilationJobKind.Both, fn: specializeBindings },
     { kind: CompilationJobKind.Both, fn: extractAttributes },
@@ -23788,7 +23974,6 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: createDeferDepsFns },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nElementPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nExpressionPlaceholders },
-    { kind: CompilationJobKind.Tmpl, fn: resolveI18nIcuPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: extractI18nMessages },
     { kind: CompilationJobKind.Tmpl, fn: generateTrackFns },
     { kind: CompilationJobKind.Tmpl, fn: collectI18nConsts },
@@ -23948,7 +24133,7 @@ function ingestHostBinding(input, bindingParser, constantPool) {
         const securityContexts = bindingParser
             .calcPossibleSecurityContexts(input.componentSelector, property.name, bindingKind === BindingKind.Attribute)
             .filter(context => context !== SecurityContext.NONE);
-        ingestHostProperty(job, property, bindingKind, false, securityContexts);
+        ingestHostProperty(job, property, bindingKind, securityContexts);
     }
     for (const [name, expr] of Object.entries(input.attributes) ?? []) {
         const securityContexts = bindingParser.calcPossibleSecurityContexts(input.componentSelector, name, true)
@@ -23962,7 +24147,7 @@ function ingestHostBinding(input, bindingParser, constantPool) {
 }
 // TODO: We should refactor the parser to use the same types and structures for host bindings as
 // with ordinary components. This would allow us to share a lot more ingestion code.
-function ingestHostProperty(job, property, bindingKind, isTextAttribute, securityContexts) {
+function ingestHostProperty(job, property, bindingKind, securityContexts) {
     let expression;
     const ast = property.expression.ast;
     if (ast instanceof Interpolation$1) {
@@ -23971,20 +24156,21 @@ function ingestHostProperty(job, property, bindingKind, isTextAttribute, securit
     else {
         expression = convertAst(ast, job, property.sourceSpan);
     }
-    job.root.update.push(createBindingOp(job.root.xref, bindingKind, property.name, expression, null, securityContexts, isTextAttribute, false, null, /* TODO: How do Host bindings handle i18n attrs? */ null, property.sourceSpan));
+    job.root.update.push(createBindingOp(job.root.xref, bindingKind, property.name, expression, null, securityContexts, false, false, null, /* TODO: How do Host bindings handle i18n attrs? */ null, property.sourceSpan));
 }
 function ingestHostAttribute(job, name, value, securityContexts) {
-    const attrBinding = createBindingOp(job.root.xref, BindingKind.Attribute, name, value, null, securityContexts, true, false, null, 
+    const attrBinding = createBindingOp(job.root.xref, BindingKind.Attribute, name, value, null, securityContexts, 
+    /* Host attributes should always be extracted to const hostAttrs, even if they are not
+     *strictly* text literals */
+    true, false, null, 
     /* TODO */ null, 
-    /* TODO: host attribute source spans */ null);
+    /** TODO: May be null? */ value.sourceSpan);
     job.root.update.push(attrBinding);
 }
 function ingestHostEvent(job, event) {
     const [phase, target] = event.type === 0 /* e.ParsedEventType.Regular */ ? [null, event.targetOrPhase] :
         [event.targetOrPhase, null];
-    const eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, [], phase, target, true, event.sourceSpan);
-    // TODO: Can this be a chain?
-    eventBinding.handlerOps.push(createStatementOp(new ReturnStatement(convertAst(event.handler.ast, job, event.sourceSpan), event.handlerSpan)));
+    const eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, makeListenerHandlerOps(job.root, event.handler, event.handlerSpan), phase, target, true, event.sourceSpan);
     job.root.create.push(eventBinding);
 }
 /**
@@ -24002,10 +24188,10 @@ function ingestNodes(unit, template) {
             ingestContent(unit, node);
         }
         else if (node instanceof Text$3) {
-            ingestText(unit, node);
+            ingestText(unit, node, null);
         }
         else if (node instanceof BoundText) {
-            ingestBoundText(unit, node);
+            ingestBoundText(unit, node, null);
         }
         else if (node instanceof IfBlock) {
             ingestIfBlock(unit, node);
@@ -24037,7 +24223,7 @@ function ingestElement(unit, element) {
     }
     const id = unit.job.allocateXrefId();
     const [namespaceKey, elementName] = splitNsName(element.name);
-    const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element.i18n instanceof TagPlaceholder ? element.i18n : undefined, element.startSourceSpan);
+    const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element.i18n instanceof TagPlaceholder ? element.i18n : undefined, element.startSourceSpan, element.sourceSpan);
     unit.create.push(startOp);
     ingestElementBindings(unit, startOp, element);
     ingestReferences(startOp, element);
@@ -24045,7 +24231,7 @@ function ingestElement(unit, element) {
     let i18nBlockId = null;
     if (element.i18n instanceof Message) {
         i18nBlockId = unit.job.allocateXrefId();
-        unit.create.push(createI18nStartOp(i18nBlockId, element.i18n));
+        unit.create.push(createI18nStartOp(i18nBlockId, element.i18n, undefined, element.startSourceSpan));
     }
     ingestNodes(unit, element.children);
     // The source span for the end op is typically the element closing tag. However, if no closing tag
@@ -24057,7 +24243,7 @@ function ingestElement(unit, element) {
     unit.create.push(endOp);
     // If there is an i18n message associated with this element, insert i18n start and end ops.
     if (i18nBlockId !== null) {
-        OpList.insertBefore(createI18nEndOp(i18nBlockId), endOp);
+        OpList.insertBefore(createI18nEndOp(i18nBlockId, element.endSourceSpan ?? element.startSourceSpan), endOp);
     }
 }
 /**
@@ -24080,7 +24266,7 @@ function ingestTemplate(unit, tmpl) {
         '' :
         prefixWithNamespace(tagNameWithoutNamespace, namespace);
     const templateKind = isPlainTemplate(tmpl) ? TemplateKind.NgTemplate : TemplateKind.Structural;
-    const templateOp = createTemplateOp(childView.xref, templateKind, tagNameWithoutNamespace, functionNameSuffix, namespace, i18nPlaceholder, tmpl.startSourceSpan);
+    const templateOp = createTemplateOp(childView.xref, templateKind, tagNameWithoutNamespace, functionNameSuffix, namespace, i18nPlaceholder, tmpl.startSourceSpan, tmpl.sourceSpan);
     unit.create.push(templateOp);
     ingestTemplateBindings(unit, templateOp, tmpl, templateKind);
     ingestReferences(templateOp, tmpl);
@@ -24093,8 +24279,8 @@ function ingestTemplate(unit, tmpl) {
     // element/template the directive is placed on.
     if (templateKind === TemplateKind.NgTemplate && tmpl.i18n instanceof Message) {
         const id = unit.job.allocateXrefId();
-        OpList.insertAfter(createI18nStartOp(id, tmpl.i18n), childView.create.head);
-        OpList.insertBefore(createI18nEndOp(id), childView.create.tail);
+        OpList.insertAfter(createI18nStartOp(id, tmpl.i18n, undefined, tmpl.startSourceSpan), childView.create.head);
+        OpList.insertBefore(createI18nEndOp(id, tmpl.endSourceSpan ?? tmpl.startSourceSpan), childView.create.tail);
     }
 }
 /**
@@ -24104,8 +24290,7 @@ function ingestContent(unit, content) {
     if (content.i18n !== undefined && !(content.i18n instanceof TagPlaceholder)) {
         throw Error(`Unhandled i18n metadata type for element: ${content.i18n.constructor.name}`);
     }
-    const attrs = content.attributes.flatMap(a => [a.name, a.value]);
-    const op = createProjectionOp(unit.job.allocateXrefId(), content.selector, content.i18n, attrs, content.sourceSpan);
+    const op = createProjectionOp(unit.job.allocateXrefId(), content.selector, content.i18n, content.sourceSpan);
     for (const attr of content.attributes) {
         const securityContext = domSchema.securityContext(content.name, attr.name, true);
         unit.update.push(createBindingOp(op.xref, BindingKind.Attribute, attr.name, literal(attr.value), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
@@ -24115,13 +24300,13 @@ function ingestContent(unit, content) {
 /**
  * Ingest a literal text node from the AST into the given `ViewCompilation`.
  */
-function ingestText(unit, text) {
-    unit.create.push(createTextOp(unit.job.allocateXrefId(), text.value, text.sourceSpan));
+function ingestText(unit, text, icuPlaceholder) {
+    unit.create.push(createTextOp(unit.job.allocateXrefId(), text.value, icuPlaceholder, text.sourceSpan));
 }
 /**
  * Ingest an interpolated text node from the AST into the given `ViewCompilation`.
  */
-function ingestBoundText(unit, text, i18nPlaceholders) {
+function ingestBoundText(unit, text, icuPlaceholder) {
     let value = text.value;
     if (value instanceof ASTWithSource) {
         value = value.ast;
@@ -24132,19 +24317,16 @@ function ingestBoundText(unit, text, i18nPlaceholders) {
     if (text.i18n !== undefined && !(text.i18n instanceof Container)) {
         throw Error(`Unhandled i18n metadata type for text interpolation: ${text.i18n?.constructor.name}`);
     }
-    if (i18nPlaceholders === undefined) {
-        // TODO: We probably can just use the placeholders field, instead of walking the AST.
-        i18nPlaceholders = text.i18n instanceof Container ?
-            text.i18n.children
-                .filter((node) => node instanceof Placeholder)
-                .map(placeholder => placeholder.name) :
-            [];
-    }
+    const i18nPlaceholders = text.i18n instanceof Container ?
+        text.i18n.children
+            .filter((node) => node instanceof Placeholder)
+            .map(placeholder => placeholder.name) :
+        [];
     if (i18nPlaceholders.length > 0 && i18nPlaceholders.length !== value.expressions.length) {
         throw Error(`Unexpected number of i18n placeholders (${value.expressions.length}) for BoundText with ${value.expressions.length} expressions`);
     }
     const textXref = unit.job.allocateXrefId();
-    unit.create.push(createTextOp(textXref, '', text.sourceSpan));
+    unit.create.push(createTextOp(textXref, '', icuPlaceholder, text.sourceSpan));
     // TemplateDefinitionBuilder does not generate source maps for sub-expressions inside an
     // interpolation. We copy that behavior in compatibility mode.
     // TODO: is it actually correct to generate these extra maps in modern mode?
@@ -24177,7 +24359,7 @@ function ingestIfBlock(unit, ifBlock) {
             }
             ifCaseI18nMeta = ifCase.i18n;
         }
-        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, tagName, 'Conditional', Namespace.HTML, ifCaseI18nMeta, ifCase.sourceSpan);
+        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, tagName, 'Conditional', Namespace.HTML, ifCaseI18nMeta, ifCase.startSourceSpan, ifCase.sourceSpan);
         unit.create.push(templateOp);
         if (firstXref === null) {
             firstXref = cView.xref;
@@ -24207,7 +24389,7 @@ function ingestSwitchBlock(unit, switchBlock) {
             }
             switchCaseI18nMeta = switchCase.i18n;
         }
-        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, null, 'Case', Namespace.HTML, switchCaseI18nMeta, switchCase.sourceSpan);
+        const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, null, 'Case', Namespace.HTML, switchCaseI18nMeta, switchCase.startSourceSpan, switchCase.sourceSpan);
         unit.create.push(templateOp);
         if (firstXref === null) {
             firstXref = cView.xref;
@@ -24232,7 +24414,7 @@ function ingestDeferView(unit, suffix, i18nMeta, children, sourceSpan) {
     }
     const secondaryView = unit.job.allocateView(unit.xref);
     ingestNodes(secondaryView, children);
-    const templateOp = createTemplateOp(secondaryView.xref, TemplateKind.Block, null, `Defer${suffix}`, Namespace.HTML, i18nMeta, sourceSpan);
+    const templateOp = createTemplateOp(secondaryView.xref, TemplateKind.Block, null, `Defer${suffix}`, Namespace.HTML, i18nMeta, sourceSpan, sourceSpan);
     unit.create.push(templateOp);
     return templateOp;
 }
@@ -24310,6 +24492,11 @@ function ingestDeferBlock(unit, deferBlock) {
             deferOnOps.push(deferOnOp);
         }
         if (triggers.when !== undefined) {
+            if (triggers.when.value instanceof Interpolation$1) {
+                // TemplateDefinitionBuilder supports this case, but it's very strange to me. What would it
+                // even mean?
+                throw new Error(`Unexpected interpolation in defer block when trigger`);
+            }
             const deferOnOp = createDeferWhenOp(deferXref, convertAst(triggers.when.value, unit.job, triggers.when.sourceSpan), prefetch, triggers.when.sourceSpan);
             deferWhenOps.push(deferOnOp);
         }
@@ -24329,10 +24516,10 @@ function ingestIcu(unit, icu) {
         unit.create.push(createIcuStartOp(xref, icu.i18n, icuFromI18nMessage(icu.i18n).name, null));
         for (const [placeholder, text] of Object.entries({ ...icu.vars, ...icu.placeholders })) {
             if (text instanceof BoundText) {
-                ingestBoundText(unit, text, [placeholder]);
+                ingestBoundText(unit, text, placeholder);
             }
             else {
-                ingestText(unit, text);
+                ingestText(unit, text, placeholder);
             }
         }
         unit.create.push(createIcuEndOp(xref));
@@ -24366,9 +24553,11 @@ function ingestForBlock(unit, forBlock) {
     const track = convertAst(forBlock.trackBy, unit.job, sourceSpan);
     ingestNodes(repeaterView, forBlock.children);
     let emptyView = null;
+    let emptyTagName = null;
     if (forBlock.empty !== null) {
         emptyView = unit.job.allocateView(unit.xref);
         ingestNodes(emptyView, forBlock.empty.children);
+        emptyTagName = ingestControlFlowInsertionPoint(unit, emptyView.xref, forBlock.empty);
     }
     const varNames = {
         $index: forBlock.contextVariables.$index.name,
@@ -24389,7 +24578,7 @@ function ingestForBlock(unit, forBlock) {
     const i18nPlaceholder = forBlock.i18n;
     const emptyI18nPlaceholder = forBlock.empty?.i18n;
     const tagName = ingestControlFlowInsertionPoint(unit, repeaterView.xref, forBlock);
-    const repeaterCreate = createRepeaterCreateOp(repeaterView.xref, emptyView?.xref ?? null, tagName, track, varNames, i18nPlaceholder, emptyI18nPlaceholder, forBlock.sourceSpan);
+    const repeaterCreate = createRepeaterCreateOp(repeaterView.xref, emptyView?.xref ?? null, tagName, track, varNames, emptyTagName, i18nPlaceholder, emptyI18nPlaceholder, forBlock.startSourceSpan, forBlock.sourceSpan);
     unit.create.push(repeaterCreate);
     const expression = convertAst(forBlock.expression, unit.job, convertSourceSpan(forBlock.expression.span, forBlock.sourceSpan));
     const repeater = createRepeaterOp(repeaterCreate.xref, repeaterCreate.handle, expression, forBlock.sourceSpan);
@@ -24403,7 +24592,29 @@ function convertAst(ast, job, baseSourceSpan) {
         return convertAst(ast.ast, job, baseSourceSpan);
     }
     else if (ast instanceof PropertyRead) {
-        if (ast.receiver instanceof ImplicitReceiver && !(ast.receiver instanceof ThisReceiver)) {
+        const isThisReceiver = ast.receiver instanceof ThisReceiver;
+        // Whether this is an implicit receiver, *excluding* explicit reads of `this`.
+        const isImplicitReceiver = ast.receiver instanceof ImplicitReceiver && !(ast.receiver instanceof ThisReceiver);
+        // Whether the  name of the read is a node that should be never retain its explicit this
+        // receiver.
+        const isSpecialNode = ast.name === '$any' || ast.name === '$event';
+        // TODO: The most sensible condition here would be simply `isImplicitReceiver`, to convert only
+        // actual implicit `this` reads, and not explicit ones. However, TemplateDefinitionBuilder (and
+        // the Typecheck block!) both have the same bug, in which they also consider explicit `this`
+        // reads to be implicit. This causes problems when the explicit `this` read is inside a
+        // template with a context that also provides the variable name being read:
+        // ```
+        // <ng-template let-a>{{this.a}}</ng-template>
+        // ```
+        // The whole point of the explicit `this` was to access the class property, but TDB and the
+        // current TCB treat the read as implicit, and give you the context property instead!
+        //
+        // For now, we emulate this old behvaior by aggressively converting explicit reads to to
+        // implicit reads, except for the special cases that TDB and the current TCB protect. However,
+        // it would be an improvement to fix this.
+        //
+        // See also the corresponding comment for the TCB, in `type_check_block.ts`.
+        if (isImplicitReceiver || (isThisReceiver && !isSpecialNode)) {
             return new LexicalReadExpr(ast.name);
         }
         else {
@@ -24507,13 +24718,13 @@ function convertAst(ast, job, baseSourceSpan) {
         throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
     }
 }
-function convertAstWithInterpolation(job, value, i18nMeta) {
+function convertAstWithInterpolation(job, value, i18nMeta, sourceSpan) {
     let expression;
     if (value instanceof Interpolation$1) {
-        expression = new Interpolation(value.strings, value.expressions.map(e => convertAst(e, job, null)), Object.keys(asMessage(i18nMeta)?.placeholders ?? {}));
+        expression = new Interpolation(value.strings, value.expressions.map(e => convertAst(e, job, sourceSpan ?? null)), Object.keys(asMessage(i18nMeta)?.placeholders ?? {}));
     }
     else if (value instanceof AST) {
-        expression = convertAst(value, job, null);
+        expression = convertAst(value, job, sourceSpan ?? null);
     }
     else {
         expression = literal(value);
@@ -28705,7 +28916,12 @@ class TemplateDefinitionBuilder {
         });
         const { expression: trackByExpression, usesComponentInstance: trackByUsesComponentInstance } = this.createTrackByFunction(block);
         let emptyData = null;
+        let emptyTagName = null;
+        let emptyAttrsExprs;
         if (block.empty !== null) {
+            const emptyInferred = this.inferProjectionDataFromInsertionPoint(block.empty);
+            emptyTagName = emptyInferred.tagName;
+            emptyAttrsExprs = emptyInferred.attrsExprs;
             emptyData = this.prepareEmbeddedTemplateFn(block.empty.children, '_ForEmpty', undefined, block.empty.i18n);
             // Allocate an extra slot for the empty block tracking.
             this.allocateBindingSlots(null);
@@ -28723,13 +28939,13 @@ class TemplateDefinitionBuilder {
                 trackByExpression,
             ];
             if (emptyData !== null) {
-                params.push(literal(trackByUsesComponentInstance), variable(emptyData.name), literal(emptyData.getConstCount()), literal(emptyData.getVarCount()));
+                params.push(literal(trackByUsesComponentInstance), variable(emptyData.name), literal(emptyData.getConstCount()), literal(emptyData.getVarCount()), literal(emptyTagName), this.addAttrsToConsts(emptyAttrsExprs || null));
             }
             else if (trackByUsesComponentInstance) {
                 // If the tracking function doesn't use the component instance, we can omit the flag.
                 params.push(literal(trackByUsesComponentInstance));
             }
-            return params;
+            return trimTrailingNulls(params);
         });
         // Note: the expression needs to be processed *after* the template,
         // otherwise pipes injecting some symbols won't work (see #52102).
@@ -29488,12 +29704,16 @@ class BindingScope {
 }
 /** Binding scope of a `track` function inside a `for` loop block. */
 class TrackByBindingScope extends BindingScope {
-    constructor(parentScope, globalAliases) {
+    constructor(parentScope, globalOverrides) {
         super(parentScope.bindingLevel + 1, parentScope);
-        this.globalAliases = globalAliases;
+        this.globalOverrides = globalOverrides;
         this.componentAccessCount = 0;
     }
     get(name) {
+        // Intercept any overridden globals.
+        if (this.globalOverrides.hasOwnProperty(name)) {
+            return variable(this.globalOverrides[name]);
+        }
         let current = this.parent;
         // Prevent accesses of template variables outside the `for` loop.
         while (current) {
@@ -29502,10 +29722,6 @@ class TrackByBindingScope extends BindingScope {
             }
             current = current.parent;
         }
-        // Intercept any aliased globals.
-        if (this.globalAliases[name]) {
-            return variable(this.globalAliases[name]);
-        }
         // When the component scope is accessed, we redirect it through `this`.
         this.componentAccessCount++;
         return variable('this').prop(name);
@@ -32046,7 +32262,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('17.1.0-next.4');
+const VERSION = new Version('17.1.0-next.5');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -33612,7 +33828,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$5 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('17.1.0-next.4'));
+    definitionMap.set('version', literal('17.1.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -33708,7 +33924,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('17.1.0-next.4'));
+    definitionMap.set('version', literal('17.1.0-next.5'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -34092,7 +34308,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('17.1.0-next.4'));
+    definitionMap.set('version', literal('17.1.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -34127,7 +34343,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('17.1.0-next.4'));
+    definitionMap.set('version', literal('17.1.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -34178,7 +34394,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('17.1.0-next.4'));
+    definitionMap.set('version', literal('17.1.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -34211,7 +34427,7 @@ function createNgModuleDefinitionMap(meta) {
         throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
     }
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-    definitionMap.set('version', literal('17.1.0-next.4'));
+    definitionMap.set('version', literal('17.1.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -34262,7 +34478,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('17.1.0-next.4'));
+    definitionMap.set('version', literal('17.1.0-next.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);