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

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, 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 { 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,28 @@ 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[];
 }
 /**
  * Data for an input file which is still in the process of template type-checking code generation.
@@ -69,7 +68,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 +88,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 +101,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 +138,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 +165,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, isStandalone: boolean): void;
     /**
      * Record a type constructor for the given `node` with the given `ctorMetadata`.
      */
@@ -181,7 +179,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

@@ -6,8 +6,8 @@
  * 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 { 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.
@@ -55,7 +55,7 @@ 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;
+    checkProperty(id: TypeCheckId, element: TmplAstElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
 }

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;
 }

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

@@ -7,35 +7,35 @@
  */
 import { AbsoluteSourceSpan, ParseSourceFile, ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
-import { TemplateId, TemplateSourceMapping } from '../api';
-import { TemplateSourceResolver } from './tcb_util';
+import { TypeCheckId, SourceMapping } from '../api';
+import { TypeCheckSourceResolver } from './tcb_util';
 /**
  * Represents the source of a template that was processed during type-checking. This information is
  * used when translating parse offsets in diagnostics back to their original line/column location.
  */
 export declare class TemplateSource {
-    readonly mapping: TemplateSourceMapping;
+    readonly mapping: SourceMapping;
     private file;
     private lineStarts;
-    constructor(mapping: TemplateSourceMapping, file: ParseSourceFile);
+    constructor(mapping: SourceMapping, file: ParseSourceFile);
     toParseSourceSpan(start: number, end: number): ParseSourceSpan;
     private toParseLocation;
     private acquireLineStarts;
 }
 /**
- * Assigns IDs to templates and keeps track of their origins.
+ * Assigns IDs for type checking and keeps track of their origins.
  *
- * Implements `TemplateSourceResolver` to resolve the source of a template based on these IDs.
+ * Implements `TypeCheckSourceResolver` to resolve the source of a template based on these IDs.
  */
-export declare class TemplateSourceManager implements TemplateSourceResolver {
+export declare class DirectiveSourceManager implements TypeCheckSourceResolver {
     /**
      * This map keeps track of all template sources that have been type-checked by the id that is
      * attached to a TCB's function declaration as leading trivia. This enables translation of
      * diagnostics produced for TCB code to their source location in the template.
      */
     private templateSources;
-    getTemplateId(node: ts.ClassDeclaration): TemplateId;
-    captureSource(node: ts.ClassDeclaration, mapping: TemplateSourceMapping, file: ParseSourceFile): TemplateId;
-    getSourceMapping(id: TemplateId): TemplateSourceMapping;
-    toParseSourceSpan(id: TemplateId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
+    getTypeCheckId(node: ts.ClassDeclaration): TypeCheckId;
+    captureTemplateSource(id: TypeCheckId, mapping: SourceMapping, file: ParseSourceFile): void;
+    getTemplateSourceMapping(id: TypeCheckId): SourceMapping;
+    toTemplateParseSourceSpan(id: TypeCheckId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
 }

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

@@ -9,25 +9,25 @@ import { AbsoluteSourceSpan, ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
 import { ClassDeclaration, ReflectionHost } from '../../../../src/ngtsc/reflection';
 import { Reference } from '../../imports';
-import { FullTemplateMapping, SourceLocation, TemplateId, TemplateSourceMapping } from '../api';
+import { FullSourceMapping, SourceLocation, TypeCheckId, SourceMapping } from '../api';
 import { ReferenceEmitEnvironment } from './reference_emit_environment';
 /**
- * Adapter interface which allows the template type-checking diagnostics code to interpret offsets
- * in a TCB and map them back to original locations in the template.
+ * Adapter interface which allows the directive type-checking diagnostics code to interpret offsets
+ * in a TCB and map them back to their original locations.
  */
-export interface TemplateSourceResolver {
-    getTemplateId(node: ts.ClassDeclaration): TemplateId;
+export interface TypeCheckSourceResolver {
+    getTypeCheckId(node: ts.ClassDeclaration): TypeCheckId;
     /**
-     * For the given template id, retrieve the original source mapping which describes how the offsets
-     * in the template should be interpreted.
+     * For the given type checking id, retrieve the original source mapping which describes how the
+     * offsets in the template should be interpreted.
      */
-    getSourceMapping(id: TemplateId): TemplateSourceMapping;
+    getTemplateSourceMapping(id: TypeCheckId): SourceMapping;
     /**
-     * Convert an absolute source span associated with the given template id into a full
-     * `ParseSourceSpan`. The returned parse span has line and column numbers in addition to only
-     * absolute offsets and gives access to the original template source.
+     * Convert an absolute source span coming from the template associated with the given type
+     * checking id into a full `ParseSourceSpan`. The returned parse span has line and column
+     * numbers in addition to only absolute offsets and gives access to the original source code.
      */
-    toParseSourceSpan(id: TemplateId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
+    toTemplateParseSourceSpan(id: TypeCheckId, span: AbsoluteSourceSpan): ParseSourceSpan | null;
 }
 /**
  * Indicates whether a particular component requires an inline type check block.
@@ -51,9 +51,9 @@ export declare enum TcbInliningRequirement {
     None = 2
 }
 export declare function requiresInlineTypeCheckBlock(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, env: ReferenceEmitEnvironment, usedPipes: Reference<ClassDeclaration<ts.ClassDeclaration>>[], reflector: ReflectionHost): TcbInliningRequirement;
-/** Maps a shim position back to a template location. */
-export declare function getTemplateMapping(shimSf: ts.SourceFile, position: number, resolver: TemplateSourceResolver, isDiagnosticRequest: boolean): FullTemplateMapping | null;
-export declare function findTypeCheckBlock(file: ts.SourceFile, id: TemplateId, isDiagnosticRequest: boolean): ts.Node | null;
+/** Maps a shim position back to a source code location. */
+export declare function getSourceMapping(shimSf: ts.SourceFile, position: number, resolver: TypeCheckSourceResolver, isDiagnosticRequest: boolean): FullSourceMapping | null;
+export declare function findTypeCheckBlock(file: ts.SourceFile, id: TypeCheckId, isDiagnosticRequest: boolean): ts.Node | null;
 /**
  * Traverses up the AST starting from the given node to extract the source location from comments
  * that have been emitted into the TCB. If the node does not exist within a TCB, or if an ignore

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

@@ -10,7 +10,7 @@ import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
 import { ComponentScopeReader } from '../../scope';
 import { ElementSymbol, LetDeclarationSymbol, ReferenceSymbol, Symbol, TemplateSymbol, VariableSymbol } from '../api';
-import { TemplateData } from './context';
+import { TypeCheckData } from './context';
 /**
  * Generates and caches `Symbol`s for various template structures for a given component.
  *
@@ -21,11 +21,11 @@ export declare class SymbolBuilder {
     private readonly tcbPath;
     private readonly tcbIsShim;
     private readonly typeCheckBlock;
-    private readonly templateData;
+    private readonly typeCheckData;
     private readonly componentScopeReader;
     private readonly getTypeChecker;
     private symbolCache;
-    constructor(tcbPath: AbsoluteFsPath, tcbIsShim: boolean, typeCheckBlock: ts.Node, templateData: TemplateData, componentScopeReader: ComponentScopeReader, getTypeChecker: () => ts.TypeChecker);
+    constructor(tcbPath: AbsoluteFsPath, tcbIsShim: boolean, typeCheckBlock: ts.Node, typeCheckData: TypeCheckData, componentScopeReader: ComponentScopeReader, getTypeChecker: () => ts.TypeChecker);
     getSymbol(node: TmplAstTemplate | TmplAstElement): TemplateSymbol | ElementSymbol | null;
     getSymbol(node: TmplAstReference | TmplAstVariable | TmplAstLetDeclaration): ReferenceSymbol | VariableSymbol | LetDeclarationSymbol | null;
     getSymbol(node: AST | TmplAstNode): Symbol | null;

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

@@ -10,7 +10,7 @@ import ts from 'typescript';
 import { Reference } from '../../imports';
 import { PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
-import { TemplateId, TypeCheckableDirectiveMeta, TypeCheckBlockMetadata } from '../api';
+import { TypeCheckId, TypeCheckableDirectiveMeta, TypeCheckBlockMetadata } from '../api';
 import { DomSchemaChecker } from './dom';
 import { Environment } from './environment';
 import { OutOfBandDiagnosticRecorder } from './oob';
@@ -127,14 +127,14 @@ export declare class Context {
     readonly env: Environment;
     readonly domSchemaChecker: DomSchemaChecker;
     readonly oobRecorder: OutOfBandDiagnosticRecorder;
-    readonly id: TemplateId;
+    readonly id: TypeCheckId;
     readonly boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
     private pipes;
     readonly schemas: SchemaMetadata[];
     readonly hostIsStandalone: boolean;
     readonly hostPreserveWhitespaces: boolean;
     private nextId;
-    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TemplateId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, PipeMeta>, schemas: SchemaMetadata[], hostIsStandalone: boolean, hostPreserveWhitespaces: boolean);
+    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TypeCheckId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, PipeMeta> | null, schemas: SchemaMetadata[], hostIsStandalone: boolean, hostPreserveWhitespaces: boolean);
     /**
      * Allocate a new variable name for use within the `Context`.
      *