@angular/compiler-cli 20.0.0-next.2 → 20.0.0-next.4

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 = "20.0.0-next.2";
+export declare const PLACEHOLDER_VERSION = "20.0.0-next.4";
 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": "20.0.0-next.2",
+  "version": "20.0.0-next.4",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -42,7 +42,7 @@
     }
   },
   "dependencies": {
-    "@babel/core": "7.26.9",
+    "@babel/core": "7.26.10",
     "@jridgewell/sourcemap-codec": "^1.4.14",
     "reflect-metadata": "^0.2.0",
     "chokidar": "^4.0.0",
@@ -52,7 +52,7 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "20.0.0-next.2",
+    "@angular/compiler": "20.0.0-next.4",
     "typescript": ">=5.8 <5.9"
   },
   "repository": {

package/src/ngtsc/annotations/component/src/handler.d.ts

@@ -73,7 +73,8 @@ export declare class ComponentDecoratorHandler implements DecoratorHandler<Decor
     private readonly strictStandalone;
     private readonly enableHmr;
     private readonly implicitStandaloneValue;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, scopeRegistry: LocalModuleScopeRegistry, typeCheckScopeRegistry: TypeCheckScopeRegistry, resourceRegistry: ResourceRegistry, isCore: boolean, strictCtorDeps: boolean, resourceLoader: ResourceLoader, rootDirs: ReadonlyArray<string>, defaultPreserveWhitespaces: boolean, i18nUseExternalIds: boolean, enableI18nLegacyMessageIdFormat: boolean, usePoisonedData: boolean, i18nNormalizeLineEndingsInICUs: boolean, moduleResolver: ModuleResolver, cycleAnalyzer: CycleAnalyzer, cycleHandlingStrategy: CycleHandlingStrategy, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, depTracker: DependencyTracker | null, injectableRegistry: InjectableClassRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, hostDirectivesResolver: HostDirectivesResolver, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, compilationMode: CompilationMode, deferredSymbolTracker: DeferredSymbolTracker, forbidOrphanRendering: boolean, enableBlockSyntax: boolean, enableLetSyntax: boolean, externalRuntimeStyles: boolean, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null, jitDeclarationRegistry: JitDeclarationRegistry, i18nPreserveSignificantWhitespace: boolean, strictStandalone: boolean, enableHmr: boolean, implicitStandaloneValue: boolean);
+    private readonly typeCheckHostBindings;
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, metaReader: MetadataReader, scopeReader: ComponentScopeReader, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>, scopeRegistry: LocalModuleScopeRegistry, typeCheckScopeRegistry: TypeCheckScopeRegistry, resourceRegistry: ResourceRegistry, isCore: boolean, strictCtorDeps: boolean, resourceLoader: ResourceLoader, rootDirs: ReadonlyArray<string>, defaultPreserveWhitespaces: boolean, i18nUseExternalIds: boolean, enableI18nLegacyMessageIdFormat: boolean, usePoisonedData: boolean, i18nNormalizeLineEndingsInICUs: boolean, moduleResolver: ModuleResolver, cycleAnalyzer: CycleAnalyzer, cycleHandlingStrategy: CycleHandlingStrategy, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, depTracker: DependencyTracker | null, injectableRegistry: InjectableClassRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, hostDirectivesResolver: HostDirectivesResolver, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, compilationMode: CompilationMode, deferredSymbolTracker: DeferredSymbolTracker, forbidOrphanRendering: boolean, enableBlockSyntax: boolean, enableLetSyntax: boolean, externalRuntimeStyles: boolean, localCompilationExtraImportsTracker: LocalCompilationExtraImportsTracker | null, jitDeclarationRegistry: JitDeclarationRegistry, i18nPreserveSignificantWhitespace: boolean, strictStandalone: boolean, enableHmr: boolean, implicitStandaloneValue: boolean, typeCheckHostBindings: boolean);
     private literalCache;
     private elementSchemaRegistry;
     /**

package/src/ngtsc/annotations/component/src/metadata.d.ts

@@ -12,6 +12,7 @@ import { ClassPropertyMapping, DirectiveResources, DirectiveTypeCheckMeta, HostD
 import { ClassDeclaration } from '../../../reflection';
 import { SubsetOfKeys } from '../../../util/src/typescript';
 import { ParsedTemplateWithSource, StyleUrlMeta } from './resources';
+import { HostBindingNodes } from '../../directive';
 /**
  * These fields of `R3ComponentMetadata` are updated in the `resolve` phase.
  *
@@ -68,6 +69,8 @@ export interface ComponentAnalysisData {
     hostDirectives: HostDirectiveMeta[] | null;
     /** Raw expression that defined the host directives array. Used for diagnostics. */
     rawHostDirectives: ts.Expression | null;
