@angular/compiler-cli 20.0.0-next.1 → 20.0.0-next.3

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.1";
+export declare const PLACEHOLDER_VERSION = "20.0.0-next.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": "20.0.0-next.1",
+  "version": "20.0.0-next.3",
   "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.1",
+    "@angular/compiler": "20.0.0-next.3",
     "typescript": ">=5.8 <5.9"
   },
   "repository": {

package/private/migrations.d.ts

@@ -9,7 +9,7 @@
  * @fileoverview The API from compiler-cli that the `@angular/core`
  * package requires for migration schematics.
  */
-export { forwardRefResolver } from '../src/ngtsc/annotations';
+export { createForwardRefResolver } from '../src/ngtsc/annotations';
 export { AbsoluteFsPath } from '../src/ngtsc/file_system';
 export { Reference } from '../src/ngtsc/imports';
 export { DynamicValue, PartialEvaluator, ResolvedValue, ResolvedValueMap, StaticInterpreter, } from '../src/ngtsc/partial_evaluator';

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

@@ -9,7 +9,7 @@ import ts from 'typescript';
 import { Reference } from '../../../imports';
 import { PartialEvaluator, ResolvedValue } from '../../../partial_evaluator';
 import { ClassDeclaration, Decorator } from '../../../reflection';
-export declare function resolveEnumValue(evaluator: PartialEvaluator, metadata: Map<string, ts.Expression>, field: string, enumSymbolName: string): number | null;
+export declare function resolveEnumValue(evaluator: PartialEvaluator, metadata: Map<string, ts.Expression>, field: string, enumSymbolName: string, isCore: boolean): number | null;
 /**
  * Resolves a EncapsulationEnum expression locally on best effort without having to calculate the
  * reference. This suites local compilation mode where each file is compiled individually.

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

@@ -26,7 +26,24 @@ export declare function toR3Reference(origin: ts.Node, ref: Reference, context:
 export declare function isAngularCore(decorator: Decorator): decorator is Decorator & {
     import: Import;
 };
-export declare function isAngularCoreReference(reference: Reference, symbolName: string): boolean;
+/**
+ * This function is used for verifying that a given reference is declared
+ * inside `@angular/core` and corresponds to the given symbol name.
+ *
+ * In some cases, due to the compiler face duplicating many symbols as
+ * an independent bridge between core and the compiler, the dts bundler may
+ * decide to alias declarations in the `.d.ts`, to avoid conflicts.
+ *
+ * e.g.
+ *
+ * ```
+ * declare enum ViewEncapsulation {} // from the facade
+ * declare enum ViewEncapsulation$1 {} // the real one exported to users.
+ * ```
+ *
+ * This function accounts for such potential re-namings.
+ */
+export declare function isAngularCoreReferenceWithPotentialAliasing(reference: Reference, symbolName: string, isCore: boolean): boolean;
 export declare function findAngularDecorator(decorators: Decorator[], name: string, isCore: boolean): Decorator | undefined;
 export declare function isAngularDecorator(decorator: Decorator, name: string, isCore: boolean): boolean;
 export declare function getAngularDecorators(decorators: Decorator[], names: readonly string[], isCore: boolean): Decorator[];
@@ -55,7 +72,7 @@ export declare function tryUnwrapForwardRef(node: ts.Expression, reflector: Refl
  * @param args the arguments to the invocation of the forwardRef expression
  * @returns an unwrapped argument if `ref` pointed to forwardRef, or null otherwise
  */
-export declare const forwardRefResolver: ForeignFunctionResolver;
+export declare function createForwardRefResolver(isCore: boolean): ForeignFunctionResolver;
 /**
  * Combines an array of resolver functions into a one.
  * @param resolvers Resolvers to be combined.

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

@@ -8,10 +8,11 @@
 import { AnimationTriggerNames, DeclarationListEmitMode, DeferBlockDepsEmitMode, R3ClassDebugInfo, R3ClassMetadata, R3ComponentMetadata, R3DeferPerBlockDependency, R3DeferPerComponentDependency, R3TemplateDependencyMetadata, SchemaMetadata, TmplAstDeferredBlock } from '@angular/compiler';
 import ts from 'typescript';
 import { Reference } from '../../../imports';
-import { ClassPropertyMapping, ComponentResources, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping } from '../../../metadata';
+import { ClassPropertyMapping, DirectiveResources, DirectiveTypeCheckMeta, HostDirectiveMeta, InputMapping } from '../../../metadata';
 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.
  *
@@ -43,7 +44,7 @@ export interface ComponentAnalysisData {
      * require an Angular factory definition at runtime.
      */
     viewProvidersRequiringFactory: Set<Reference<ClassDeclaration>> | null;
-    resources: ComponentResources;
+    resources: DirectiveResources;
     /**
      * `styleUrls` extracted from the decorator, if present.
      */
@@ -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/component/src/resources.d.ts

@@ -13,7 +13,7 @@ import { Resource } from '../../../metadata';
 import { PartialEvaluator } from '../../../partial_evaluator';
 import { ClassDeclaration, DeclarationNode, Decorator } from '../../../reflection';
 import { CompilationMode } from '../../../transform';
-import { TemplateSourceMapping } from '../../../typecheck/api';
+import { SourceMapping } from '../../../typecheck/api';
 import { ResourceLoader } from '../../common';
 /**
  * The literal style url extracted from the decorator, along with metadata for diagnostics.
@@ -58,7 +58,7 @@ export interface ParsedComponentTemplate extends ParsedTemplate {
 export interface ParsedTemplateWithSource extends ParsedComponentTemplate {
     /** The string contents of the template. */
     content: string;
-    sourceMapping: TemplateSourceMapping;
+    sourceMapping: SourceMapping;
     declaration: TemplateDeclaration;
 }
 /**
@@ -104,6 +104,7 @@ export interface ExtractTemplateOptions {
     preserveSignificantWhitespace?: boolean;
 }
 export declare function extractTemplate(node: ClassDeclaration, template: TemplateDeclaration, evaluator: PartialEvaluator, depTracker: DependencyTracker | null, resourceLoader: ResourceLoader, options: ExtractTemplateOptions, compilationMode: CompilationMode): ParsedTemplateWithSource;
+export declare function createEmptyTemplate(componentClass: ClassDeclaration, component: Map<string, ts.Expression>, containingFile: string): ParsedTemplateWithSource;
 export declare function parseTemplateDeclaration(node: ClassDeclaration, decorator: Decorator, component: Map<string, ts.Expression>, containingFile: string, evaluator: PartialEvaluator, depTracker: DependencyTracker | null, resourceLoader: ResourceLoader, defaultPreserveWhitespaces: boolean): TemplateDeclaration;
 export declare function preloadAndParseTemplate(evaluator: PartialEvaluator, resourceLoader: ResourceLoader, depTracker: DependencyTracker | null, preanalyzeTemplateCache: Map<DeclarationNode, ParsedTemplateWithSource>, node: ClassDeclaration, decorator: Decorator, component: Map<string, ts.Expression>, containingFile: string, defaultPreserveWhitespaces: boolean, options: ExtractTemplateOptions, compilationMode: CompilationMode): Promise<ParsedTemplateWithSource | null>;
 export declare function makeResourceNotFoundError(file: string, nodeForError: ts.Node, resourceType: ResourceTypeForDiagnostics): FatalDiagnosticError;

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/annotations/index.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
  */
-export { forwardRefResolver, findAngularDecorator, getAngularDecorators, isAngularDecorator, NoopReferencesRegistry, ReferencesRegistry, ResourceLoader, ResourceLoaderContext, JitDeclarationRegistry, } from './common';
+export { createForwardRefResolver, findAngularDecorator, getAngularDecorators, isAngularDecorator, NoopReferencesRegistry, ReferencesRegistry, ResourceLoader, ResourceLoaderContext, JitDeclarationRegistry, } from './common';
 export { ComponentDecoratorHandler } from './component';
 export { DirectiveDecoratorHandler, InitializerApiFunction, INPUT_INITIALIZER_FN, MODEL_INITIALIZER_FN, OUTPUT_INITIALIZER_FNS, QUERY_INITIALIZER_FNS, queryDecoratorNames, QueryFunctionName, tryParseInitializerApi, tryParseInitializerBasedOutput, tryParseSignalInputMapping, tryParseSignalModelMapping, tryParseSignalQueryFromInitializer, } from './directive';
 export { NgModuleDecoratorHandler } from './ng_module';

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.
  */
@@ -38,6 +38,14 @@ export interface InternalOptions {
      * Whether to check the event side of two-way bindings.
      */
     _checkTwoWayBoundEvents?: boolean;
+    /**
+     * Whether this is a compilation of Angular core itself.
+     *
+     * By default, we detect this automatically based on the existence of `r3_symbols.ts`
+     * in the compilation, but there are other test targets within the `core` package that
+     * import e.g. `Component` relatively and should be detected by the compiler.
+     */
+    _isAngularCoreCompilation?: boolean;
 }
 /**
  * A merged interface of all of the various Angular compiler options, as well as the standard
@@ -45,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/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 { ComponentResources, DirectiveMeta, PipeMeta } from '../../metadata';
+import { DirectiveResources, DirectiveMeta, PipeMeta } from '../../metadata';
 import { ActivePerfRecorder } from '../../perf';
 import { ProgramDriver } from '../../program_driver';
 import { DeclarationNode } from '../../reflection';
@@ -208,9 +208,9 @@ export declare class NgCompiler {
      */
     getComponentsWithStyleFile(styleFilePath: string): ReadonlySet<DeclarationNode>;
     /**
-     * Retrieves external resources for the given component.
+     * Retrieves external resources for the given directive.
      */
-    getComponentResources(classDecl: DeclarationNode): ComponentResources | null;
+    getDirectiveResources(classDecl: DeclarationNode): DirectiveResources | null;
     getMeta(classDecl: DeclarationNode): PipeMeta | DirectiveMeta | null;
     /**
      * Perform Angular's analysis step (as a precursor to `getDiagnostics` or `prepareEmit`)

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/docs/src/function_extractor.d.ts

@@ -7,7 +7,7 @@
  */
 import ts from 'typescript';
 import { EntryType, FunctionEntry, ParameterEntry } from './entities';
-export type FunctionLike = ts.FunctionDeclaration | ts.MethodDeclaration | ts.MethodSignature | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration;
+export type FunctionLike = ts.FunctionDeclaration | ts.MethodDeclaration | ts.MethodSignature | ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration | ts.ConstructorDeclaration;
 export declare class FunctionExtractor {
     private name;
     private exportDeclaration;

package/src/ngtsc/hmr/src/update_declaration.d.ts

@@ -7,11 +7,12 @@
  */
 import { R3HmrMetadata, outputAst as o } from '@angular/compiler';
 import { CompileResult } from '../../transform';
+import { ClassDeclaration } from '../../reflection';
 import ts from 'typescript';
 /**
  * Gets the declaration for the function that replaces the metadata of a class during HMR.
  * @param compilationResults Code generated for the class during compilation.
  * @param meta HMR metadata about the class.
- * @param sourceFile File in which the class is defined.
+ * @param declaration Class for which the update declaration is being generated.
  */
-export declare function getHmrUpdateDeclaration(compilationResults: CompileResult[], constantStatements: o.Statement[], meta: R3HmrMetadata, sourceFile: ts.SourceFile): ts.FunctionDeclaration;
+export declare function getHmrUpdateDeclaration(compilationResults: CompileResult[], constantStatements: o.Statement[], meta: R3HmrMetadata, declaration: ClassDeclaration): ts.FunctionDeclaration;

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

@@ -9,7 +9,7 @@ export * from './src/api';
 export { DtsMetadataReader } from './src/dts';
 export { flattenInheritedDirectiveMetadata } from './src/inheritance';
 export { CompoundMetadataRegistry, LocalMetadataRegistry } from './src/registry';
-export { ResourceRegistry, Resource, ComponentResources, isExternalResource, ExternalResource, } from './src/resource_registry';
+export { ResourceRegistry, Resource, DirectiveResources, isExternalResource, ExternalResource, } from './src/resource_registry';
 export { extractDirectiveTypeCheckMeta, hasInjectableFields, CompoundMetadataReader, isHostDirectiveMetaForGlobalMode, } from './src/util';
 export { BindingPropertyName, ClassPropertyMapping, ClassPropertyName, InputOrOutput, } from './src/property_mapping';
 export { ExportedProviderStatusResolver } from './src/providers';

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

@@ -17,23 +17,25 @@ import { ClassDeclaration } from '../../reflection';
  */
 export interface Resource {
     path: AbsoluteFsPath | null;
-    expression: ts.Expression;
+    node: ts.Node;
 }
 export interface ExternalResource extends Resource {
     path: AbsoluteFsPath;
 }
 export declare function isExternalResource(resource: Resource): resource is ExternalResource;
 /**
- * Represents the either inline or external resources of a component.
+ * Represents the either inline or external resources of a directive.
  *
  * A resource with a `path` of `null` is considered inline.
+ * The template will be present for components, but will be null for directives.
  */
-export interface ComponentResources {
-    template: Resource;
-    styles: ReadonlySet<Resource>;
+export interface DirectiveResources {
+    template: Resource | null;
+    styles: ReadonlySet<Resource> | null;
+    hostBindings: ReadonlySet<Resource> | null;
 }
 /**
- * Tracks the mapping between external template/style files and the component(s) which use them.
+ * Tracks the mapping between external resources and the directives(s) which use them.
  *
  * This information is produced during analysis of the program and is used mainly to support
  * external tooling, for which such a mapping is challenging to determine without compiler
@@ -44,11 +46,13 @@ export declare class ResourceRegistry {
     private componentToTemplateMap;
     private componentToStylesMap;
     private externalStyleToComponentsMap;
+    private directiveToHostBindingsMap;
     getComponentsWithTemplate(template: AbsoluteFsPath): ReadonlySet<ClassDeclaration>;
-    registerResources(resources: ComponentResources, component: ClassDeclaration): void;
-    registerTemplate(templateResource: Resource, component: ClassDeclaration): void;
+    registerResources(resources: DirectiveResources, directive: ClassDeclaration): void;
+    private registerTemplate;
     getTemplate(component: ClassDeclaration): Resource | null;
-    registerStyle(styleResource: Resource, component: ClassDeclaration): void;
+    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

@@ -28,8 +28,8 @@ export interface TypeCheckableDirectiveMeta extends DirectiveMeta, DirectiveType
     imports: Reference<ClassDeclaration>[] | null;
     rawImports: ts.Expression | null;
 }
-export type TemplateId = string & {
-    __brand: 'TemplateId';
+export type TypeCheckId = string & {
+    __brand: 'TypeCheckId';
 };
 /**
  * A `ts.Diagnostic` with additional information about the diagnostic related to template
@@ -39,11 +39,11 @@ export interface TemplateDiagnostic extends ts.Diagnostic {
     /**
      * The component with the template that resulted in this diagnostic.
      */
-    componentFile: ts.SourceFile;
+    sourceFile: ts.SourceFile;
     /**
-     * The template id of the component that resulted in this diagnostic.
+     * The type check ID of the directive that resulted in this diagnostic.
      */
-    templateId: TemplateId;
+    typeCheckId: TypeCheckId;
 }
 /**
  * A `TemplateDiagnostic` with a specific error code.
@@ -59,14 +59,14 @@ export interface TypeCheckBlockMetadata {
     /**
      * A unique identifier for the class which gave rise to this TCB.
      *
-     * This can be used to map errors back to the `ts.ClassDeclaration` for the component.
+     * This can be used to map errors back to the `ts.ClassDeclaration` for the directive.
      */
-    id: TemplateId;
+    id: TypeCheckId;
     /**
      * Semantic information about the template of the component.
      */
     boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
-    pipes: Map<string, PipeMeta>;
+    pipes: Map<string, PipeMeta> | null;
     /**
      * Schemas that apply to this template.
      */
@@ -309,26 +309,24 @@ export interface TypeCheckingConfig {
      */
     checkTwoWayBoundEvents: boolean;
 }
-export type TemplateSourceMapping = DirectTemplateSourceMapping | IndirectTemplateSourceMapping | ExternalTemplateSourceMapping;
+export type SourceMapping = DirectSourceMapping | IndirectSourceMapping | ExternalTemplateSourceMapping;
 /**
- * A mapping to an inline template in a TS file.
+ * A mapping to a node within the same source file..
  *
- * `ParseSourceSpan`s for this template should be accurate for direct reporting in a TS error
- * message.
+ * `ParseSourceSpan`s for this node should be accurate for direct reporting in a TS error message.
  */
-export interface DirectTemplateSourceMapping {
+export interface DirectSourceMapping {
     type: 'direct';
-    node: ts.StringLiteral | ts.NoSubstitutionTemplateLiteral;
+    node: ts.Node;
 }
 /**
- * A mapping to a template which is still in a TS file, but where the node positions in any
+ * A mapping to a node which is still in a TS file, but where the positions in any
  * `ParseSourceSpan`s are not accurate for one reason or another.
  *
- * This can occur if the template expression was interpolated in a way where the compiler could not
- * construct a contiguous mapping for the template string. The `node` refers to the `template`
- * expression.
+ * This can occur if the expression was interpolated in a way where the compiler could not
+ * construct a contiguous mapping for the template string.
  */
-export interface IndirectTemplateSourceMapping {
+export interface IndirectSourceMapping {
     type: 'indirect';
     componentClass: ClassDeclaration;
     node: ts.Expression;
@@ -348,18 +346,18 @@ export interface ExternalTemplateSourceMapping {
     templateUrl: string;
 }
 /**
- * A mapping of a TCB template id to a span in the corresponding template source.
+ * A mapping of a TCB template id to a span in the corresponding source code.
  */
 export interface SourceLocation {
-    id: TemplateId;
+    id: TypeCheckId;
     span: AbsoluteSourceSpan;
 }
 /**
- * A representation of all a node's template mapping information we know. Useful for producing
+ * A representation of all a node's type checking information we know. Useful for producing
  * diagnostics based on a TCB node or generally mapping from a TCB node back to a template location.
  */
-export interface FullTemplateMapping {
+export interface FullSourceMapping {
     sourceLocation: SourceLocation;
-    templateSourceMapping: TemplateSourceMapping;
+    sourceMapping: SourceMapping;
     span: ParseSourceSpan;
 }

package/src/ngtsc/typecheck/api/checker.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 { 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';
 import { Reference } from '../../imports';
 import { NgModuleMeta, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
-import { FullTemplateMapping, NgTemplateDiagnostic, TypeCheckableDirectiveMeta } from './api';
+import { FullSourceMapping, NgTemplateDiagnostic, TypeCheckableDirectiveMeta } from './api';
 import { GlobalCompletion } from './completion';
 import { PotentialDirective, PotentialImport, PotentialImportMode, PotentialPipe } from './scope';
 import { ElementSymbol, Symbol, TcbLocation, TemplateSymbol } from './symbols';
@@ -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`.
      *
@@ -50,10 +54,10 @@ export interface TemplateTypeChecker {
      */
     getDiagnosticsForFile(sf: ts.SourceFile, optimizeFor: OptimizeFor): ts.Diagnostic[];
     /**
-     * Given a `shim` and position within the file, returns information for mapping back to a template
+     * Given a `shim` and position within the file, returns information for mapping back to a source
      * location.
      */
-    getTemplateMappingAtTcbLocation(tcbLocation: TcbLocation): FullTemplateMapping | null;
+    getSourceMappingAtTcbLocation(tcbLocation: TcbLocation): FullSourceMapping | null;
     /**
      * Get all `ts.Diagnostic`s currently available that pertain to the given component.
      *