refactor(compiler): Split the i18n placeholder mega-phase (angular#52390)

The i18n placeholder resolution phase has accumulated too much logic,
making it difficult to understand. This commit refactors it into several
smaller phases to make it easier to manage.

I suspect this will undergo further refactoring in the near future as I
work through the ICU logic. In particular `ExtractedMessageOp` feels
like a bit of a grab bag of properties, and the i18n const collection
phase is also starting to get quite heavy. This refactor at least feels
like a good start.

PR Close angular#52390

Author: mmalerba

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

@@ -479,3 +479,31 @@ export enum I18nParamResolutionTime {
    */
   Postproccessing
 }
+
+/**
+ * Flags that describe what an i18n param value. These determine how the value is serialized into
+ * the final map.
+ */
+export enum I18nParamValueFlags {
+  None = 0b0000,
+
+  /**
+   *  This value represtents an element tag.
+   */
+  ElementTag = 0b001,
+
+  /**
+   * This value represents a template tag.
+   */
+  TemplateTag = 0b0010,
+
+  /**
+   * This value represents the opening of a tag.
+   */
+  OpenTag = 0b0100,
+
+  /**
+   * This value represents the closing of a tag.
+   */
+  CloseTag = 0b1000,
+}

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

@@ -960,12 +960,6 @@ export function transformExpressionsInOp(
       op.expression =
           op.expression && transformExpressionsInExpression(op.expression, transform, flags);
       break;
-    case OpKind.ExtractedMessage:
-      op.expression = transformExpressionsInExpression(op.expression, transform, flags);
-      for (const statement of op.statements) {
-        transformExpressionsInStatement(statement, transform, flags);
-      }
-      break;
     case OpKind.RepeaterCreate:
       op.track = transformExpressionsInExpression(op.track, transform, flags);
       if (op.trackByFn !== null) {
@@ -975,34 +969,31 @@ export function transformExpressionsInOp(
     case OpKind.Repeater:
       op.collection = transformExpressionsInExpression(op.collection, transform, flags);
       break;
-    case OpKind.I18n:
-    case OpKind.I18nStart:
-      for (const [placeholder, expression] of op.params) {
-        op.params.set(placeholder, transformExpressionsInExpression(expression, transform, flags));
-      }
-      break;
+    case OpKind.Advance:
+    case OpKind.Container:
+    case OpKind.ContainerEnd:
+    case OpKind.ContainerStart:
     case OpKind.Defer:
-    case OpKind.DeferSecondaryBlock:
     case OpKind.DeferOn:
-    case OpKind.Projection:
-    case OpKind.ProjectionDef:
+    case OpKind.DeferSecondaryBlock:
+    case OpKind.DisableBindings:
     case OpKind.Element:
-    case OpKind.ElementStart:
     case OpKind.ElementEnd:
-    case OpKind.I18nEnd:
-    case OpKind.Container:
-    case OpKind.ContainerStart:
-    case OpKind.ContainerEnd:
-    case OpKind.Template:
-    case OpKind.DisableBindings:
+    case OpKind.ElementStart:
     case OpKind.EnableBindings:
-    case OpKind.Text:
-    case OpKind.Pipe:
-    case OpKind.Advance:
-    case OpKind.Namespace:
+    case OpKind.ExtractedMessage:
+    case OpKind.I18n:
     case OpKind.I18nApply:
+    case OpKind.I18nEnd:
+    case OpKind.I18nStart:
     case OpKind.Icu:
     case OpKind.IcuUpdate:
+    case OpKind.Namespace:
+    case OpKind.Pipe:
+    case OpKind.Projection:
+    case OpKind.ProjectionDef:
+    case OpKind.Template:
+    case OpKind.Text:
       // These operations contain no expressions.
       break;
     default:

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

@@ -9,7 +9,7 @@
 import * as i18n from '../../../../../i18n/i18n_ast';
 import * as o from '../../../../../output/output_ast';
 import {ParseSourceSpan} from '../../../../../parse_util';
-import {BindingKind, DeferSecondaryKind, OpKind} from '../enums';
+import {BindingKind, DeferSecondaryKind, I18nParamValueFlags, OpKind} from '../enums';
 import {Op, OpList, XrefId} from '../operations';
 import {ConsumesSlotOpTrait, HasConstTrait, TRAIT_CONSUMES_SLOT, TRAIT_HAS_CONST, TRAIT_USES_SLOT_INDEX, UsesSlotIndexTrait} from '../traits';
 
@@ -739,6 +739,27 @@ export function createDeferOnOp(xref: XrefId, sourceSpan: ParseSourceSpan): Defe
   };
 }
 
+/**
+ * Represents a single value in an i18n param map. Each placeholder in the map may have multiple of
+ * these values associated with it.
+ */
+export interface I18nParamValue {
+  /**
+   * The value.
+   */
+  value: string|number;
+
+  /**
+   * The sub-template index associated with the value.
+   */
+  subTemplateIndex: number|null;
+
+  /**
+   * Flags associated with the value.
+   */
+  flags: I18nParamValueFlags;
+}
+
 /**
  * Represents an i18n message that has been extracted for inclusion in the consts array.
  */
@@ -751,26 +772,61 @@ export interface ExtractedMessageOp extends Op<CreateOp> {
   owner: XrefId;
 
   /**
-   * The message expression.
+   * The i18n message represented by this op.
+   */
+  message: i18n.Message;
+
+  /**
+   * Whether this op represents a root message (as opposed to a partial message for a sub-template
+   * in a root message).
+   */
+  isRoot: boolean;
+
+  /**
+   * The param map, with placeholders represented as an array of value objects for easy
+   * manipulation.
+   */
+  params: Map<string, I18nParamValue[]>;
+
+  /**
+   * The post-processing param map, with placeholders represented as an array of value objects for
+   * easy manipulation.
+   */
+  postprocessingParams: Map<string, I18nParamValue[]>;
+
+  /**
+   * Whether this message needs post-processing.
+   */
+  needsPostprocessing: boolean;
+
+  /**
+   * The param map, with placeholders represented as an `Expression` to facilitate extraction to the
+   * const arry.
    */
-  expression: o.Expression;
+  formattedParams: Map<string, o.Expression>|null;
 
   /**
-   * The statements to construct the message.
+   * The post-processing param map, with placeholders represented as an `Expression` to facilitate
+   * extraction to the const arry.
    */
-  statements: o.Statement[];
+  formattedPostprocessingParams: Map<string, o.Expression>|null;
 }
 
 /**
  * Create an `ExtractedMessageOp`.
  */
 export function createExtractedMessageOp(
-    owner: XrefId, expression: o.Expression, statements: o.Statement[]): ExtractedMessageOp {
+    owner: XrefId, message: i18n.Message, isRoot: boolean): ExtractedMessageOp {
   return {
     kind: OpKind.ExtractedMessage,
     owner,
-    expression,
-    statements,
+    message,
+    isRoot,
+    params: new Map(),
+    postprocessingParams: new Map(),
+    needsPostprocessing: false,
+    formattedParams: null,
+    formattedPostprocessingParams: null,
     ...NEW_OP,
   };
 }
@@ -794,17 +850,6 @@ export interface I18nOpBase extends Op<CreateOp>, ConsumesSlotOpTrait {
    */
   message: i18n.Message;
 
-  /**
-   * Map of values to use for named placeholders in the i18n message. (Resolved at message creation)
-   */
-  params: Map<string, o.Expression>;
-
-  /**
-   * Map of values to use for named placeholders in the i18n message. (Resolved during
-   * post-porcessing)
-   */
-  postprocessingParams: Map<string, o.Expression>;
-
   /**
    * The index in the consts array where the message i18n message is stored.
    */
@@ -814,11 +859,6 @@ export interface I18nOpBase extends Op<CreateOp>, ConsumesSlotOpTrait {
    * The index of this sub-block in the i18n message. For a root i18n block, this is null.
    */
   subTemplateIndex: number|null;
-
-  /**
-   * Whether the i18n message requires postprocessing.
-   */
-  needsPostprocessing: boolean;
 }
 
 /**
@@ -844,11 +884,8 @@ export function createI18nStartOp(xref: XrefId, message: i18n.Message, root?: Xr
     xref,
     root: root ?? xref,
     message,
-    params: new Map(),
-    postprocessingParams: new Map(),
     messageIndex: null,
     subTemplateIndex: null,
-    needsPostprocessing: false,
     ...NEW_OP,
     ...TRAIT_CONSUMES_SLOT,
   };

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

@@ -16,15 +16,15 @@ import {CompilationJob, CompilationJobKind as Kind, type ComponentCompilationJob
 import {phaseFindAnyCasts} from './phases/any_cast';
 import {phaseApplyI18nExpressions} from './phases/apply_i18n_expressions';
 import {phaseAssignI18nSlotDependencies} from './phases/assign_i18n_slot_dependencies';
-import {phaseCollapseSingletonInterpolations} from './phases/collapse_singleton_interpolations';
 import {phaseAttributeExtraction} from './phases/attribute_extraction';
 import {phaseBindingSpecialization} from './phases/binding_specialization';
 import {phaseChaining} from './phases/chaining';
+import {phaseCollapseSingletonInterpolations} from './phases/collapse_singleton_interpolations';
 import {phaseConditionals} from './phases/conditionals';
 import {phaseConstCollection} from './phases/const_collection';
 import {phaseEmptyElements} from './phases/empty_elements';
 import {phaseExpandSafeReads} from './phases/expand_safe_reads';
-import {phaseRepeaterDerivedVars} from './phases/repeater_derived_vars';
+import {phaseFormatI18nParams} from './phases/format_i18n_params';
 import {phaseGenerateAdvance} from './phases/generate_advance';
 import {phaseGenerateProjectionDef} from './phases/generate_projection_def';
 import {phaseGenerateVariables} from './phases/generate_variables';
@@ -47,25 +47,28 @@ import {phaseRemoveContentSelectors} from './phases/phase_remove_content_selecto
 import {phasePipeCreation} from './phases/pipe_creation';
 import {phasePipeVariadic} from './phases/pipe_variadic';
 import {phasePropagateI18nBlocks} from './phases/propagate_i18n_blocks';
+import {phasePropagateI18nPlaceholders} from './phases/propagate_i18n_placeholders';
 import {phasePureFunctionExtraction} from './phases/pure_function_extraction';
 import {phasePureLiteralStructures} from './phases/pure_literal_structures';
 import {phaseReify} from './phases/reify';
 import {phaseRemoveEmptyBindings} from './phases/remove_empty_bindings';
+import {phaseRepeaterDerivedVars} from './phases/repeater_derived_vars';
 import {phaseResolveContexts} from './phases/resolve_contexts';
 import {phaseResolveDollarEvent} from './phases/resolve_dollar_event';
-import {phaseResolveI18nPlaceholders} from './phases/resolve_i18n_placeholders';
+import {phaseResolveI18nElementPlaceholders} from './phases/resolve_i18n_element_placeholders';
+import {phaseResolveI18nExpressionPlaceholders} from './phases/resolve_i18n_expression_placeholders';
 import {phaseResolveNames} from './phases/resolve_names';
 import {phaseResolveSanitizers} from './phases/resolve_sanitizers';
 import {phaseSaveRestoreView} from './phases/save_restore_view';
 import {phaseSlotAllocation} from './phases/slot_allocation';
 import {phaseStyleBindingSpecialization} from './phases/style_binding_specialization';
 import {phaseTemporaryVariables} from './phases/temporary_variables';
+import {phaseTrackFnGeneration} from './phases/track_fn_generation';
+import {phaseTrackFnOptimization} from './phases/track_fn_optimization';
+import {phaseTrackVariables} from './phases/track_variables';
 import {phaseVarCounting} from './phases/var_counting';
 import {phaseVariableOptimization} from './phases/variable_optimization';
 import {phaseWrapIcus} from './phases/wrap_icus';
-import {phaseTrackVariables} from './phases/track_variables';
-import {phaseTrackFnGeneration} from './phases/track_fn_generation';
-import {phaseTrackFnOptimization} from './phases/track_fn_optimization';
 
 type Phase = {
   fn: (job: CompilationJob) => void; kind: Kind.Both | Kind.Host | Kind.Tmpl;
@@ -114,9 +117,12 @@ const phases: Phase[] = [
   {kind: Kind.Both, fn: phaseExpandSafeReads},
   {kind: Kind.Both, fn: phaseTemporaryVariables},
   {kind: Kind.Tmpl, fn: phaseSlotAllocation},
-  {kind: Kind.Tmpl, fn: phaseResolveI18nPlaceholders},
-  {kind: Kind.Tmpl, fn: phaseTrackFnGeneration},
   {kind: Kind.Tmpl, fn: phaseI18nMessageExtraction},
+  {kind: Kind.Tmpl, fn: phaseResolveI18nElementPlaceholders},
+  {kind: Kind.Tmpl, fn: phaseResolveI18nExpressionPlaceholders},
+  {kind: Kind.Tmpl, fn: phasePropagateI18nPlaceholders},
+  {kind: Kind.Tmpl, fn: phaseFormatI18nParams},
+  {kind: Kind.Tmpl, fn: phaseTrackFnGeneration},
   {kind: Kind.Tmpl, fn: phaseI18nConstCollection},
   {kind: Kind.Tmpl, fn: phaseConstTraitCollection},
   {kind: Kind.Both, fn: phaseConstCollection},