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

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.2";
 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.2",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -52,7 +52,7 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "20.0.0-next.1",
+    "@angular/compiler": "20.0.0-next.2",
     "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/metadata.d.ts

@@ -8,7 +8,7 @@
 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';
@@ -43,7 +43,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.
      */

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/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

@@ -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

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/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

@@ -24,16 +24,17 @@ export interface ExternalResource extends Resource {
 }
 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;
 }
 /**
- * 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
@@ -45,10 +46,10 @@ export declare class ResourceRegistry {
     private componentToStylesMap;
     private externalStyleToComponentsMap;
     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>;
 }

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.Expression;
 }
 /**
- * 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

@@ -12,7 +12,7 @@ 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';
@@ -50,10 +50,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.
      *

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

@@ -10,34 +10,43 @@ 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;
+}
 /**
  * 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 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, 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/src/checker.d.ts

@@ -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
@@ -82,7 +82,7 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     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 +150,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.
      *