@angular/compiler-cli 21.2.1 → 21.2.3

package/bundles/{chunk-WBUBKNAO.js → chunk-NU2SXS64.js}

@@ -12,7 +12,7 @@ import {
   formatDiagnostics,
   performCompilation,
   readConfiguration
-} from "./chunk-VO3Q626H.js";
+} from "./chunk-KJC7YNMY.js";
 
 // packages/compiler-cli/src/main.js
 import ts2 from "typescript";

package/bundles/index.js

@@ -17,7 +17,7 @@ import {
   isTsDiagnostic,
   performCompilation,
   readConfiguration
-} from "./chunk-VO3Q626H.js";
+} from "./chunk-KJC7YNMY.js";
 import {
   ConsoleLogger,
   LogLevel
@@ -34,7 +34,7 @@ import {
   freshCompilationTicket,
   incrementalFromStateTicket,
   isDocEntryWithSourceInfo
-} from "./chunk-PW54LIP6.js";
+} from "./chunk-6JHVJEKD.js";
 import {
   ActivePerfRecorder,
   ErrorCode,
@@ -46,7 +46,7 @@ import {
   getInitializerApiJitTransform,
   isLocalCompilationDiagnostics,
   ngErrorCode
-} from "./chunk-IG22BDVK.js";
+} from "./chunk-L3PEIUBN.js";
 import "./chunk-CSUVPNMK.js";
 import {
   InvalidFileSystem,
@@ -77,7 +77,7 @@ import "./chunk-G7GFT6BU.js";
 
 // packages/compiler-cli/src/version.js
 import { Version } from "@angular/compiler";
-var VERSION = new Version("21.2.1");
+var VERSION = new Version("21.2.3");
 
 // packages/compiler-cli/private/tooling.js
 var GLOBAL_DEFS_FOR_TERSER = {

package/bundles/private/migrations.js

@@ -5,7 +5,7 @@
 import {
   DiagnosticCategoryLabel,
   NgCompiler
-} from "../chunk-PW54LIP6.js";
+} from "../chunk-6JHVJEKD.js";
 import {
   CompilationMode,
   DtsMetadataReader,
@@ -32,7 +32,7 @@ import {
   queryDecoratorNames,
   reflectObjectLiteral,
   unwrapExpression
-} from "../chunk-IG22BDVK.js";
+} from "../chunk-L3PEIUBN.js";
 import "../chunk-CSUVPNMK.js";
 import {
   getFileSystem,

package/bundles/private/testing.js

@@ -6,7 +6,7 @@ import {
   ImportedSymbolsTracker,
   TypeScriptReflectionHost,
   getInitializerApiJitTransform
-} from "../chunk-IG22BDVK.js";
+} from "../chunk-L3PEIUBN.js";
 import "../chunk-CSUVPNMK.js";
 import {
   InvalidFileSystem,

package/bundles/private/tooling.js

@@ -4,7 +4,7 @@
     
 import {
   angularJitApplicationTransform
-} from "../chunk-IG22BDVK.js";
+} from "../chunk-L3PEIUBN.js";
 import "../chunk-CSUVPNMK.js";
 import "../chunk-CEBE44Q5.js";
 import "../chunk-XYYEESKY.js";

package/bundles/src/bin/ng_xi18n.js

@@ -6,12 +6,12 @@
 import {
   main,
   readCommandLineAndConfiguration
-} from "../../chunk-WBUBKNAO.js";
+} from "../../chunk-NU2SXS64.js";
 import {
   EmitFlags
-} from "../../chunk-VO3Q626H.js";
-import "../../chunk-PW54LIP6.js";
-import "../../chunk-IG22BDVK.js";
+} from "../../chunk-KJC7YNMY.js";
+import "../../chunk-6JHVJEKD.js";
+import "../../chunk-L3PEIUBN.js";
 import "../../chunk-CSUVPNMK.js";
 import {
   setFileSystem

package/bundles/src/bin/ngc.js

@@ -5,10 +5,10 @@
     
 import {
   main
-} from "../../chunk-WBUBKNAO.js";
-import "../../chunk-VO3Q626H.js";
-import "../../chunk-PW54LIP6.js";
-import "../../chunk-IG22BDVK.js";
+} from "../../chunk-NU2SXS64.js";
+import "../../chunk-KJC7YNMY.js";
+import "../../chunk-6JHVJEKD.js";
+import "../../chunk-L3PEIUBN.js";
 import "../../chunk-CSUVPNMK.js";
 import {
   setFileSystem

package/linker/src/file_linker/partial_linkers/util.d.ts

@@ -7,7 +7,7 @@
  */
 import { MaybeForwardRefExpression, outputAst as o, R3DeclareDependencyMetadata, R3DependencyMetadata, R3Reference } from '@angular/compiler';
 import { AstObject, AstValue } from '../../ast/ast_value';
-export declare const PLACEHOLDER_VERSION = "21.2.1";
+export declare const PLACEHOLDER_VERSION = "21.2.3";
 export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
 /**
  * Parses the value of an enum from the AST value's symbol name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "21.2.1",
+  "version": "21.2.3",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -43,7 +43,7 @@
     "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "@angular/compiler": "21.2.1",
+    "@angular/compiler": "21.2.3",
     "typescript": ">=5.9 <6.1"
   },
   "peerDependenciesMeta": {

package/src/ngtsc/annotations/common/src/diagnostics.d.ts

@@ -1,10 +1,10 @@
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
+* @license
+* Copyright Google LLC All Rights Reserved.
+*
+* Use of this source code is governed by an MIT-style license that can be
+* found in the LICENSE file at https://angular.dev/license
+*/
 import ts from 'typescript';
 import { FatalDiagnosticError } from '../../../diagnostics';
 import { Reference } from '../../../imports';
@@ -56,7 +56,7 @@ export declare function findInheritedCtor(node: ClassDeclaration, injectableRegi
  * from external files. This is a common scenario for errors in local compilation mode,
  * and so this helper can be used to quickly generate the relevant errors.
  *
- * @param nodeToHighlight Node to be highlighted in teh error message.
+ * @param nodeToHighlight Node to be highlighted in the error message.
  * Will default to value.node if not provided.
  */
 export declare function assertLocalCompilationUnresolvedConst(compilationMode: CompilationMode, value: ResolvedValue, nodeToHighlight: ts.Node | null, errorMessage: string): void;

package/src/ngtsc/core/api/src/adapter.d.ts

@@ -12,7 +12,7 @@ import { ExtendedTsCompilerHost, UnifiedModulesHost } from './interfaces';
  * Names of methods from `ExtendedTsCompilerHost` that need to be provided by the
  * `NgCompilerAdapter`.
  */
-export type ExtendedCompilerHostMethods = 'getCanonicalFileName' | 'resolveModuleNames' | 'getCurrentDirectory' | 'getModifiedResourceFiles' | 'readResource' | 'resourceNameToFileName' | 'transformResource';
+export type ExtendedCompilerHostMethods = 'getCanonicalFileName' | 'getSourceFile' | 'resolveModuleNames' | 'getCurrentDirectory' | 'getModifiedResourceFiles' | 'readResource' | 'resourceNameToFileName' | 'transformResource';
 /**
  * Adapter for `NgCompiler` that allows it to be used in various circumstances, such as
  * command-line `ngc`, as a plugin to `ts_library` in Bazel, or from the Language Service.

package/src/ngtsc/incremental/src/incremental.d.ts

@@ -35,7 +35,7 @@ export declare class IncrementalCompilation implements IncrementalBuild<ClassRec
     /**
      * Begin a fresh `IncrementalCompilation`.
      */
-    static fresh(program: ts.Program, versions: Map<AbsoluteFsPath, string> | null): IncrementalCompilation;
+    static fresh(versions: Map<AbsoluteFsPath, string> | null): IncrementalCompilation;
     static incremental(program: ts.Program, newVersions: Map<AbsoluteFsPath, string> | null, oldProgram: ts.Program, oldState: IncrementalState, modifiedResourceFiles: Set<AbsoluteFsPath> | null, perf: PerfRecorder): IncrementalCompilation;
     get state(): IncrementalState;
     get semanticDepGraphUpdater(): SemanticDepGraphUpdater;

package/src/ngtsc/typecheck/api/api.d.ts

@@ -5,12 +5,89 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { AbsoluteSourceSpan, BoundTarget, DirectiveMeta, ParseSourceSpan, SchemaMetadata } from '@angular/compiler';
+import { AbsoluteSourceSpan, BoundTarget, DirectiveMeta, LegacyAnimationTriggerNames, ParseSourceSpan, SchemaMetadata } from '@angular/compiler';
 import ts from 'typescript';
 import { ErrorCode } from '../../diagnostics';
 import { Reference } from '../../imports';
-import { ClassPropertyMapping, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping, PipeMeta } from '../../metadata';
+import { ClassPropertyMapping, ClassPropertyName, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping, InputOrOutput, PipeMeta, TemplateGuardMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
+export interface TcbReferenceMetadata {
+    /** The name of the class */
+    name: string;
+    /** The module path where the symbol is located, or null if local/ambient */
+    moduleName: string | null;
+    /** True if the symbol successfully emitted locally (no external import required) */
+    isLocal: boolean;
+    /** If the reference could not be externally emitted, this string holds the diagnostic reason why */
+    unexportedDiagnostic: string | null;
+    /**
+     * Defines the `AbsoluteSourceSpan` of the target's node name, if available.
+     */
+    nodeNameSpan?: AbsoluteSourceSpan;
+    /**
+     * The absolute path to the file containing the reference node, if available.
+     */
+    nodeFilePath?: string;
+}
+export type TcbReferenceKey = string & {
+    __brand: 'TcbReferenceKey';
+};
+export interface TcbTypeParameter {
+    name: string;
+    representation: string;
+    representationWithDefault: string;
+}
+export type TcbInputMapping = InputOrOutput & {
+    required: boolean;
+    /**
+     * AST-free string representation of the transform type of the input, if available.
+     */
+    transformType?: string;
+};
+export interface TcbPipeMetadata {
+    name: string;
+    ref: TcbReferenceMetadata;
+    isExplicitlyDeferred: boolean;
+}
+export interface TcbDirectiveMetadata {
+    ref: TcbReferenceMetadata;
+    name: string;
+    selector: string | null;
+    isComponent: boolean;
+    isGeneric: boolean;
+    isStructural: boolean;
+    isStandalone: boolean;
+    isExplicitlyDeferred: boolean;
+    preserveWhitespaces: boolean;
+    exportAs: string[] | null;
+    /** Type parameters of the directive, if available. */
+    typeParameters: TcbTypeParameter[] | null;
+    inputs: ClassPropertyMapping<TcbInputMapping>;
+    outputs: ClassPropertyMapping;
+    hasRequiresInlineTypeCtor: boolean;
+    ngTemplateGuards: TemplateGuardMeta[];
+    hasNgTemplateContextGuard: boolean;
+    hasNgFieldDirective: boolean;
+    coercedInputFields: Set<ClassPropertyName>;
+    restrictedInputFields: Set<ClassPropertyName>;
+    stringLiteralInputFields: Set<ClassPropertyName>;
+    undeclaredInputFields: Set<ClassPropertyName>;
+    publicMethods: Set<string>;
+    ngContentSelectors: string[] | null;
+    animationTriggerNames: LegacyAnimationTriggerNames | null;
+}
+export interface TcbComponentMetadata {
+    ref: TcbReferenceMetadata;
+    typeParameters: TcbTypeParameter[] | null;
+}
+export interface TcbTypeCheckBlockMetadata {
+    id: TypeCheckId;
+    boundTarget: BoundTarget<TcbDirectiveMetadata>;
+    pipes: Map<string, TcbPipeMetadata> | null;
+    schemas: SchemaMetadata[];
+    isStandalone: boolean;
+    preserveWhitespaces: boolean;
+}
 /**
  * Extension of `DirectiveMeta` that includes additional information required to type-check the
  * usage of a particular directive.
@@ -90,8 +167,7 @@ export interface TypeCtorMetadata {
      * Input, output, and query field names in the type which should be included as constructor input.
      */
     fields: {
-        inputs: ClassPropertyMapping<InputMapping>;
-        queries: string[];
+        inputs: ClassPropertyMapping<TcbInputMapping>;
     };
     /**
      * `Set` of field names which have type coercion enabled.

package/src/ngtsc/typecheck/src/checker.d.ts

@@ -75,7 +75,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     private elementTagCache;
     private isComplete;
     private priorResultsAdopted;
-    constructor(originalProgram: ts.Program, programDriver: ProgramDriver, typeCheckAdapter: ProgramTypeCheckAdapter, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>, metaReader: MetadataReader, localMetaReader: MetadataReaderWithIndex, ngModuleIndex: NgModuleIndex, componentScopeReader: ComponentScopeReader, typeCheckScopeRegistry: TypeCheckScopeRegistry, perf: PerfRecorder);
+    constructor(originalProgram: ts.Program, programDriver: ProgramDriver, typeCheckAdapter: ProgramTypeCheckAdapter, config: TypeCheckingConfig, refEmitter: ReferenceEmitter, reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName' | 'getSourceFile'>, priorBuild: IncrementalBuild<unknown, FileTypeCheckingData>, metaReader: MetadataReader, localMetaReader: MetadataReaderWithIndex, ngModuleIndex: NgModuleIndex, componentScopeReader: ComponentScopeReader, typeCheckScopeRegistry: TypeCheckScopeRegistry, perf: PerfRecorder);
     getTemplate(component: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstNode[] | null;
     getHostElement(directive: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstHostElement | null;
     getDirectivesOfNode(component: ts.ClassDeclaration, node: TmplAstElement | TmplAstTemplate): TypeCheckableDirectiveMeta[] | null;

package/src/ngtsc/typecheck/src/comments.d.ts

@@ -26,13 +26,6 @@ export declare enum ExpressionIdentifier {
     EVENT_PARAMETER = "EP",
     VARIABLE_AS_EXPRESSION = "VAE"
 }
-/** Tags the node with the given expression identifier. */
-export declare function addExpressionIdentifier(node: ts.Node, identifier: ExpressionIdentifier): void;
-/**
- * Tag the `ts.Node` with an indication that any errors arising from the evaluation of the node
- * should be ignored.
- */
-export declare function markIgnoreDiagnostics(node: ts.Node): void;
 /** Returns true if the node has a marker that indicates diagnostics errors should be ignored.  */
 export declare function hasIgnoreForDiagnosticsMarker(node: ts.Node, sourceFile: ts.SourceFile): boolean;
 export interface FindOptions<T extends ts.Node> {

package/src/ngtsc/typecheck/src/context.d.ts

@@ -153,7 +153,7 @@ export declare class TypeCheckContextImpl implements TypeCheckContext {
     private inlining;
     private perf;
     private fileMap;
-    constructor(config: TypeCheckingConfig, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, refEmitter: ReferenceEmitter, reflector: ReflectionHost, host: TypeCheckingHost, inlining: InliningMode, perf: PerfRecorder);
+    constructor(config: TypeCheckingConfig, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName' | 'getSourceFile'>, refEmitter: ReferenceEmitter, reflector: ReflectionHost, host: TypeCheckingHost, inlining: InliningMode, perf: PerfRecorder);
     /**
      * A `Map` of `ts.SourceFile`s that the context has seen to the operations (additions of methods
      * or type-check blocks) that need to be eventually performed on that file.

package/src/ngtsc/typecheck/src/environment.d.ts

@@ -9,8 +9,9 @@ import ts from 'typescript';
 import { Reference, ReferenceEmitter } from '../../imports';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { ImportManager } from '../../translator';
-import { TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
+import { TcbDirectiveMetadata, TcbPipeMetadata, TcbReferenceKey, TcbReferenceMetadata, TypeCheckingConfig } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
+import { TcbExpr } from './ops/codegen';
 /**
  * A context which hosts one or more Type Check Blocks (TCBs).
  *
@@ -26,9 +27,9 @@ export declare class Environment extends ReferenceEmitEnvironment {
     readonly config: TypeCheckingConfig;
     private nextIds;
     private typeCtors;
-    protected typeCtorStatements: ts.Statement[];
+    protected typeCtorStatements: TcbExpr[];
     private pipeInsts;
-    protected pipeInstStatements: ts.Statement[];
+    protected pipeInstStatements: TcbExpr[];
     constructor(config: TypeCheckingConfig, importManager: ImportManager, refEmitter: ReferenceEmitter, reflector: ReflectionHost, contextFile: ts.SourceFile);
     /**
      * Get an expression referring to a type constructor for the given directive.
@@ -36,14 +37,15 @@ export declare class Environment extends ReferenceEmitEnvironment {
      * Depending on the shape of the directive itself, this could be either a reference to a declared
      * type constructor, or to an inline type constructor.
      */
-    typeCtorFor(dir: TypeCheckableDirectiveMeta): ts.Expression;
-    pipeInst(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): ts.Expression;
+    typeCtorFor(dir: TcbDirectiveMetadata): TcbExpr;
+    pipeInst(pipe: TcbPipeMetadata): TcbExpr;
     /**
      * Generate a `ts.Expression` that references the given node.
      *
      * This may involve importing the node into the file if it's not declared there already.
      */
-    reference(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): ts.Expression;
+    reference(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): TcbExpr;
     private emitTypeParameters;
-    getPreludeStatements(): ts.Statement[];
+    getPreludeStatements(): TcbExpr[];
 }
+export declare function getTcbReferenceKey(ref: TcbReferenceMetadata): TcbReferenceKey;

package/src/ngtsc/typecheck/src/expression.d.ts

@@ -6,22 +6,10 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { AST } from '@angular/compiler';
-import ts from 'typescript';
+import { TcbExpr } from './ops/codegen';
 import { TypeCheckingConfig } from '../api';
 /**
- * Gets an expression that is cast to any. Currently represented as `0 as any`.
- *
- * Historically this expression was using `null as any`, but a newly-added check in TypeScript 5.6
- * (https://devblogs.microsoft.com/typescript/announcing-typescript-5-6-beta/#disallowed-nullish-and-truthy-checks)
- * started flagging it as always being nullish. Other options that were considered:
- * - `NaN as any` or `Infinity as any` - not used, because they don't work if the `noLib` compiler
- *   option is enabled. Also they require more characters.
- * - Some flavor of function call, like `isNan(0) as any` - requires even more characters than the
- *   NaN option and has the same issue with `noLib`.
- */
-export declare function getAnyExpression(): ts.AsExpression;
-/**
- * Convert an `AST` to TypeScript code directly, without going through an intermediate `Expression`
+ * Convert an `AST` to a `TcbExpr` directly, without going through an intermediate `Expression`
  * AST.
  */
-export declare function astToTypescript(ast: AST, maybeResolve: (ast: AST) => ts.Expression | null, config: TypeCheckingConfig): ts.Expression;
+export declare function astToTcbExpr(ast: AST, maybeResolve: (ast: AST) => TcbExpr | null, config: TypeCheckingConfig): TcbExpr;

package/src/ngtsc/typecheck/src/host_bindings.d.ts

@@ -23,7 +23,7 @@ export declare function createHostElement(type: 'component' | 'directive', selec
  * Creates an AST node that can be used as a guard in `if` statements to distinguish TypeScript
  * nodes used for checking host bindings from ones used for checking templates.
  */
-export declare function createHostBindingsBlockGuard(): ts.Expression;
+export declare function createHostBindingsBlockGuard(): string;
 /**
  * Determines if a given node is a guard that indicates that descendant nodes are used to check
  * host bindings.

package/src/ngtsc/typecheck/src/oob.d.ts

@@ -8,7 +8,7 @@
 import { AST, BindingPipe, PropertyRead, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty, TmplAstHoverDeferredTrigger, TmplAstIfBlockBranch, TmplAstInteractionDeferredTrigger, TmplAstLetDeclaration, TmplAstReference, TmplAstSwitchBlockCase, TmplAstTemplate, TmplAstTextAttribute, TmplAstVariable, TmplAstViewportDeferredTrigger } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassDeclaration } from '../../reflection';
-import { TemplateDiagnostic, TypeCheckId } from '../api';
+import { TcbDirectiveMetadata, TemplateDiagnostic, TypeCheckId } from '../api';
 import { TypeCheckSourceResolver } from './tcb_util';
 /**
  * Collects `ts.Diagnostic`s on problems which occur in the template which aren't directly sourced
@@ -73,7 +73,7 @@ export interface OutOfBandDiagnosticRecorder {
     /**
      * Reports a split two way binding error message.
      */
-    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: ClassDeclaration, outputConsumer: ClassDeclaration | TmplAstElement): void;
+    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'>, outputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'> | TmplAstElement): void;
     /** Reports required inputs that haven't been bound. */
     missingRequiredInputs(id: TypeCheckId, element: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
     /**
@@ -136,6 +136,7 @@ export interface OutOfBandDiagnosticRecorder {
 }
 export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnosticRecorder {
     private resolver;
+    private getSourceFile;
     private readonly _diagnostics;
     /**
      * Tracks which `BindingPipe` nodes have already been recorded as invalid, so only one diagnostic
@@ -144,7 +145,7 @@ export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnos
     private readonly recordedPipes;
     /** Common pipes that can be suggested to users. */
     private readonly pipeSuggestions;
-    constructor(resolver: TypeCheckSourceResolver);
+    constructor(resolver: TypeCheckSourceResolver, getSourceFile?: (fileName: string) => ts.SourceFile | undefined);
     get diagnostics(): ReadonlyArray<TemplateDiagnostic>;
     missingReferenceTarget(id: TypeCheckId, ref: TmplAstReference): void;
     missingPipe(id: TypeCheckId, ast: BindingPipe, isStandalone: boolean): void;
@@ -154,7 +155,7 @@ export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnos
     requiresInlineTcb(id: TypeCheckId, node: ClassDeclaration): void;
     requiresInlineTypeConstructors(id: TypeCheckId, node: ClassDeclaration, directives: ClassDeclaration[]): void;
     suboptimalTypeInference(id: TypeCheckId, variables: TmplAstVariable[]): void;
-    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: ClassDeclaration, outputConsumer: ClassDeclaration | TmplAstElement): void;
+    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'>, outputConsumer: Pick<TcbDirectiveMetadata, 'name' | 'isComponent' | 'ref'> | TmplAstElement): void;
     missingRequiredInputs(id: TypeCheckId, element: TmplAstElement | TmplAstTemplate | TmplAstComponent | TmplAstDirective, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
     illegalForLoopTrackAccess(id: TypeCheckId, block: TmplAstForLoopBlock, access: PropertyRead): void;
     inaccessibleDeferredTriggerElement(id: TypeCheckId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;

package/src/ngtsc/typecheck/src/ops/base.d.ts

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import ts from 'typescript';
+import { TcbExpr } from './codegen';
 /**
  * A code generation operation that's involved in the construction of a Type Check Block.
  *
@@ -30,7 +30,7 @@ export declare abstract class TcbOp {
      * code to generate, parse and type-check, overall positively contributing to performance.
      */
     abstract readonly optional: boolean;
-    abstract execute(): ts.Expression | null;
+    abstract execute(): TcbExpr | null;
     /**
      * Replacement value or operation used while this `TcbOp` is executing (i.e. to resolve circular
      * references during its execution).
@@ -39,5 +39,5 @@ export declare abstract class TcbOp {
      * `TcbOp` can be returned in cases where additional code generation is necessary to deal with
      * circular references.
      */
-    circularFallback(): TcbOp | ts.Expression;
+    circularFallback(): TcbOp | TcbExpr;
 }

package/src/ngtsc/typecheck/src/ops/bindings.d.ts

@@ -6,11 +6,10 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { AST, ParseSourceSpan, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstTemplate } from '@angular/compiler';
-import ts from 'typescript';
-import { TypeCheckableDirectiveMeta } from '../../api';
+import { TcbDirectiveMetadata } from '../../api';
 import { ClassPropertyName } from '../../../metadata';
-import { Reference } from '../../../imports';
 import { Context } from './context';
+import { TcbExpr } from './codegen';
 export interface TcbBoundAttribute {
     value: AST | string;
     sourceSpan: ParseSourceSpan;
@@ -19,7 +18,7 @@ export interface TcbBoundAttribute {
         fieldName: ClassPropertyName;
         required: boolean;
         isSignal: boolean;
-        transformType: Reference<ts.TypeNode> | null;
+        transformType?: string;
         isTwoWayBinding: boolean;
     }[];
 }
@@ -33,9 +32,13 @@ export interface TcbDirectiveBoundInput {
      */
     field: string;
     /**
-     * The `ts.Expression` corresponding with the input binding expression.
+     * The `TcbExpr` corresponding with the input binding expression.
      */
-    expression: ts.Expression;
+    expression: TcbExpr;
+    /**
+     * The input's original value expression.
+     */
+    originalExpression: AST | string;
     /**
      * The source span of the full attribute binding.
      */
@@ -56,9 +59,9 @@ export interface TcbDirectiveUnsetInput {
     field: string;
 }
 export type TcbDirectiveInput = TcbDirectiveBoundInput | TcbDirectiveUnsetInput;
-export declare function getBoundAttributes(directive: TypeCheckableDirectiveMeta, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective): TcbBoundAttribute[];
+export declare function getBoundAttributes(directive: TcbDirectiveMetadata, node: TmplAstTemplate | TmplAstElement | TmplAstComponent | TmplAstDirective): TcbBoundAttribute[];
 export declare function checkSplitTwoWayBinding(inputName: string, output: TmplAstBoundEvent, inputs: TmplAstBoundAttribute[], tcb: Context): boolean;
 /**
  * Potentially widens the type of `expr` according to the type-checking configuration.
  */
-export declare function widenBinding(expr: ts.Expression, tcb: Context): ts.Expression;
+export declare function widenBinding(expr: TcbExpr, tcb: Context, originalValue: string | AST): TcbExpr;

package/src/ngtsc/typecheck/src/ops/codegen.d.ts

@@ -0,0 +1,74 @@
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+import { AbsoluteSourceSpan, ParseSourceSpan } from '@angular/compiler';
+import ts from 'typescript';
+import { ExpressionIdentifier } from '../comments';
+/** Represents an expression generated within a type check block. */
+export declare class TcbExpr {
+    private source;
+    /** Text for the content containing the expression's location information. */
+    private spanComment;
+    /** Text for the content containing the expression's identifier. */
+    private identifierComment;
+    /**
+     * Text of the comment instructing the type checker to
+     * ignore diagnostics coming from this expression.
+     */
+    private ignoreComment;
+    constructor(source: string);
+    /**
+     * Converts the node's current state to a string.
+     * @param ignoreComments Whether the comments associated with the expression should be skipped.
+     */
+    print(ignoreComments?: boolean): string;
+    /**
+     * Adds a synthetic comment to the expression that represents the parse span of the provided node.
+     * This comment can later be retrieved as trivia of a node to recover original source locations.
+     * @param span Span from the parser containing the location information.
+     */
+    addParseSpanInfo(span: AbsoluteSourceSpan | ParseSourceSpan): this;
+    /** Marks the expression to be ignored for diagnostics. */
+    markIgnoreDiagnostics(): this;
+    /**
+     * Wraps the expression in parenthesis such that inserted
+     * span comments become attached to the proper node.
+     */
+    wrapForTypeChecker(): this;
+    /**
+     * Tags the expression with an identifier.
+     * @param identifier Identifier to apply to the expression.
+     */
+    addExpressionIdentifier(identifier: ExpressionIdentifier): this;
+    /**
+     * `toString` implementation meant to catch errors like accidentally
+     * writing `foo ${expr} bar` instead of `foo ${expr.print()} bar`.
+     */
+    toString(): never;
+    /** Format a comment string as a TypeScript comment. */
+    private formatComment;
+}
+/**
+ * Declares a variable with a specific type.
+ * @param identifier Identifier used to refer to the variable.
+ * @param type Type that the variable should be initialized to.
+ */
+export declare function declareVariable(identifier: TcbExpr, type: TcbExpr): TcbExpr;
+/**
+ * Formats an array of `TcbExpr` as a block of single statements.
+ * @param expressions Expressions to format.
+ * @param singleLine Whether to print them on a single line or across multiple. Defaults to multiple.
+ */
+export declare function getStatementsBlock(expressions: TcbExpr[], singleLine?: boolean): string;
+/** Wraps a string value in quotes and escapes relevant characters. */
+export declare function quoteAndEscape(value: string): string;
+/**
+ * Prints a TypeScript node as a string.
+ *
+ * @deprecated This is a temporary method until all code generation code has been migrated.
+ */
+export declare function tempPrint(node: ts.Node, sourceFile: ts.SourceFile): string;

package/src/ngtsc/typecheck/src/ops/context.d.ts

@@ -6,11 +6,9 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { BoundTarget, SchemaMetadata } from '@angular/compiler';
-import ts from 'typescript';
 import { DomSchemaChecker } from '../dom';
 import { OutOfBandDiagnosticRecorder } from '../oob';
-import { TypeCheckableDirectiveMeta, TypeCheckId } from '../../api';
-import { PipeMeta } from '../../../metadata';
+import { TypeCheckId, TcbDirectiveMetadata, TcbPipeMetadata } from '../../api';
 import { Environment } from '../environment';
 /**
  * Controls how generics for the component context class will be handled during TCB generation.
@@ -49,19 +47,19 @@ export declare class Context {
     readonly domSchemaChecker: DomSchemaChecker;
     readonly oobRecorder: OutOfBandDiagnosticRecorder;
     readonly id: TypeCheckId;
-    readonly boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
+    readonly boundTarget: BoundTarget<TcbDirectiveMetadata>;
     private pipes;
     readonly schemas: SchemaMetadata[];
     readonly hostIsStandalone: boolean;
     readonly hostPreserveWhitespaces: boolean;
     private nextId;
-    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TypeCheckId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, PipeMeta> | null, schemas: SchemaMetadata[], hostIsStandalone: boolean, hostPreserveWhitespaces: boolean);
+    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TypeCheckId, boundTarget: BoundTarget<TcbDirectiveMetadata>, pipes: Map<string, TcbPipeMetadata> | null, schemas: SchemaMetadata[], hostIsStandalone: boolean, hostPreserveWhitespaces: boolean);
     /**
      * Allocate a new variable name for use within the `Context`.
      *
      * Currently this uses a monotonically increasing counter, but in the future the variable name
      * might change depending on the type of data being stored.
      */
-    allocateId(): ts.Identifier;
-    getPipeByName(name: string): PipeMeta | null;
+    allocateId(): string;
+    getPipeByName(name: string): TcbPipeMetadata | null;
 }