+    /** Raw nodes representing the host bindings of the directive. */
+    hostBindingNodes: HostBindingNodes;
 }
 export interface ComponentResolutionData {
     declarations: R3TemplateDependencyMetadata[];

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

@@ -9,15 +9,17 @@ import { ConstantPool, R3ClassMetadata, R3DirectiveMetadata } from '@angular/com
 import ts from 'typescript';
 import { ImportedSymbolsTracker, Reference, ReferenceEmitter } from '../../../imports';
 import { SemanticDepGraphUpdater } from '../../../incremental/semantic_graph';
-import { ClassPropertyMapping, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping, MetadataReader, MetadataRegistry } from '../../../metadata';
+import { ClassPropertyMapping, DirectiveResources, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping, MetadataReader, MetadataRegistry, ResourceRegistry } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { PerfRecorder } from '../../../perf';
 import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
-import { LocalModuleScopeRegistry } from '../../../scope';
+import { LocalModuleScopeRegistry, TypeCheckScopeRegistry } from '../../../scope';
 import { AnalysisOutput, CompilationMode, CompileResult, DecoratorHandler, DetectResult, HandlerPrecedence, ResolveResult } from '../../../transform';
 import { InjectableClassRegistry, ReferencesRegistry } from '../../common';
+import { HostBindingNodes } from './shared';
 import { DirectiveSymbol } from './symbol';
 import { JitDeclarationRegistry } from '../../common/src/jit_declaration_registry';
+import { TypeCheckContext } from '../../../typecheck/api';
 export interface DirectiveHandlerData {
     baseClass: Reference<ClassDeclaration> | 'dynamic' | null;
     typeCheckMeta: DirectiveTypeCheckMeta;
@@ -32,6 +34,8 @@ export interface DirectiveHandlerData {
     decorator: ts.Decorator | null;
     hostDirectives: HostDirectiveMeta[] | null;
     rawHostDirectives: ts.Expression | null;
+    hostBindingNodes: HostBindingNodes;
+    resources: DirectiveResources;
 }
 export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decorator | null, DirectiveHandlerData, DirectiveSymbol, unknown> {
     private reflector;
@@ -49,17 +53,22 @@ export declare class DirectiveDecoratorHandler implements DecoratorHandler<Decor
     private perf;
     private importTracker;
     private includeClassMetadata;
+    private typeCheckScopeRegistry;
     private readonly compilationMode;
     private readonly jitDeclarationRegistry;
+    private readonly resourceRegistry;
     private readonly strictStandalone;
     private readonly implicitStandaloneValue;
-    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, isCore: boolean, strictCtorDeps: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, compilationMode: CompilationMode, jitDeclarationRegistry: JitDeclarationRegistry, strictStandalone: boolean, implicitStandaloneValue: boolean);
+    private readonly usePoisonedData;
+    private readonly typeCheckHostBindings;
+    constructor(reflector: ReflectionHost, evaluator: PartialEvaluator, metaRegistry: MetadataRegistry, scopeRegistry: LocalModuleScopeRegistry, metaReader: MetadataReader, injectableRegistry: InjectableClassRegistry, refEmitter: ReferenceEmitter, referencesRegistry: ReferencesRegistry, isCore: boolean, strictCtorDeps: boolean, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, annotateForClosureCompiler: boolean, perf: PerfRecorder, importTracker: ImportedSymbolsTracker, includeClassMetadata: boolean, typeCheckScopeRegistry: TypeCheckScopeRegistry, compilationMode: CompilationMode, jitDeclarationRegistry: JitDeclarationRegistry, resourceRegistry: ResourceRegistry, strictStandalone: boolean, implicitStandaloneValue: boolean, usePoisonedData: boolean, typeCheckHostBindings: boolean);
     readonly precedence = HandlerPrecedence.PRIMARY;
     readonly name = "DirectiveDecoratorHandler";
     detect(node: ClassDeclaration, decorators: Decorator[] | null): DetectResult<Decorator | null> | undefined;
     analyze(node: ClassDeclaration, decorator: Readonly<Decorator | null>): AnalysisOutput<DirectiveHandlerData>;
     symbol(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>): DirectiveSymbol;
     register(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>): void;
+    typeCheck(ctx: TypeCheckContext, node: ClassDeclaration, meta: Readonly<DirectiveHandlerData>): void;
     resolve(node: ClassDeclaration, analysis: DirectiveHandlerData, symbol: DirectiveSymbol): ResolveResult<unknown>;
     compileFull(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, resolution: Readonly<unknown>, pool: ConstantPool): CompileResult[];
     compilePartial(node: ClassDeclaration, analysis: Readonly<DirectiveHandlerData>, resolution: Readonly<unknown>): CompileResult[];

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

@@ -5,16 +5,21 @@
  * 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 { ParsedHostBindings, R3DirectiveMetadata, R3QueryMetadata } from '@angular/compiler';
+import { R3DirectiveMetadata, R3QueryMetadata } from '@angular/compiler';
 import ts from 'typescript';
 import { ImportedSymbolsTracker, Reference, ReferenceEmitter } from '../../../imports';
-import { ClassPropertyMapping, DecoratorInputTransform, HostDirectiveMeta, InputMapping } from '../../../metadata';
+import { ClassPropertyMapping, DecoratorInputTransform, HostDirectiveMeta, InputMapping, Resource } from '../../../metadata';
 import { DynamicValue, PartialEvaluator } from '../../../partial_evaluator';
-import { ClassDeclaration, ClassMember, Decorator, ReflectionHost } from '../../../reflection';
+import { ClassDeclaration, Decorator, ReflectionHost } from '../../../reflection';
 import { CompilationMode } from '../../../transform';
 import { ReferencesRegistry } from '../../common';
 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>;
+}
 /**
  * Helper function to extract metadata from a `Directive` or `Component`. `Directive`s without a
  * selector are allowed to be used for abstract base classes. These abstract directives should not
@@ -31,11 +36,11 @@ export declare function extractDirectiveMetadata(clazz: ClassDeclaration, decora
     hostDirectives: HostDirectiveMeta[] | null;
     rawHostDirectives: ts.Expression | null;
     inputFieldNamesFromMetadataArray: Set<string>;
+    hostBindingNodes: HostBindingNodes;
 } | {
     jitForced: true;
 };
 export declare function extractDecoratorQueryMetadata(exprNode: ts.Node, name: string, args: ReadonlyArray<ts.Expression>, propertyName: string, reflector: ReflectionHost, evaluator: PartialEvaluator): R3QueryMetadata;
-export declare function extractHostBindings(members: ClassMember[], evaluator: PartialEvaluator, coreModule: string | undefined, compilationMode: CompilationMode, metadata?: Map<string, ts.Expression>): ParsedHostBindings;
 export declare function parseDirectiveStyles(directive: Map<string, ts.Expression>, evaluator: PartialEvaluator, compilationMode: CompilationMode): null | string[];
 export declare function parseFieldStringArrayValue(directive: Map<string, ts.Expression>, field: string, evaluator: PartialEvaluator): null | string[];
 /**
@@ -50,4 +55,5 @@ export declare function parseFieldStringArrayValue(directive: Map<string, ts.Exp
  *
  */
 export declare function parseDecoratorInputTransformFunction(clazz: ClassDeclaration, classPropertyName: string, value: DynamicValue | Reference, reflector: ReflectionHost, refEmitter: ReferenceEmitter, compilationMode: CompilationMode): DecoratorInputTransform;
+export declare function extractHostBindingResources(nodes: HostBindingNodes): ReadonlySet<Resource>;
 export {};

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

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import ts from 'typescript';
-import { BazelAndG3Options, DiagnosticOptions, I18nOptions, LegacyNgcOptions, MiscOptions, StrictTemplateOptions, TargetOptions } from './public_options';
+import { BazelAndG3Options, DiagnosticOptions, I18nOptions, LegacyNgcOptions, MiscOptions, TypeCheckingOptions, TargetOptions } from './public_options';
 /**
  * Non-public options which are useful during testing of the compiler.
  */
@@ -53,6 +53,6 @@ export interface InternalOptions {
  *
  * Also includes a few miscellaneous options.
  */
-export interface NgCompilerOptions extends ts.CompilerOptions, LegacyNgcOptions, BazelAndG3Options, DiagnosticOptions, StrictTemplateOptions, TestOnlyOptions, I18nOptions, TargetOptions, InternalOptions, MiscOptions {
+export interface NgCompilerOptions extends ts.CompilerOptions, LegacyNgcOptions, BazelAndG3Options, DiagnosticOptions, TypeCheckingOptions, TestOnlyOptions, I18nOptions, TargetOptions, InternalOptions, MiscOptions {
     [prop: string]: any;
 }

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

@@ -81,11 +81,13 @@ export interface LegacyNgcOptions {
     preserveWhitespaces?: boolean;
 }
 /**
- * Options related to template type-checking and its strictness.
+ * Options related to Angular-specific type-checking and its strictness.
  *
  * @publicApi
  */
-export interface StrictTemplateOptions {
+export interface TypeCheckingOptions {
+    /** Whether type checking of host bindings is enabled. */
+    typeCheckHostBindings?: boolean;
     /**
      * If `true`, implies all template strictness flags below (unless individually disabled).
      *

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

@@ -444,6 +444,10 @@ export declare enum ErrorCode {
      * A symbol referenced in `@Component.imports` isn't being used within the template.
      */
     UNUSED_STANDALONE_IMPORTS = 8113,
+    /**
+     * An expression mixes nullish coalescing and logical and/or without parentheses.
+     */
+    UNPARENTHESIZED_NULLISH_COALESCING = 8114,
     /**
      * The template type-checking engine would need to generate an inline type check block for a
      * component, but the current type-checking environment doesn't support it.

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

@@ -27,5 +27,6 @@ export declare enum ExtendedTemplateDiagnosticName {
     INTERPOLATED_SIGNAL_NOT_INVOKED = "interpolatedSignalNotInvoked",
     CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION = "controlFlowPreventingContentProjection",
     UNUSED_LET_DECLARATION = "unusedLetDeclaration",
-    UNUSED_STANDALONE_IMPORTS = "unusedStandaloneImports"
+    UNUSED_STANDALONE_IMPORTS = "unusedStandaloneImports",
+    UNPARENTHESIZED_NULLISH_COALESCING = "unparenthesizedNullishCoalescing"
 }

package/src/ngtsc/metadata/src/resource_registry.d.ts

@@ -17,7 +17,7 @@ import { ClassDeclaration } from '../../reflection';
  */
 export interface Resource {
     path: AbsoluteFsPath | null;
-    expression: ts.Expression;
+    node: ts.Node;
 }
 export interface ExternalResource extends Resource {
     path: AbsoluteFsPath;
@@ -32,6 +32,7 @@ export declare function isExternalResource(resource: Resource): resource is Exte
 export interface DirectiveResources {
     template: Resource | null;
     styles: ReadonlySet<Resource> | null;
+    hostBindings: ReadonlySet<Resource> | null;
 }
 /**
  * Tracks the mapping between external resources and the directives(s) which use them.
@@ -45,6 +46,7 @@ export declare class ResourceRegistry {
     private componentToTemplateMap;
     private componentToStylesMap;
     private externalStyleToComponentsMap;
+    private directiveToHostBindingsMap;
     getComponentsWithTemplate(template: AbsoluteFsPath): ReadonlySet<ClassDeclaration>;
     registerResources(resources: DirectiveResources, directive: ClassDeclaration): void;
     private registerTemplate;
@@ -52,4 +54,5 @@ export declare class ResourceRegistry {
     private registerStyle;
     getStyles(component: ClassDeclaration): Set<Resource>;
     getComponentsWithStyle(styleUrl: AbsoluteFsPath): ReadonlySet<ClassDeclaration>;
+    getHostBindings(directive: ClassDeclaration): ReadonlySet<Resource> | null;
 }

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

@@ -317,7 +317,7 @@ export type SourceMapping = DirectSourceMapping | IndirectSourceMapping | Extern
  */
 export interface DirectSourceMapping {
     type: 'direct';
-    node: ts.Expression;
+    node: ts.Node;
 }
 /**
  * A mapping to a node which is still in a TS file, but where the positions in any

package/src/ngtsc/typecheck/api/checker.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 { AST, LiteralPrimitive, ParseSourceSpan, PropertyRead, SafePropertyRead, TemplateEntity, TmplAstElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
+import { AST, LiteralPrimitive, ParseSourceSpan, PropertyRead, SafePropertyRead, TemplateEntity, TmplAstElement, TmplAstHostElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
 import { ErrorCode } from '../../diagnostics';
@@ -34,6 +34,10 @@ export interface TemplateTypeChecker {
      * Retrieve the template in use for the given component.
      */
     getTemplate(component: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstNode[] | null;
+    /**
+     * Retrieve the host element of the given directive.
+     */
+    getHostElement(directive: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstHostElement | null;
     /**
      * Get all `ts.Diagnostic`s currently available for the given `ts.SourceFile`.
      *

package/src/ngtsc/typecheck/api/context.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 { ParseError, ParseSourceFile, R3TargetBinder, SchemaMetadata, TmplAstNode } from '@angular/compiler';
+import { ParseError, ParseSourceFile, R3TargetBinder, SchemaMetadata, TmplAstHostElement, TmplAstNode } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../imports';
 import { PipeMeta } from '../../metadata';
@@ -26,6 +26,13 @@ export interface TemplateContext {
     /** Whether the template preserves whitespaces. */
     preserveWhitespaces: boolean;
 }
+/** Contextual data for type checking the host bindings of a directive. */
+export interface HostBindingsContext {
+    /** AST node representing the host element of the directive. */
+    node: TmplAstHostElement;
+    /** Describes the source of the host bindings. Used for mapping errors back. */
+    sourceMapping: SourceMapping;
+}
 /**
  * A currently pending type checking operation, into which templates for type-checking can be
  * registered.
@@ -44,9 +51,11 @@ export interface TypeCheckContext {
      * @param schemas Schemas that will apply when checking the directive.
      * @param templateContext Contextual information necessary for checking the template.
      * Only relevant for component classes.
+     * @param hostBindingContext Contextual information necessary for checking the host bindings of
+     * a directive.
      * @param isStandalone a boolean indicating whether the directive is standalone.
      */
-    addDirective(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, schemas: SchemaMetadata[], templateContext: TemplateContext | null, isStandalone: boolean): void;
+    addDirective(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, schemas: SchemaMetadata[], templateContext: TemplateContext | null, hostBindingContext: HostBindingsContext | null, isStandalone: boolean): void;
 }
 /**
  * Interface to trigger generation of type-checking code for a program given a new

package/src/ngtsc/typecheck/extended/checks/unparenthesized_nullish_coalescing/index.d.ts

@@ -0,0 +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
+ */
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../../diagnostics';
+import { TemplateCheckFactory } from '../../api';
+export declare const factory: TemplateCheckFactory<ErrorCode.UNPARENTHESIZED_NULLISH_COALESCING, ExtendedTemplateDiagnosticName.UNPARENTHESIZED_NULLISH_COALESCING>;

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

@@ -9,3 +9,4 @@ export { FileTypeCheckingData, TemplateTypeCheckerImpl } from './src/checker';
 export { TypeCheckContextImpl, getTemplateDiagnostics } from './src/context';
 export { TypeCheckShimGenerator } from './src/shim';
 export { typeCheckFilePath } from './src/type_check_file';
+export { createHostElement } from './src/host_bindings';

package/src/ngtsc/typecheck/src/checker.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 { AST, LiteralPrimitive, ParseSourceSpan, PropertyRead, SafePropertyRead, TemplateEntity, TmplAstElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
+import { AST, LiteralPrimitive, ParseSourceSpan, PropertyRead, SafePropertyRead, TemplateEntity, TmplAstElement, TmplAstHostElement, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
 import ts from 'typescript';
 import { ErrorCode } from '../../diagnostics';
 import { AbsoluteFsPath } from '../../file_system';
@@ -76,6 +76,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     private isComplete;
     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);
     getTemplate(component: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstNode[] | null;
+    getHostElement(directive: ts.ClassDeclaration, optimizeFor?: OptimizeFor): TmplAstHostElement | null;
     getUsedDirectives(component: ts.ClassDeclaration): TypeCheckableDirectiveMeta[] | null;
     getUsedPipes(component: ts.ClassDeclaration): string[] | null;
     private getLatestComponentState;

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

@@ -5,14 +5,14 @@
  * 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 { BoundTarget, ParseError, R3TargetBinder, SchemaMetadata, TmplAstNode } from '@angular/compiler';
+import { BoundTarget, ParseError, R3TargetBinder, SchemaMetadata, TmplAstHostElement, TmplAstNode } from '@angular/compiler';
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { Reference, ReferenceEmitter } from '../../imports';
 import { PerfRecorder } from '../../perf';
 import { FileUpdate } from '../../program_driver';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
-import { TemplateDiagnostic, TypeCheckId, SourceMapping, TypeCheckableDirectiveMeta, TypeCheckContext, TypeCheckingConfig, TypeCtorMetadata, TemplateContext } from '../api';
+import { HostBindingsContext, TemplateDiagnostic, TypeCheckId, SourceMapping, TypeCheckableDirectiveMeta, TypeCheckContext, TypeCheckingConfig, TypeCtorMetadata, TemplateContext } from '../api';
 import { DomSchemaChecker } from './dom';
 import { OutOfBandDiagnosticRecorder } from './oob';
 import { DirectiveSourceManager } from './source';
@@ -55,6 +55,10 @@ export interface TypeCheckData {
      * Errors found while parsing the template, which have been converted to diagnostics.
      */
     templateParsingDiagnostics: TemplateDiagnostic[];
+    /**
+     * Element representing the host bindings of a directive.
+     */
+    hostElement: TmplAstHostElement | null;
 }
 /**
  * Data for an input file which is still in the process of template type-checking code generation.
@@ -165,7 +169,7 @@ export declare class TypeCheckContextImpl implements TypeCheckContext {
      *
      * Implements `TypeCheckContext.addTemplate`.
      */
-    addDirective(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, schemas: SchemaMetadata[], templateContext: TemplateContext | null, isStandalone: boolean): void;
+    addDirective(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, schemas: SchemaMetadata[], templateContext: TemplateContext | null, hostBindingContext: HostBindingsContext | null, isStandalone: boolean): void;
     /**
      * Record a type constructor for the given `node` with the given `ctorMetadata`.
      */

package/src/ngtsc/typecheck/src/dom.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 { ParseSourceSpan, SchemaMetadata, TmplAstElement } from '@angular/compiler';
+import { ParseSourceSpan, SchemaMetadata, TmplAstElement, TmplAstHostElement } from '@angular/compiler';
 import { TemplateDiagnostic, TypeCheckId } from '../api';
 import { TypeCheckSourceResolver } from './tcb_util';
 /**
@@ -37,7 +37,7 @@ export interface DomSchemaChecker {
     /**
      * Check a property binding on an element and record any diagnostics about it.
      *
-     * @param id the template ID, suitable for resolution with a `TcbSourceResolver`.
+     * @param id the type check ID, suitable for resolution with a `TcbSourceResolver`.
      * @param element the element node in question.
      * @param name the name of the property being checked.
      * @param span the source span of the binding. This is redundant with `element.attributes` but is
@@ -45,7 +45,17 @@ export interface DomSchemaChecker {
      * @param schemas any active schemas for the template, which might affect the validity of the
      * property.
      */
-    checkProperty(id: string, element: TmplAstElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
+    checkTemplateElementProperty(id: string, element: TmplAstElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
+    /**
+     * Check a property binding on a host element and record any diagnostics about it.
+     * @param id the type check ID, suitable for resolution with a `TcbSourceResolver`.
+     * @param element the element node in question.
+     * @param name the name of the property being checked.
+     * @param span the source span of the binding.
+     * @param schemas any active schemas for the template, which might affect the validity of the
+     * property.
+     */
+    checkHostElementProperty(id: string, element: TmplAstHostElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[]): void;
 }
 /**
  * Checks non-Angular elements and properties against the `DomElementSchemaRegistry`, a schema
@@ -57,5 +67,6 @@ export declare class RegistryDomSchemaChecker implements DomSchemaChecker {
     get diagnostics(): ReadonlyArray<TemplateDiagnostic>;
     constructor(resolver: TypeCheckSourceResolver);
     checkElement(id: TypeCheckId, element: TmplAstElement, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
-    checkProperty(id: TypeCheckId, element: TmplAstElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
+    checkTemplateElementProperty(id: TypeCheckId, element: TmplAstElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
+    checkHostElementProperty(id: TypeCheckId, element: TmplAstHostElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[]): void;
 }

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

@@ -0,0 +1,31 @@
+/*!
+ * @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 { TmplAstHostElement } from '@angular/compiler';
+import ts from 'typescript';
+import { ClassDeclaration } from '../../reflection';
+/**
+ * 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.
+ */
+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;
+/**
+ * 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;
+/**
+ * Determines if a given node is a guard that indicates that descendant nodes are used to check
+ * host bindings.
+ */
+export declare function isHostBindingsBlockGuard(node: ts.Node): boolean;

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

@@ -9,19 +9,6 @@ import { AbsoluteSourceSpan, ParseSourceFile, ParseSourceSpan } from '@angular/c
 import ts from 'typescript';
 import { TypeCheckId, SourceMapping } from '../api';
 import { TypeCheckSourceResolver } from './tcb_util';
-/**
- * Represents the source of a template that was processed during type-checking. This information is
- * used when translating parse offsets in diagnostics back to their original line/column location.
- */
-export declare class TemplateSource {
-    readonly mapping: SourceMapping;
-    private file;
-    private lineStarts;
-    constructor(mapping: SourceMapping, file: ParseSourceFile);
-    toParseSourceSpan(start: number, end: number): ParseSourceSpan;
-    private toParseLocation;
-    private acquireLineStarts;
-}
 /**
  * Assigns IDs for type checking and keeps track of their origins.
  *
@@ -34,8 +21,13 @@ export declare class DirectiveSourceManager implements TypeCheckSourceResolver {
      * diagnostics produced for TCB code to their source location in the template.
      */
     private templateSources;
+    /** Keeps track of type check IDs and the source location of their host bindings. */
+    private hostBindingSources;
     getTypeCheckId(node: ts.ClassDeclaration): TypeCheckId;
     captureTemplateSource(id: TypeCheckId, mapping: SourceMapping, file: ParseSourceFile): void;
+    captureHostBindingsMapping(id: TypeCheckId, mapping: SourceMapping, file: ParseSourceFile): void;
     getTemplateSourceMapping(id: TypeCheckId): SourceMapping;
+    getHostBindingsMapping(id: TypeCheckId): SourceMapping;
     toTemplateParseSourceSpan(id: TypeCheckId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
+    toHostParseSourceSpan(id: TypeCheckId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
 }

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

@@ -28,6 +28,14 @@ export interface TypeCheckSourceResolver {
      * numbers in addition to only absolute offsets and gives access to the original source code.
      */
     toTemplateParseSourceSpan(id: TypeCheckId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
+    /** For the given type checking id, retrieve the source mapping of its host bindings. */
+    getHostBindingsMapping(id: TypeCheckId): SourceMapping;
+    /**
+     * Convert an absolute source span coming from a host binding associated with the given type
+     * checking id into a full `ParseSourceSpan`. The returned parse span has line and column
+     * numbers in addition to only absolute offsets and gives access to the original source code.
+     */
+    toHostParseSourceSpan(id: TypeCheckId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
 }
 /**
  * Indicates whether a particular component requires an inline type check block.

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

@@ -13,7 +13,7 @@ export declare function tsCastToAny(expr: ts.Expression): ts.Expression;
  * Thanks to narrowing of `document.createElement()`, this expression will have its type inferred
  * based on the tag name, including for custom elements that have appropriate .d.ts definitions.
  */
-export declare function tsCreateElement(tagName: string): ts.Expression;
+export declare function tsCreateElement(...tagNames: string[]): ts.Expression;
 /**
  * Create a `ts.VariableStatement` which declares a variable without explicit initialization.
  *

package/src/ngtsc/typecheck/src/type_check_block.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 { BoundTarget, SchemaMetadata, TmplAstElement, TmplAstForLoopBlock, TmplAstIfBlockBranch, TmplAstLetDeclaration, TmplAstNode, TmplAstReference, TmplAstTemplate, TmplAstVariable } from '@angular/compiler';
+import { BoundTarget, SchemaMetadata, TmplAstElement, TmplAstForLoopBlock, TmplAstIfBlockBranch, TmplAstLetDeclaration, TmplAstNode, TmplAstReference, TmplAstTemplate, TmplAstVariable, TmplAstHostElement } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../imports';
 import { PipeMeta } from '../../metadata';
@@ -65,7 +65,7 @@ export declare enum TcbGenericContextBehavior {
  */
 export declare function generateTypeCheckBlock(env: Environment, ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, name: ts.Identifier, meta: TypeCheckBlockMetadata, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, genericContextBehavior: TcbGenericContextBehavior): ts.FunctionDeclaration;
 /** Types that can referenced locally in a template. */
-type LocalSymbol = TmplAstElement | TmplAstTemplate | TmplAstVariable | TmplAstLetDeclaration | TmplAstReference;
+type LocalSymbol = TmplAstElement | TmplAstTemplate | TmplAstVariable | TmplAstLetDeclaration | TmplAstReference | TmplAstHostElement;
 /**
  * A code generation operation that's involved in the construction of a Type Check Block.
  *
@@ -179,6 +179,10 @@ declare class Scope {
      * A map of `TmplAstElement`s to the index of their `TcbElementOp` in the `opQueue`
      */
     private elementOpMap;
+    /**
+     * A map of `TmplAstHostElement`s to the index of their `TcbHostElementOp` in the `opQueue`
+     */
+    private hostElementOpMap;
     /**
      * A map of maps which tracks the index of `TcbDirectiveCtorOp`s in the `opQueue` for each
      * directive on a `TmplAstElement` or `TmplAstTemplate` node.
@@ -227,7 +231,7 @@ declare class Scope {
      * @param children Child nodes that should be appended to the TCB.
      * @param guard an expression that is applied to this scope for type narrowing purposes.
      */
-    static forNodes(tcb: Context, parentScope: Scope | null, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | null, children: TmplAstNode[], guard: ts.Expression | null): Scope;
+    static forNodes(tcb: Context, parentScope: Scope | null, scopedNode: TmplAstTemplate | TmplAstIfBlockBranch | TmplAstForLoopBlock | TmplAstHostElement | null, children: TmplAstNode[] | null, guard: ts.Expression | null): Scope;
     /** Registers a local variable with a scope. */
     private static registerVariable;
     /**