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

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

@@ -5,39 +5,57 @@
  * 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';
 import { ClassDeclaration } from '../../reflection';
-import { TemplateSourceMapping, TypeCheckableDirectiveMeta } from './api';
+import { SourceMapping, TypeCheckableDirectiveMeta } from './api';
+/** Contextuable data for type checking the template of a component. */
+export interface TemplateContext {
+    /** AST nodes representing the template. */
+    nodes: TmplAstNode[];
+    /** Describes the origin of the template text. Used for mapping errors back. */
+    sourceMapping: SourceMapping;
+    /** `ParseSourceFile` associated with the template. */
+    file: ParseSourceFile;
+    /** Errors produced while parsing the template. */
+    parseErrors: ParseError[] | null;
+    /** Pipes available within the template. */
+    pipes: Map<string, PipeMeta>;
+    /** 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.
  */
 export interface TypeCheckContext {
     /**
-     * Register a template to potentially be type-checked.
+     * Register a directive to be potentially be type-checked.
      *
-     * Templates registered via `addTemplate` are available for checking, but might be skipped if
-     * checking of that component is not required. This can happen for a few reasons, including if
-     * the component was previously checked and the prior results are still valid.
+     * Directives registered via `addDIrective` are available for checking, but might be skipped if
+     * checking of that class is not required. This can happen for a few reasons, including if it was
+     * previously checked and the prior results are still valid.
      *
-     * @param ref a `Reference` to the component class which yielded this template.
+     * @param ref a `Reference` to the directive class which yielded this template.
      * @param binder an `R3TargetBinder` which encapsulates the scope of this template, including all
      * available directives.
-     * @param template the original template AST of this component.
-     * @param pipes a `Map` of pipes available within the scope of this template.
-     * @param schemas any schemas which apply to this template.
-     * @param sourceMapping a `TemplateSourceMapping` instance which describes the origin of the
-     * template text described by the AST.
-     * @param file the `ParseSourceFile` associated with the template.
-     * @param parseErrors the `ParseError`'s associated with the template.
-     * @param isStandalone a boolean indicating whether the component is standalone.
-     * @param preserveWhitespaces a boolean indicating whether the component's template preserves
-     * whitespaces.
+     * @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.
      */
-    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, PipeMeta>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null, isStandalone: boolean, preserveWhitespaces: 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/diagnostics/src/diagnostic.d.ts

@@ -7,11 +7,11 @@
  */
 import { ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
-import { TemplateDiagnostic, TemplateId, TemplateSourceMapping } from '../../api';
+import { TemplateDiagnostic, TypeCheckId, SourceMapping } from '../../api';
 /**
  * Constructs a `ts.Diagnostic` for a given `ParseSourceSpan` within a template.
  */
-export declare function makeTemplateDiagnostic(templateId: TemplateId, mapping: TemplateSourceMapping, span: ParseSourceSpan, category: ts.DiagnosticCategory, code: number, messageText: string | ts.DiagnosticMessageChain, relatedMessages?: {
+export declare function makeTemplateDiagnostic(id: TypeCheckId, mapping: SourceMapping, span: ParseSourceSpan, category: ts.DiagnosticCategory, code: number, messageText: string | ts.DiagnosticMessageChain, relatedMessages?: {
     text: string;
     start: number;
     end: number;

package/src/ngtsc/typecheck/diagnostics/src/id.d.ts

@@ -6,5 +6,5 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { DeclarationNode } from '../../../reflection';
-import { TemplateId } from '../../api';
-export declare function getTemplateId(clazz: DeclarationNode): TemplateId;
+import { TypeCheckId } from '../../api';
+export declare function getTypeCheckId(clazz: DeclarationNode): TypeCheckId;

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';
@@ -16,9 +16,9 @@ import { PerfRecorder } from '../../perf';
 import { ProgramDriver } from '../../program_driver';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { ComponentScopeReader, TypeCheckScopeRegistry } from '../../scope';
-import { ElementSymbol, FullTemplateMapping, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PotentialDirective, PotentialImport, PotentialImportMode, PotentialPipe, ProgramTypeCheckAdapter, TcbLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
+import { ElementSymbol, FullSourceMapping, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PotentialDirective, PotentialImport, PotentialImportMode, PotentialPipe, ProgramTypeCheckAdapter, TcbLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
 import { ShimTypeCheckingData } from './context';
-import { TemplateSourceManager } from './source';
+import { DirectiveSourceManager } from './source';
 /**
  * Primary template type-checking engine, which performs type-checking using a
  * `TypeCheckingProgramStrategy` for type-checking program maintenance, and the
@@ -76,13 +76,14 @@ 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;
     isTrackedTypeCheckFile(filePath: AbsoluteFsPath): boolean;
     private getFileRecordForTcbLocation;
     private getFileAndShimRecordsForPath;
-    getTemplateMappingAtTcbLocation(tcbLocation: TcbLocation): FullTemplateMapping | null;
+    getSourceMappingAtTcbLocation(tcbLocation: TcbLocation): FullSourceMapping | null;
     generateAllTypeCheckBlocks(): void;
     /**
      * Retrieve type-checking and template parse diagnostics from the given `ts.SourceFile` using the
@@ -150,10 +151,10 @@ export interface FileTypeCheckingData {
      */
     hasInlines: boolean;
     /**
-     * Source mapping information for mapping diagnostics from inlined type check blocks back to the
-     * original template.
+     * Information for mapping diagnostics from inlined type check blocks
+     * back to their original sources.
      */
-    sourceManager: TemplateSourceManager;
+    sourceManager: DirectiveSourceManager;
     /**
      * Data for each shim generated from this input file.
      *

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

@@ -9,7 +9,7 @@ import { AST, LiteralPrimitive, PropertyRead, PropertyWrite, SafePropertyRead, T
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { GlobalCompletion, TcbLocation } from '../api';
-import { TemplateData } from './context';
+import { TypeCheckData } from './context';
 /**
  * Powers autocompletion for a specific component.
  *
@@ -28,7 +28,7 @@ export declare class CompletionEngine {
      */
     private templateContextCache;
     private expressionCompletionCache;
-    constructor(tcb: ts.Node, data: TemplateData, tcbPath: AbsoluteFsPath, tcbIsShim: boolean);
+    constructor(tcb: ts.Node, data: TypeCheckData, tcbPath: AbsoluteFsPath, tcbIsShim: boolean);
     /**
      * Get global completions within the given template context and AST node.
      *

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

@@ -5,18 +5,17 @@
  * 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, ParseSourceFile, 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 { PipeMeta } from '../../metadata';
 import { PerfRecorder } from '../../perf';
 import { FileUpdate } from '../../program_driver';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
-import { TemplateDiagnostic, TemplateId, TemplateSourceMapping, TypeCheckableDirectiveMeta, TypeCheckContext, TypeCheckingConfig, TypeCtorMetadata } from '../api';
+import { HostBindingsContext, TemplateDiagnostic, TypeCheckId, SourceMapping, TypeCheckableDirectiveMeta, TypeCheckContext, TypeCheckingConfig, TypeCtorMetadata, TemplateContext } from '../api';
 import { DomSchemaChecker } from './dom';
 import { OutOfBandDiagnosticRecorder } from './oob';
-import { TemplateSourceManager } from './source';
+import { DirectiveSourceManager } from './source';
 import { TypeCheckFile } from './type_check_file';
 export interface ShimTypeCheckingData {
     /**
@@ -34,28 +33,32 @@ export interface ShimTypeCheckingData {
      */
     hasInlines: boolean;
     /**
-     * Map of `TemplateId` to information collected about the template during the template
+     * Map of `TypeCheckId` to information collected about the template during the template
      * type-checking process.
      */
-    templates: Map<TemplateId, TemplateData>;
+    data: Map<TypeCheckId, TypeCheckData>;
 }
 /**
- * Data tracked for each template processed by the template type-checking system.
+ * Data tracked for each class processed by the type-checking system.
  */
-export interface TemplateData {
+export interface TypeCheckData {
     /**
      * Template nodes for which the TCB was generated.
      */
-    template: TmplAstNode[];
+    template: TmplAstNode[] | null;
     /**
      * `BoundTarget` which was used to generate the TCB, and contains bindings for the associated
      * template nodes.
      */
     boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
     /**
-     * Errors found while parsing them template, which have been converted to diagnostics.
+     * Errors found while parsing the template, which have been converted to diagnostics.
      */
-    templateDiagnostics: TemplateDiagnostic[];
+    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.
@@ -69,7 +72,7 @@ export interface PendingFileTypeCheckingData {
      * Source mapping information for mapping diagnostics from inlined type check blocks back to the
      * original template.
      */
-    sourceManager: TemplateSourceManager;
+    sourceManager: DirectiveSourceManager;
     /**
      * Map of in-progress shim data for shims generated from this input file.
      */
@@ -89,9 +92,9 @@ export interface PendingShimData {
      */
     file: TypeCheckFile;
     /**
-     * Map of `TemplateId` to information collected about the template as it's ingested.
+     * Map of `TypeCheckId` to information collected about the template as it's ingested.
      */
-    templates: Map<TemplateId, TemplateData>;
+    data: Map<TypeCheckId, TypeCheckData>;
 }
 /**
  * Adapts the `TypeCheckContextImpl` to the larger template type-checking system.
@@ -102,23 +105,23 @@ export interface PendingShimData {
  */
 export interface TypeCheckingHost {
     /**
-     * Retrieve the `TemplateSourceManager` responsible for components in the given input file path.
+     * Retrieve the `DirectiveSourceManager` responsible for directives in the given input file path.
      */
-    getSourceManager(sfPath: AbsoluteFsPath): TemplateSourceManager;
+    getSourceManager(sfPath: AbsoluteFsPath): DirectiveSourceManager;
     /**
-     * Whether a particular component class should be included in the current type-checking pass.
+     * Whether a particular class should be included in the current type-checking pass.
      *
-     * Not all components offered to the `TypeCheckContext` for checking may require processing. For
-     * example, the component may have results already available from a prior pass or from a previous
+     * Not all classes offered to the `TypeCheckContext` for checking may require processing. For
+     * example, the directive may have results already available from a prior pass or from a previous
      * program.
      */
-    shouldCheckComponent(node: ts.ClassDeclaration): boolean;
+    shouldCheckClass(node: ts.ClassDeclaration): boolean;
     /**
      * Report data from a shim generated from the given input file path.
      */
     recordShimData(sfPath: AbsoluteFsPath, data: ShimTypeCheckingData): void;
     /**
-     * Record that all of the components within the given input file path had code generated - that
+     * Record that all of the classes within the given input file path had code generated - that
      * is, coverage for the file can be considered complete.
      */
     recordComplete(sfPath: AbsoluteFsPath): void;
@@ -139,8 +142,7 @@ export declare enum InliningMode {
 /**
  * A template type checking context for a program.
  *
- * The `TypeCheckContext` allows registration of components and their templates which need to be
- * type checked.
+ * The `TypeCheckContext` allows registration of directives to be type checked.
  */
 export declare class TypeCheckContextImpl implements TypeCheckContext {
     private config;
@@ -167,7 +169,7 @@ export declare class TypeCheckContextImpl implements TypeCheckContext {
      *
      * Implements `TypeCheckContext.addTemplate`.
      */
-    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, PipeMeta>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null, isStandalone: boolean, preserveWhitespaces: 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`.
      */
@@ -181,7 +183,7 @@ export declare class TypeCheckContextImpl implements TypeCheckContext {
     transform(sf: ts.SourceFile): string | null;
     finalize(): Map<AbsoluteFsPath, FileUpdate>;
     private addInlineTypeCheckBlock;
-    private pendingShimForComponent;
+    private pendingShimForClass;
     private dataForFile;
 }
-export declare function getTemplateDiagnostics(parseErrors: ParseError[], templateId: TemplateId, sourceMapping: TemplateSourceMapping): TemplateDiagnostic[];
+export declare function getTemplateDiagnostics(parseErrors: ParseError[], templateId: TypeCheckId, sourceMapping: SourceMapping): TemplateDiagnostic[];

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

@@ -7,8 +7,8 @@
  */
 import { AbsoluteSourceSpan, ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
-import { TemplateDiagnostic, TemplateId } from '../api';
-import { TemplateSourceResolver } from './tcb_util';
+import { TemplateDiagnostic, TypeCheckId } from '../api';
+import { TypeCheckSourceResolver } from './tcb_util';
 /**
  * Wraps the node in parenthesis such that inserted span comments become attached to the proper
  * node. This is an alias for `ts.factory.createParenthesizedExpression` with the benefit that it
@@ -34,10 +34,10 @@ export declare function wrapForTypeChecker(expr: ts.Expression): ts.Expression;
  */
 export declare function addParseSpanInfo(node: ts.Node, span: AbsoluteSourceSpan | ParseSourceSpan): void;
 /**
- * Adds a synthetic comment to the function declaration that contains the template id
+ * Adds a synthetic comment to the function declaration that contains the type checking ID
  * of the class declaration.
  */
-export declare function addTemplateId(tcb: ts.FunctionDeclaration, id: TemplateId): void;
+export declare function addTypeCheckId(tcb: ts.FunctionDeclaration, id: TypeCheckId): void;
 /**
  * Determines if the diagnostic should be reported. Some diagnostics are produced because of the
  * way TCBs are generated; those diagnostics should not be reported as type check errors of the
@@ -52,4 +52,4 @@ export declare function shouldReportDiagnostic(diagnostic: ts.Diagnostic): boole
  * should not be reported at all. This prevents diagnostics from non-TCB code in a user's source
  * file from being reported as type-check errors.
  */
-export declare function translateDiagnostic(diagnostic: ts.Diagnostic, resolver: TemplateSourceResolver): TemplateDiagnostic | null;
+export declare function translateDiagnostic(diagnostic: ts.Diagnostic, resolver: TypeCheckSourceResolver): TemplateDiagnostic | null;

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

@@ -5,9 +5,9 @@
  * 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 { TemplateDiagnostic, TemplateId } from '../api';
-import { TemplateSourceResolver } from './tcb_util';
+import { ParseSourceSpan, SchemaMetadata, TmplAstElement, TmplAstHostElement } from '@angular/compiler';
+import { TemplateDiagnostic, TypeCheckId } from '../api';
+import { TypeCheckSourceResolver } from './tcb_util';
 /**
  * Checks every non-Angular element/property processed in a template and potentially produces
  * `ts.Diagnostic`s related to improper usage.
@@ -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
@@ -55,7 +65,8 @@ export declare class RegistryDomSchemaChecker implements DomSchemaChecker {
     private resolver;
     private _diagnostics;
     get diagnostics(): ReadonlyArray<TemplateDiagnostic>;
-    constructor(resolver: TemplateSourceResolver);
-    checkElement(id: TemplateId, element: TmplAstElement, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
-    checkProperty(id: TemplateId, element: TmplAstElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
+    constructor(resolver: TypeCheckSourceResolver);
+    checkElement(id: TypeCheckId, element: TmplAstElement, 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/oob.d.ts

@@ -8,8 +8,8 @@
 import { BindingPipe, PropertyRead, PropertyWrite, TmplAstBoundAttribute, TmplAstBoundEvent, TmplAstElement, TmplAstForLoopBlock, TmplAstForLoopBlockEmpty, TmplAstHoverDeferredTrigger, TmplAstIfBlockBranch, TmplAstInteractionDeferredTrigger, TmplAstLetDeclaration, TmplAstReference, TmplAstSwitchBlockCase, TmplAstTemplate, TmplAstVariable, TmplAstViewportDeferredTrigger } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassDeclaration } from '../../reflection';
-import { TemplateDiagnostic, TemplateId } from '../api';
-import { TemplateSourceResolver } from './tcb_util';
+import { TemplateDiagnostic, TypeCheckId } from '../api';
+import { TypeCheckSourceResolver } from './tcb_util';
 /**
  * Collects `ts.Diagnostic`s on problems which occur in the template which aren't directly sourced
  * from Type Check Blocks.
@@ -25,83 +25,79 @@ export interface OutOfBandDiagnosticRecorder {
      * Reports a `#ref="target"` expression in the template for which a target directive could not be
      * found.
      *
-     * @param templateId the template type-checking ID of the template which contains the broken
-     * reference.
+     * @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(templateId: TemplateId, ref: TmplAstReference): void;
+    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 templateId the template type-checking ID of the template which contains the unknown
-     * pipe.
+     * @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.
      */
-    missingPipe(templateId: TemplateId, ast: BindingPipe): void;
+    missingPipe(id: TypeCheckId, ast: BindingPipe): void;
     /**
      * Reports usage of a pipe imported via `@Component.deferredImports` outside
      * of a `@defer` block in a template.
      *
-     * @param templateId the template type-checking ID of the template which contains the unknown
-     * pipe.
+     * @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(templateId: TemplateId, ast: BindingPipe): void;
+    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 templateId the template type-checking ID of the template which contains the unknown
-     * pipe.
+     * @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(templateId: TemplateId, element: TmplAstElement): void;
+    deferredComponentUsedEagerly(id: TypeCheckId, element: TmplAstElement): void;
     /**
      * Reports a duplicate declaration of a template variable.
      *
-     * @param templateId the template type-checking ID of the template which contains the duplicate
+     * @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(templateId: TemplateId, variable: TmplAstVariable, firstDecl: TmplAstVariable): void;
-    requiresInlineTcb(templateId: TemplateId, node: ClassDeclaration): void;
-    requiresInlineTypeConstructors(templateId: TemplateId, node: ClassDeclaration, directives: ClassDeclaration[]): void;
+    duplicateTemplateVar(id: TypeCheckId, variable: TmplAstVariable, firstDecl: TmplAstVariable): void;
+    requiresInlineTcb(id: TypeCheckId, node: ClassDeclaration): void;
+    requiresInlineTypeConstructors(id: TypeCheckId, node: ClassDeclaration, directives: ClassDeclaration[]): void;
     /**
      * Report a warning when structural directives support context guards, but the current
      * type-checking configuration prohibits their usage.
      */
-    suboptimalTypeInference(templateId: TemplateId, variables: TmplAstVariable[]): void;
+    suboptimalTypeInference(id: TypeCheckId, variables: TmplAstVariable[]): void;
     /**
      * Reports a split two way binding error message.
      */
-    splitTwoWayBinding(templateId: TemplateId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: ClassDeclaration, outputConsumer: ClassDeclaration | TmplAstElement): void;
+    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: ClassDeclaration, outputConsumer: ClassDeclaration | TmplAstElement): void;
     /** Reports required inputs that haven't been bound. */
-    missingRequiredInputs(templateId: TemplateId, element: TmplAstElement | TmplAstTemplate, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
+    missingRequiredInputs(id: TypeCheckId, element: TmplAstElement | TmplAstTemplate, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
     /**
      * Reports accesses of properties that aren't available in a `for` block's tracking expression.
      */
-    illegalForLoopTrackAccess(templateId: TemplateId, block: TmplAstForLoopBlock, access: PropertyRead): void;
+    illegalForLoopTrackAccess(id: TypeCheckId, block: TmplAstForLoopBlock, access: PropertyRead): void;
     /**
      * Reports deferred triggers that cannot access the element they're referring to.
      */
-    inaccessibleDeferredTriggerElement(templateId: TemplateId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
+    inaccessibleDeferredTriggerElement(id: TypeCheckId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
     /**
      * Reports cases where control flow nodes prevent content projection.
      */
-    controlFlowPreventingContentProjection(templateId: TemplateId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstSwitchBlockCase | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
+    controlFlowPreventingContentProjection(id: TypeCheckId, category: ts.DiagnosticCategory, 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(templateId: TemplateId, node: PropertyWrite, target: TmplAstLetDeclaration): void;
+    illegalWriteToLetDeclaration(id: TypeCheckId, node: PropertyWrite, target: TmplAstLetDeclaration): void;
     /** Reports cases where users are accessing an `@let` before it is defined.. */
-    letUsedBeforeDefinition(templateId: TemplateId, node: PropertyRead, target: TmplAstLetDeclaration): void;
+    letUsedBeforeDefinition(id: TypeCheckId, node: PropertyRead, target: TmplAstLetDeclaration): void;
     /**
      * Reports a `@let` declaration that conflicts with another symbol in the same scope.
      *
-     * @param templateId the template type-checking ID of the template which contains the declaration.
+     * @param id the type-checking ID of the template which contains the declaration.
      * @param current the `TmplAstLetDeclaration` which is invalid.
      */
-    conflictingDeclaration(templateId: TemplateId, current: TmplAstLetDeclaration): void;
+    conflictingDeclaration(id: TypeCheckId, current: TmplAstLetDeclaration): void;
 }
 export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnosticRecorder {
     private resolver;
@@ -111,22 +107,22 @@ export declare class OutOfBandDiagnosticRecorderImpl implements OutOfBandDiagnos
      * is ever produced per node.
      */
     private recordedPipes;
-    constructor(resolver: TemplateSourceResolver);
+    constructor(resolver: TypeCheckSourceResolver);
     get diagnostics(): ReadonlyArray<TemplateDiagnostic>;
-    missingReferenceTarget(templateId: TemplateId, ref: TmplAstReference): void;
-    missingPipe(templateId: TemplateId, ast: BindingPipe): void;
-    deferredPipeUsedEagerly(templateId: TemplateId, ast: BindingPipe): void;
-    deferredComponentUsedEagerly(templateId: TemplateId, element: TmplAstElement): void;
-    duplicateTemplateVar(templateId: TemplateId, variable: TmplAstVariable, firstDecl: TmplAstVariable): void;
-    requiresInlineTcb(templateId: TemplateId, node: ClassDeclaration): void;
-    requiresInlineTypeConstructors(templateId: TemplateId, node: ClassDeclaration, directives: ClassDeclaration[]): void;
-    suboptimalTypeInference(templateId: TemplateId, variables: TmplAstVariable[]): void;
-    splitTwoWayBinding(templateId: TemplateId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: ClassDeclaration, outputConsumer: ClassDeclaration | TmplAstElement): void;
-    missingRequiredInputs(templateId: TemplateId, element: TmplAstElement | TmplAstTemplate, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
-    illegalForLoopTrackAccess(templateId: TemplateId, block: TmplAstForLoopBlock, access: PropertyRead): void;
-    inaccessibleDeferredTriggerElement(templateId: TemplateId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
-    controlFlowPreventingContentProjection(templateId: TemplateId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstSwitchBlockCase | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
-    illegalWriteToLetDeclaration(templateId: TemplateId, node: PropertyWrite, target: TmplAstLetDeclaration): void;
-    letUsedBeforeDefinition(templateId: TemplateId, node: PropertyRead, target: TmplAstLetDeclaration): void;
-    conflictingDeclaration(templateId: TemplateId, decl: TmplAstLetDeclaration): void;
+    missingReferenceTarget(id: TypeCheckId, ref: TmplAstReference): void;
+    missingPipe(id: TypeCheckId, ast: BindingPipe): void;
+    deferredPipeUsedEagerly(id: TypeCheckId, ast: BindingPipe): void;
+    deferredComponentUsedEagerly(id: TypeCheckId, element: TmplAstElement): void;
+    duplicateTemplateVar(id: TypeCheckId, variable: TmplAstVariable, firstDecl: TmplAstVariable): void;
+    requiresInlineTcb(id: TypeCheckId, node: ClassDeclaration): void;
+    requiresInlineTypeConstructors(id: TypeCheckId, node: ClassDeclaration, directives: ClassDeclaration[]): void;
+    suboptimalTypeInference(id: TypeCheckId, variables: TmplAstVariable[]): void;
+    splitTwoWayBinding(id: TypeCheckId, input: TmplAstBoundAttribute, output: TmplAstBoundEvent, inputConsumer: ClassDeclaration, outputConsumer: ClassDeclaration | TmplAstElement): void;
+    missingRequiredInputs(id: TypeCheckId, element: TmplAstElement | TmplAstTemplate, directiveName: string, isComponent: boolean, inputAliases: string[]): void;
+    illegalForLoopTrackAccess(id: TypeCheckId, block: TmplAstForLoopBlock, access: PropertyRead): void;
+    inaccessibleDeferredTriggerElement(id: TypeCheckId, trigger: TmplAstHoverDeferredTrigger | TmplAstInteractionDeferredTrigger | TmplAstViewportDeferredTrigger): void;
+    controlFlowPreventingContentProjection(id: TypeCheckId, category: ts.DiagnosticCategory, projectionNode: TmplAstElement | TmplAstTemplate, componentName: string, slotSelector: string, controlFlowNode: TmplAstIfBlockBranch | TmplAstSwitchBlockCase | TmplAstForLoopBlock | TmplAstForLoopBlockEmpty, preservesWhitespaces: boolean): void;
+    illegalWriteToLetDeclaration(id: TypeCheckId, node: PropertyWrite, target: TmplAstLetDeclaration): void;
+    letUsedBeforeDefinition(id: TypeCheckId, node: PropertyRead, target: TmplAstLetDeclaration): void;
+    conflictingDeclaration(id: TypeCheckId, decl: TmplAstLetDeclaration): void;
 }