@angular/compiler-cli 22.0.0-next.3 → 22.0.0-next.5

package/linker/src/file_linker/linker_environment.d.ts

@@ -12,14 +12,14 @@ import { AstFactory } from '../../../src/ngtsc/translator';
 import { AstHost } from '../ast/ast_host';
 import { LinkerOptions } from './linker_options';
 import { Translator } from './translator';
-export declare class LinkerEnvironment<TStatement, TExpression> {
+export declare class LinkerEnvironment<TStatement, TExpression, TType> {
     readonly fileSystem: ReadonlyFileSystem;
     readonly logger: Logger;
     readonly host: AstHost<TExpression>;
-    readonly factory: AstFactory<TStatement, TExpression>;
+    readonly factory: AstFactory<TStatement, TExpression, TType>;
     readonly options: LinkerOptions;
-    readonly translator: Translator<TStatement, TExpression>;
+    readonly translator: Translator<TStatement, TExpression, TType>;
     readonly sourceFileLoader: SourceFileLoader | null;
     private constructor();
-    static create<TStatement, TExpression>(fileSystem: ReadonlyFileSystem, logger: Logger, host: AstHost<TExpression>, factory: AstFactory<TStatement, TExpression>, options: Partial<LinkerOptions>): LinkerEnvironment<TStatement, TExpression>;
+    static create<TStatement, TExpression, TType>(fileSystem: ReadonlyFileSystem, logger: Logger, host: AstHost<TExpression>, factory: AstFactory<TStatement, TExpression, TType>, options: Partial<LinkerOptions>): LinkerEnvironment<TStatement, TExpression, TType>;
 }

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

@@ -8,8 +8,8 @@
 import { ConstantPool, R3PartialDeclaration } from '@angular/compiler';
 import { AstObject } from '../../ast/ast_value';
 import { GetSourceFileFn } from '../get_source_file';
-import { LinkedDefinition, PartialLinker } from './partial_linker';
 import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system/src/types';
+import { LinkedDefinition, PartialLinker } from './partial_linker';
 /**
  * A `PartialLinker` that is designed to process `ɵɵngDeclareComponent()` call expressions.
  */

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

@@ -48,7 +48,7 @@ export interface LinkerRange<TExpression> {
  * `minVersion` of the partial-declaration should be updated, the new linker implementation should
  * be added to the end of the collection, and the version of the previous linker should be updated.
  */
-export declare function createLinkerMap<TStatement, TExpression>(environment: LinkerEnvironment<TStatement, TExpression>, sourceUrl: AbsoluteFsPath, code: string): Map<string, LinkerRange<TExpression>[]>;
+export declare function createLinkerMap<TStatement, TExpression, TType>(environment: LinkerEnvironment<TStatement, TExpression, TType>, sourceUrl: AbsoluteFsPath, code: string): Map<string, LinkerRange<TExpression>[]>;
 /**
  * A helper that selects the appropriate `PartialLinker` for a given declaration.
  *

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 = "22.0.0-next.3";
+export declare const PLACEHOLDER_VERSION = "22.0.0-next.5";
 export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
 /**
  * Parses the value of an enum from the AST value's symbol name.

package/linker/src/file_linker/translator.d.ts

@@ -13,9 +13,9 @@ import { AstFactory } from '../../../src/ngtsc/translator/src/api/ast_factory';
  * Generic translator helper class, which exposes methods for translating expressions and
  * statements.
  */
-export declare class Translator<TStatement, TExpression> {
+export declare class Translator<TStatement, TExpression, TType> {
     private factory;
-    constructor(factory: AstFactory<TStatement, TExpression>);
+    constructor(factory: AstFactory<TStatement, TExpression, TType>);
     /**
      * Translate the given output AST in the context of an expression.
      */

package/linker/src/linker_import_generator.d.ts

@@ -14,10 +14,10 @@ import { AstFactory, ImportGenerator, ImportRequest } from '../../src/ngtsc/tran
  * must be achieved by property access on an `ng` namespace identifier, which is passed in via the
  * constructor.
  */
-export declare class LinkerImportGenerator<TStatement, TExpression> implements ImportGenerator<null, TExpression> {
+export declare class LinkerImportGenerator<TStatement, TExpression, TType> implements ImportGenerator<null, TExpression> {
     private factory;
     private ngImport;
-    constructor(factory: AstFactory<TStatement, TExpression>, ngImport: TExpression);
+    constructor(factory: AstFactory<TStatement, TExpression, TType>, ngImport: TExpression);
     addImport(request: ImportRequest<null>): TExpression;
     private assertModuleName;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "22.0.0-next.3",
+  "version": "22.0.0-next.5",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -40,10 +40,10 @@
     "yargs": "^18.0.0"
   },
   "devDependencies": {
-    "typescript": "5.9.3"
+    "typescript": "6.0.2"
   },
   "peerDependencies": {
-    "@angular/compiler": "22.0.0-next.3",
+    "@angular/compiler": "22.0.0-next.5",
     "typescript": ">=5.9 <6.1"
   },
   "peerDependenciesMeta": {

package/private/hybrid_analysis.d.ts

@@ -6,13 +6,13 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 export { generateTypeCheckBlock } from '../src/ngtsc/typecheck/src/type_check_block';
-export type { TypeCheckingConfig, TcbComponentMetadata, TcbTypeCheckBlockMetadata, TcbTypeParameter, TypeCheckId, TcbDirectiveMetadata, TemplateDiagnostic, TcbReferenceMetadata, SourceMapping, } from '../src/ngtsc/typecheck/api';
+export type { TypeCheckingConfig, TcbComponentMetadata, TcbTypeCheckBlockMetadata, TcbTypeParameter, TypeCheckId, TcbDirectiveMetadata, TemplateDiagnostic, TcbReferenceMetadata, SourceMapping, OutOfBandDiagnosticRecorder, OutOfBadDiagnosticCategory, } from '../src/ngtsc/typecheck/api';
 export { DomSchemaChecker, RegistryDomSchemaChecker } from '../src/ngtsc/typecheck/src/dom';
 export { Environment } from '../src/ngtsc/typecheck/src/environment';
-export { OutOfBandDiagnosticRecorder } from '../src/ngtsc/typecheck/src/oob';
 export { TcbGenericContextBehavior } from '../src/ngtsc/typecheck/src/ops/context';
 export { ImportManager } from '../src/ngtsc/translator';
 export type { ReferenceEmitter } from '../src/ngtsc/imports';
 export type { ReflectionHost, ClassDeclaration } from '../src/ngtsc/reflection';
 export { ClassPropertyMapping } from '../src/ngtsc/metadata/src/property_mapping';
 export type { TypeCheckSourceResolver } from '../src/ngtsc/typecheck/src/tcb_util';
+export { createHostElement, type SourceNode, type StaticSourceNode, type HostObjectLiteralBinding, type HostListenerDecorator, type HostBindingDecorator, } from '../src/ngtsc/typecheck/src/host_bindings';

package/src/ngtsc/annotations/directive/src/shared.d.ts

@@ -13,12 +13,14 @@ import { DynamicValue, PartialEvaluator } from '../../../partial_evaluator';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
 import { CompilationMode } from '../../../transform';
 import { ReferencesRegistry, UndecoratedMetadataExtractor } from '../../common';
+import { HostObjectLiteralBinding, HostListenerDecorator, HostBindingDecorator } from '../../../typecheck/src/host_bindings';
 type QueryDecoratorName = 'ViewChild' | 'ViewChildren' | 'ContentChild' | 'ContentChildren';
 export declare const queryDecoratorNames: QueryDecoratorName[];
 export interface HostBindingNodes {
-    literal: ts.ObjectLiteralExpression | null;
-    bindingDecorators: Set<ts.Decorator>;
-    listenerDecorators: Set<ts.Decorator>;
+    hostObjectLiteralBindings: HostObjectLiteralBinding[];
+    hostBindingDecorators: HostBindingDecorator[];
+    hostListenerDecorators: HostListenerDecorator[];
+    rawNodes: ts.Node[];
 }
 /**
  * Helper function to extract metadata from a `Directive` or `Component`. `Directive`s without a

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

@@ -93,7 +93,7 @@ export interface TypeCheckingOptions {
      *
      * This flag is a superset of the deprecated `fullTemplateTypeCheck` option.
      *
-     * Defaults to `false`, even if "fullTemplateTypeCheck" is `true`.
+     * Defaults to `true`
      */
     strictTemplates?: boolean;
     /**

package/src/ngtsc/core/src/compiler.d.ts

@@ -10,7 +10,7 @@ import { DocEntry } from '../../docs';
 import { AbsoluteFsPath } from '../../file_system';
 import { IncrementalBuildStrategy, IncrementalCompilation, IncrementalState } from '../../incremental';
 import { IndexedComponent } from '../../indexer';
-import { DirectiveResources, DirectiveMeta, PipeMeta } from '../../metadata';
+import { DirectiveMeta, DirectiveResources, PipeMeta } from '../../metadata';
 import { ActivePerfRecorder } from '../../perf';
 import { ProgramDriver } from '../../program_driver';
 import { DeclarationNode } from '../../reflection';
@@ -263,6 +263,11 @@ export declare class NgCompiler {
     private ensureAnalyzed;
     private analyzeSync;
     private resolveCompilation;
+    /**
+     * strictTemplate is `true` by default.
+     * Explicit opt-out is required to disable strictness
+     */
+    private get strictTemplates();
     private get fullTemplateTypeCheck();
     private getTypeCheckingConfig;
     private getTemplateDiagnostics;

package/src/ngtsc/diagnostics/src/error_code.d.ts

@@ -371,6 +371,10 @@ export declare enum ErrorCode {
     DEFER_TRIGGER_MISCONFIGURATION = 8021,
     /** Raised when the user has an unsupported binding on a `FormField` directive. */
     FORM_FIELD_UNSUPPORTED_BINDING = 8022,
+    /**
+     * Raised when multiple components in the compilation scope match a given element in a template.
+     */
+    MULTIPLE_MATCHING_COMPONENTS = 8023,
     /**
      * A two way binding in a template has an incorrect syntax,
      * parentheses outside brackets. For example:

package/src/ngtsc/file_system/testing/index.d.ts

@@ -9,4 +9,4 @@ export { Folder, MockFileSystem } from './src/mock_file_system';
 export { MockFileSystemNative } from './src/mock_file_system_native';
 export { MockFileSystemPosix } from './src/mock_file_system_posix';
 export { MockFileSystemWindows } from './src/mock_file_system_windows';
-export { initMockFileSystem, runInEachFileSystem, TestFile } from './src/test_helper';
+export { initMockFileSystem, lockMockFileSystem, runInEachFileSystem, TestFile, } from './src/test_helper';

package/src/ngtsc/file_system/testing/src/test_helper.d.ts

@@ -13,4 +13,5 @@ export interface RunInEachFileSystemFn {
     osX(callback: (os: string) => void): void;
 }
 export declare const runInEachFileSystem: RunInEachFileSystemFn;
+export declare function lockMockFileSystem(): void;
 export declare function initMockFileSystem(os: string, cwd?: AbsoluteFsPath): MockFileSystem;

package/src/ngtsc/translator/src/api/ast_factory.d.ts

@@ -12,7 +12,7 @@
  * It is up to the caller to do this - e.g. only call `createTaggedTemplate()` or pass `let`|`const`
  * to `createVariableDeclaration()` if the final JS will allow it.
  */
-export interface AstFactory<TStatement, TExpression> {
+export interface AstFactory<TStatement, TExpression, TType> {
     /**
      * Attach the `leadingComments` to the given `statement` node.
      *
@@ -84,7 +84,7 @@ export interface AstFactory<TStatement, TExpression> {
      * @param parameters the names of the function's parameters.
      * @param body a statement (or a block of statements) that are the body of the function.
      */
-    createFunctionDeclaration(functionName: string, parameters: string[], body: TStatement): TStatement;
+    createFunctionDeclaration(functionName: string, parameters: Parameter<TType>[], body: TStatement): TStatement;
     /**
      * Create an expression that represents a function
      * (e.g. `function foo(param1, param2) { stmt; }`).
@@ -93,7 +93,7 @@ export interface AstFactory<TStatement, TExpression> {
      * @param parameters the names of the function's parameters.
      * @param body a statement (or a block of statements) that are the body of the function.
      */
-    createFunctionExpression(functionName: string | null, parameters: string[], body: TStatement): TExpression;
+    createFunctionExpression(functionName: string | null, parameters: Parameter<TType>[], body: TStatement): TExpression;
     /**
      * Create an expression that represents an arrow function
      * (e.g. `(param1, param2) => body`).
@@ -101,7 +101,7 @@ export interface AstFactory<TStatement, TExpression> {
      * @param parameters the names of the function's parameters.
      * @param body an expression or block of statements that are the body of the function.
      */
-    createArrowFunctionExpression(parameters: string[], body: TExpression | TStatement): TExpression;
+    createArrowFunctionExpression(parameters: Parameter<TType>[], body: TExpression | TStatement): TExpression;
     /**
      * Creates an expression that represents a dynamic import
      * (e.g. `import('./some/path')`)
@@ -216,9 +216,9 @@ export interface AstFactory<TStatement, TExpression> {
      *
      * @param variableName the name of the variable.
      * @param initializer if not `null` then this expression is assigned to the declared variable.
-     * @param type whether this variable should be declared as `var`, `let` or `const`.
+     * @param variableType whether this variable should be declared as `var`, `let` or `const`.
      */
-    createVariableDeclaration(variableName: string, initializer: TExpression | null, type: VariableDeclarationType): TStatement;
+    createVariableDeclaration(variableName: string, initializer: TExpression | null, variableType: VariableDeclarationType, type: TType | null): TStatement;
     /**
      * Create a regular expression literal (e.g. `/\d+/g`).
      *
@@ -232,6 +232,32 @@ export interface AstFactory<TStatement, TExpression> {
      * @param target Expression of the spread element.
      */
     createSpreadElement(expression: TExpression): TExpression;
+    /**
+     * Create a type node for a built-in type.
+     * @param type Type that should be created.
+     */
+    createBuiltInType(type: BuiltInType): TType;
+    /**
+     * Create an expression type.
+     * @param expression Expression to be turned into a type node.
+     * @param typeParams Type parameters for the expression.
+     */
+    createExpressionType(expression: TExpression, typeParams: TType[] | null): TType;
+    /**
+     * Create an array type.
+     * @param elementType Type of the array elements.
+     */
+    createArrayType(elementType: TType): TType;
+    /**
+     * Create a map type.
+     * @param valueType Type of the map values.
+     */
+    createMapType(valueType: TType): TType;
+    /**
+     * Forward a transplanted type.
+     * @param type Type to be transplanted, if supported.
+     */
+    transplantType(type: TType): TType;
     /**
      * Attach a source map range to the given node.
      *
@@ -249,6 +275,12 @@ export type VariableDeclarationType = 'const' | 'let' | 'var';
  * The unary operators supported by the `AstFactory`.
  */
 export type UnaryOperator = '+' | '-' | '!';
+/** Supported built-in types. */
+export type BuiltInType = 'any' | 'boolean' | 'number' | 'string' | 'function' | 'never' | 'unknown';
+export interface Parameter<TType> {
+    name: string;
+    type: TType | null;
+}
 /**
  * The binary operators supported by the `AstFactory`.
  */

package/src/ngtsc/translator/src/translator.d.ts

@@ -16,14 +16,14 @@ export interface TranslatorOptions<TExpression> {
     recordWrappedNode?: RecordWrappedNodeFn<TExpression>;
     annotateForClosureCompiler?: boolean;
 }
-export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression> implements o.ExpressionVisitor, o.StatementVisitor {
+export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression, TType> implements o.ExpressionVisitor, o.StatementVisitor, o.TypeVisitor {
     private factory;
     private imports;
     private contextFile;
     private downlevelTaggedTemplates;
     private downlevelVariableDeclarations;
     private recordWrappedNode;
-    constructor(factory: AstFactory<TStatement, TExpression>, imports: ImportGenerator<TFile, TExpression>, contextFile: TFile, options: TranslatorOptions<TExpression>);
+    constructor(factory: AstFactory<TStatement, TExpression, TType>, imports: ImportGenerator<TFile, TExpression>, contextFile: TFile, options: TranslatorOptions<TExpression>);
     visitDeclareVarStmt(stmt: o.DeclareVarStmt, context: Context): TStatement;
     visitDeclareFunctionStmt(stmt: o.DeclareFunctionStmt, context: Context): TStatement;
     visitExpressionStmt(stmt: o.ExpressionStatement, context: Context): TStatement;
@@ -37,6 +37,11 @@ export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression>
     visitLiteralExpr(ast: o.LiteralExpr, _context: Context): TExpression;
     visitRegularExpressionLiteral(ast: o.RegularExpressionLiteralExpr, context: any): TExpression;
     visitLocalizedString(ast: o.LocalizedString, context: Context): TExpression;
+    visitBuiltinType(ast: o.BuiltinType): TType | null;
+    visitExpressionType(ast: o.ExpressionType, context: Context): TType;
+    visitArrayType(ast: o.ArrayType, context: Context): TType;
+    visitMapType(ast: o.MapType, context: Context): TType;
+    visitTransplantedType(type: o.TransplantedType<TType>): TType;
     private createTaggedTemplateExpression;
     /**
      * Translate the tagged template literal into a call that is compatible with ES5, using the
@@ -66,4 +71,5 @@ export declare class ExpressionTranslatorVisitor<TFile, TStatement, TExpression>
     private setSourceMapRange;
     private attachComments;
     private getTemplateLiteralFromAst;
+    private translateParams;
 }

package/src/ngtsc/translator/src/typescript_ast_factory.d.ts

@@ -6,11 +6,11 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import ts from 'typescript';
-import { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
+import { AstFactory, BinaryOperator, BuiltInType, LeadingComment, ObjectLiteralProperty, Parameter, SourceMapRange, TemplateLiteral, UnaryOperator, VariableDeclarationType } from './api/ast_factory';
 /**
  * A TypeScript flavoured implementation of the AstFactory.
  */
-export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Expression> {
+export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts.Expression, ts.TypeNode> {
     private annotateForClosureCompiler;
     private externalSourceFiles;
     private readonly UNARY_OPERATORS;
@@ -27,9 +27,10 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     createElementAccess: (expression: ts.Expression, index: number | ts.Expression) => ts.ElementAccessExpression;
     createExpressionStatement: (expression: ts.Expression) => ts.ExpressionStatement;
     createDynamicImport(url: string | ts.Expression): ts.CallExpression;
-    createFunctionDeclaration(functionName: string, parameters: string[], body: ts.Statement): ts.Statement;
-    createFunctionExpression(functionName: string | null, parameters: string[], body: ts.Statement): ts.Expression;
-    createArrowFunctionExpression(parameters: string[], body: ts.Statement | ts.Expression): ts.Expression;
+    createFunctionDeclaration(functionName: string, parameters: Parameter<ts.TypeNode>[], body: ts.Statement): ts.Statement;
+    createFunctionExpression(functionName: string | null, parameters: Parameter<ts.TypeNode>[], body: ts.Statement): ts.Expression;
+    createArrowFunctionExpression(parameters: Parameter<ts.TypeNode>[], body: ts.Statement | ts.Expression): ts.Expression;
+    private createParameter;
     createIdentifier: (text: string) => ts.Identifier;
     createIfStatement(condition: ts.Expression, thenStatement: ts.Statement, elseStatement: ts.Statement | null): ts.Statement;
     createLiteral(value: string | number | boolean | null | undefined): ts.Expression;
@@ -45,9 +46,14 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     createTypeOfExpression: (expression: ts.Expression) => ts.TypeOfExpression;
     createVoidExpression: (expression: ts.Expression) => ts.VoidExpression;
     createUnaryExpression(operator: UnaryOperator, operand: ts.Expression): ts.Expression;
-    createVariableDeclaration(variableName: string, initializer: ts.Expression | null, type: VariableDeclarationType): ts.Statement;
+    createVariableDeclaration(variableName: string, initializer: ts.Expression | null, variableType: VariableDeclarationType, type: ts.TypeNode | null): ts.Statement;
     createRegularExpressionLiteral(body: string, flags: string | null): ts.Expression;
     setSourceMapRange<T extends ts.Node>(node: T, sourceMapRange: SourceMapRange | null): T;
+    createBuiltInType(type: BuiltInType): ts.TypeNode;
+    createExpressionType(expression: ts.Expression, typeParams: ts.TypeNode[] | null): ts.TypeNode;
+    createArrayType(elementType: ts.TypeNode): ts.TypeNode;
+    createMapType(valueType: ts.TypeNode): ts.TypeNode;
+    transplantType(type: ts.TypeNode): ts.TypeNode;
 }
 export declare function createTemplateMiddle(cooked: string, raw: string): ts.TemplateMiddle;
 export declare function createTemplateTail(cooked: string, raw: string): ts.TemplateTail;

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

@@ -64,7 +64,7 @@ export interface TcbDirectiveMetadata {
     typeParameters: TcbTypeParameter[] | null;
     inputs: ClassPropertyMapping<TcbInputMapping>;
     outputs: ClassPropertyMapping;
-    hasRequiresInlineTypeCtor: boolean;
+    requiresInlineTypeCtor: boolean;
     ngTemplateGuards: TemplateGuardMeta[];
     hasNgTemplateContextGuard: boolean;
     hasNgFieldDirective: boolean;
@@ -79,6 +79,7 @@ export interface TcbDirectiveMetadata {
 export interface TcbComponentMetadata {
     ref: TcbReferenceMetadata;
     typeParameters: TcbTypeParameter[] | null;
+    typeArguments: string[] | null;
 }
 export interface TcbTypeCheckBlockMetadata {
     id: TypeCheckId;

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

@@ -11,3 +11,4 @@ export * from './completion';
 export * from './context';
 export * from './scope';
 export * from './symbols';
+export * from './oob';

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

@@ -0,0 +1,140 @@
+/**
+ * @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 { AST, BindingPipe, PropertyRead, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstComponent, TmplAstDirective, TmplAstElement, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty, TmplAstHoverDeferredTrigger, TmplAstIfBlockBranch, TmplAstInteractionDeferredTrigger, TmplAstLetDeclaration, TmplAstReference, TmplAstSwitchBlockCase, TmplAstTemplate, TmplAstTextAttribute, TmplAstVariable, TmplAstViewportDeferredTrigger } from '@angular/compiler';
+import { TcbDirectiveMetadata, TypeCheckId } from './api';
+/** Categories of diagnostics that can be reported by a `OutOfBandDiagnosticRecorder`. */
+export declare enum OutOfBadDiagnosticCategory {
+    Error = 0,
+    Warning = 1
+}
+/**
+ * Collects diagnostics on problems which occur in the template which aren't directly sourced
+ * from type check blocks.
+ *
+ * During the creation of a type check block, the template is traversed and the
+ * `OutOfBandDiagnosticRecorder` is called to record cases when a correct interpretation for the
+ * template cannot be found. These operations create diagnostics which are stored by the
+ * recorder for later display.
+ */
+export interface OutOfBandDiagnosticRecorder<T> {
+    readonly diagnostics: ReadonlyArray<T>;
+    /**
+     * Reports a `#ref="target"` expression in the template for which a target directive could not be
+     * found.
+     *
+     * @param id the type-checking ID of the template which contains the broken reference.
+     * @param ref the `TmplAstReference` which could not be matched to a directive.
+     */
+    missingReferenceTarget(id: TypeCheckId, ref: TmplAstReference): void;
+    /**
+     * Reports usage of a `| pipe` expression in the template for which the named pipe could not be
+     * found.
+     *
+     * @param id the type-checking ID of the template which contains the unknown pipe.
+     * @param ast the `BindingPipe` invocation of the pipe which could not be found.
+     * @param isStandalone whether the host component is standalone.
+     */
+    missingPipe(id: TypeCheckId, ast: BindingPipe, isStandalone: boolean): void;
+    /**
+     * Reports usage of a pipe imported via `@Component.deferredImports` outside
+     * of a `@defer` block in a template.
+     *
+     * @param id the type-checking ID of the template which contains the unknown pipe.
+     * @param ast the `BindingPipe` invocation of the pipe which could not be found.
+     */
+    deferredPipeUsedEagerly(id: TypeCheckId, ast: BindingPipe): void;
+    /**
+     * Reports usage of a component/directive imported via `@Component.deferredImports` outside
+     * of a `@defer` block in a template.
+     *
+     * @param id the type-checking ID of the template which contains the unknown pipe.
+     * @param element the element which hosts a component that was defer-loaded.
+     */
+    deferredComponentUsedEagerly(id: TypeCheckId, element: TmplAstElement): void;
+    /**
+     * Reports a duplicate declaration of a template variable.
+     *
+     * @param id the type-checking ID of the template which contains the duplicate
+     * declaration.
+     * @param variable the `TmplAstVariable` which duplicates a previously declared variable.
+     * @param firstDecl the first variable declaration which uses the same name as `variable`.
+     */
+    duplicateTemplateVar(id: TypeCheckId, variable: TmplAstVariable, firstDecl: TmplAstVariable): void;
+    /**
+     * Report a warning when structural directives support context guards, but the current
+     * type-checking configuration prohibits their usage.
+     */
+    suboptimalTypeInference(id: TypeCheckId, variables: TmplAstVariable[]): void;
+    /**
+     * Reports a split two way binding error message.
+     */
+    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;
+    /**
+     * Reports accesses of properties that aren't available in a `for` block's tracking expression.
+     */
+    illegalForLoopTrackAccess(id: TypeCheckId, block: TmplAstForLoopBlock, access: PropertyRead): void;
+    /**
+     * Reports deferred triggers that cannot access the element they're referring to.
+     */
+    inaccessibleDeferredTriggerElement(id: TypeCheckId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
+    /**
+     * Reports cases where control flow nodes prevent content projection.
+     */
+    controlFlowPreventingContentProjection(id: TypeCheckId, category: OutOfBadDiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstSwitchBlockCase | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
+    /** Reports cases where users are writing to `@let` declarations. */
+    illegalWriteToLetDeclaration(id: TypeCheckId, node: AST, target: TmplAstLetDeclaration): void;
+    /** Reports cases where users are accessing an `@let` before it is defined.. */
+    letUsedBeforeDefinition(id: TypeCheckId, node: PropertyRead, target: TmplAstLetDeclaration): void;
+    /**
+     * Reports a `@let` declaration that conflicts with another symbol in the same scope.
+     *
+     * @param id the type-checking ID of the template which contains the declaration.
+     * @param current the `TmplAstLetDeclaration` which is invalid.
+     */
+    conflictingDeclaration(id: TypeCheckId, current: TmplAstLetDeclaration): void;
+    /**
+     * Reports that a named template dependency (e.g. `<Missing/>`) is not available.
+     * @param id Type checking ID of the template in which the dependency is declared.
+     * @param node Node that declares the dependency.
+     */
+    missingNamedTemplateDependency(id: TypeCheckId, node: TmplAstComponent | TmplAstDirective): void;
+    /**
+     * Reports that a templace dependency of the wrong kind has been referenced at a specific position
+     * (e.g. `<SomeDirective/>`).
+     * @param id Type checking ID of the template in which the dependency is declared.
+     * @param node Node that declares the dependency.
+     */
+    incorrectTemplateDependencyType(id: TypeCheckId, node: TmplAstComponent | TmplAstDirective): void;
+    /**
+     * Reports a binding inside directive syntax that does not match any of the inputs/outputs of
+     * the directive.
+     * @param id Type checking ID of the template in which the directive was defined.
+     * @param directive Directive that contains the binding.
+     * @param node Node declaring the binding.
+     */
+    unclaimedDirectiveBinding(id: TypeCheckId, directive: TmplAstDirective, node: TmplAstBoundAttribute | TmplAstTextAttribute | TmplAstBoundEvent): void;
+    /**
+     * Reports that an implicit deferred trigger is set on a block that does not have a placeholder.
+     */
+    deferImplicitTriggerMissingPlaceholder(id: TypeCheckId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
+    /**
+     * Reports that an implicit deferred trigger is set on a block whose placeholder is not set up
+     * correctly (e.g. more than one root node).
+     */
+    deferImplicitTriggerInvalidPlaceholder(id: TypeCheckId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
+    /**
+     * Reports an unsupported binding on a form `FormField` node.
+     */
+    formFieldUnsupportedBinding(id: TypeCheckId, node: TmplAstBoundAttribute | TmplAstTextAttribute): void;
+    /**
+     * Reports that multiple components in the compilation scope match a given element.
+     */
+    multipleMatchingComponents(id: TypeCheckId, element: TmplAstElement, componentNames: string[]): void;
+}

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

@@ -12,9 +12,8 @@ import { Reference, ReferenceEmitter } from '../../imports';
 import { PerfRecorder } from '../../perf';
 import { FileUpdate } from '../../program_driver';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
-import { HostBindingsContext, TemplateDiagnostic, TypeCheckId, SourceMapping, TypeCheckableDirectiveMeta, TypeCheckContext, TypeCheckingConfig, TypeCtorMetadata, TemplateContext } from '../api';
+import { HostBindingsContext, TemplateDiagnostic, TypeCheckId, SourceMapping, TypeCheckableDirectiveMeta, TypeCheckContext, TypeCheckingConfig, TypeCtorMetadata, TemplateContext, OutOfBandDiagnosticRecorder } from '../api';
 import { DomSchemaChecker } from './dom';
-import { OutOfBandDiagnosticRecorder } from './oob';
 import { DirectiveSourceManager } from './source';
 import { TypeCheckFile } from './type_check_file';
 export interface ShimTypeCheckingData {
@@ -82,7 +81,7 @@ export interface PendingShimData {
     /**
      * Recorder for out-of-band diagnostics which are raised during generation.
      */
-    oobRecorder: OutOfBandDiagnosticRecorder;
+    oobRecorder: OutOfBandDiagnosticRecorder<TemplateDiagnostic>;
     /**
      * The `DomSchemaChecker` in use for this template, which records any schema-related diagnostics.
      */
@@ -95,6 +94,10 @@ export interface PendingShimData {
      * Map of `TypeCheckId` to information collected about the template as it's ingested.
      */
     data: Map<TypeCheckId, TypeCheckData>;
+    /**
+     * Diagnostics produced during shim creation.
+     */
+    shimDiagnostics: TemplateDiagnostic[] | null;
 }
 /**
  * Adapts the `TypeCheckContextImpl` to the larger template type-checking system.

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

@@ -5,20 +5,62 @@
  * 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 { TmplAstHostElement } from '@angular/compiler';
+import { ParseSourceSpan, TmplAstHostElement } from '@angular/compiler';
 import ts from 'typescript';
-import { ClassDeclaration } from '../../reflection';
+/** Represents information extracted from the source AST. */
+export type SourceNode = StaticSourceNode | {
+    kind: 'unspecified';
+    sourceSpan: ParseSourceSpan;
+};
+/** A `SourceNode` which represents a static expression. */
+export interface StaticSourceNode {
+    kind: 'string' | 'identifier';
+    /** Raw source code of the node (e.g. strings include the quotes). */
+    source: string;
+    /** Actual text of the node (e.g. value inside the quotes in strings). */
+    text: string;
+    /** Location information about the node. */
+    sourceSpan: ParseSourceSpan;
+}
+/** A single binding inside the `host` object of a directive. */
+export interface HostObjectLiteralBinding {
+    /** Node representing the key of the binding. */
+    key: SourceNode;
+    /** Node representing the value of the binding. */
+    value: SourceNode;
+    /** Location information about the entire binding. */
+    sourceSpan: ParseSourceSpan;
+}
+/** A single binding declared by a `@HostListener` decorator on a class member. */
+export interface HostListenerDecorator {
+    /** Node declaring the name of the event (e.g. first argument of `@HostListener`). */
+    eventName: SourceNode | null;
+    /** Node representing the name of the member that was decorated. */
+    memberName: StaticSourceNode;
+    /** Location information about the member that the decorator is set on. */
+    memberSpan: ParseSourceSpan;
+    /** Arguments passed to the event. */
+    arguments: SourceNode[];
+    /** Location information about the decorator. */
+    decoratorSpan: ParseSourceSpan;
+}
+/** A single binding declared by the `@HostBinding` decorator on a class member. */
+export interface HostBindingDecorator {
+    /** Node representing the name of the member that was decorated. */
+    memberName: StaticSourceNode;
+    /** Location information about the member that the decorator is set on. */
+    memberSpan: ParseSourceSpan;
+    /** Arguments passed into the decorator */
+    arguments: SourceNode[];
+    /** Location information about the decorator. */
+    decoratorSpan: ParseSourceSpan;
+}
 /**
  * Creates an AST node that represents the host element of a directive.
  * Can return null if there are no valid bindings to be checked.
- * @param type Whether the host element is for a directive or a component.
- * @param selector Selector of the directive.
- * @param sourceNode Class declaration for the directive.
- * @param literal `host` object literal from the decorator.
- * @param bindingDecorators `HostBinding` decorators discovered on the node.
- * @param listenerDecorators `HostListener` decorators discovered on the node.
+ * @param meta Metadata used to construct the host element.
  */
-export declare function createHostElement(type: 'component' | 'directive', selector: string | null, sourceNode: ClassDeclaration, literal: ts.ObjectLiteralExpression | null, bindingDecorators: Iterable<ts.Decorator>, listenerDecorators: Iterable<ts.Decorator>): TmplAstHostElement | null;
+export declare function createHostElement(type: 'component' | 'directive', selector: string | null, nameSpan: ParseSourceSpan, hostObjectLiteralBindings: HostObjectLiteralBinding[], hostBindingDecorators: HostBindingDecorator[], hostListenerDecorators: HostListenerDecorator[]): TmplAstHostElement | null;
 /**
  * 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.