@angular/compiler-cli 14.0.0-next.7 → 14.0.0-rc.0

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

@@ -120,6 +120,16 @@ export declare enum ErrorCode {
      * Raised when a standalone directive/pipe is part of the declarations of an NgModule.
      */
     NGMODULE_DECLARATION_IS_STANDALONE = 6008,
+    /**
+     * Raised when a standalone component is part of the bootstrap list of an NgModule.
+     */
+    NGMODULE_BOOTSTRAP_IS_STANDALONE = 6009,
+    /**
+     * Indicates that an NgModule is declared with `id: module.id`. This is an anti-pattern that is
+     * disabled explicitly in the compiler, that was originally based on a misunderstanding of
+     * `NgModule.id`.
+     */
+    WARN_NGMODULE_ID_UNNECESSARY = 6100,
     /**
      * Not actually raised by the compiler, but reserved for documentation of a View Engine error when
      * a View Engine build depends on an Ivy-compiled NgModule.

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

@@ -15,6 +15,7 @@ import { ClassPropertyMapping, ClassPropertyName } from './property_mapping';
  * Metadata collected for an `NgModule`.
  */
 export interface NgModuleMeta {
+    kind: MetaKind.NgModule;
     ref: Reference<ClassDeclaration>;
     declarations: Reference<ClassDeclaration>[];
     imports: Reference<ClassDeclaration>[];
@@ -27,6 +28,20 @@ export interface NgModuleMeta {
      * because the module came from a .d.ts file).
      */
     rawDeclarations: ts.Expression | null;
+    /**
+     * The raw `ts.Expression` which gave rise to `imports`, if one exists.
+     *
+     * If this is `null`, then either no imports exist, or no expression was available (likely
+     * because the module came from a .d.ts file).
+     */
+    rawImports: ts.Expression | null;
+    /**
+     * The raw `ts.Expression` which gave rise to `exports`, if one exists.
+     *
+     * If this is `null`, then either no exports exist, or no expression was available (likely
+     * because the module came from a .d.ts file).
+     */
+    rawExports: ts.Expression | null;
 }
 /**
  * Typing metadata collected for a directive within an NgModule's scope.
@@ -67,15 +82,19 @@ export interface DirectiveTypeCheckMeta {
      */
     isGeneric: boolean;
 }
-export declare enum MetaType {
-    Pipe = 0,
-    Directive = 1
+/**
+ * Disambiguates different kinds of compiler metadata objects.
+ */
+export declare enum MetaKind {
+    Directive = 0,
+    Pipe = 1,
+    NgModule = 2
 }
 /**
  * Metadata collected for a directive within an NgModule's scope.
  */
 export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
-    type: MetaType.Directive;
+    kind: MetaKind.Directive;
     ref: Reference<ClassDeclaration>;
     /**
      * Unparsed selector of the directive, or null if the directive does not have a selector.
@@ -110,6 +129,14 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
      * Whether the directive is a standalone entity.
      */
     isStandalone: boolean;
+    /**
+     * For standalone components, the list of imported types.
+     */
+    imports: Reference<ClassDeclaration>[] | null;
+    /**
+     * For standalone components, the list of schemas declared.
+     */
+    schemas: SchemaMetadata[] | null;
 }
 /**
  * Metadata that describes a template guard for one of the directive's inputs.
@@ -132,7 +159,7 @@ export interface TemplateGuardMeta {
  * Metadata for a pipe within an NgModule's scope.
  */
 export interface PipeMeta {
-    type: MetaType.Pipe;
+    kind: MetaKind.Pipe;
     ref: Reference<ClassDeclaration>;
     name: string;
     nameExpr: ts.Expression | null;

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

@@ -12,6 +12,7 @@ import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { DirectiveMeta, DirectiveTypeCheckMeta, MetadataReader, NgModuleMeta, PipeMeta } from './api';
 import { ClassPropertyMapping } from './property_mapping';
 export declare function extractReferencesFromType(checker: ts.TypeChecker, def: ts.TypeNode, bestGuessOwningModule: OwningModule | null): Reference<ClassDeclaration>[];
+export declare function readBooleanType(type: ts.TypeNode): boolean | null;
 export declare function readStringType(type: ts.TypeNode): string | null;
 export declare function readStringMapType(type: ts.TypeNode): {
     [key: string]: string;

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

@@ -11,3 +11,4 @@ export { DynamicValue } from './src/dynamic';
 export { ForeignFunctionResolver, PartialEvaluator } from './src/interface';
 export { StaticInterpreter } from './src/interpreter';
 export { EnumValue, KnownFn, ResolvedValue, ResolvedValueArray, ResolvedValueMap } from './src/result';
+export { SyntheticValue } from './src/synthetic';

package/src/ngtsc/partial_evaluator/src/dynamic.d.ts

@@ -9,6 +9,7 @@
 import ts from 'typescript';
 import { Reference } from '../../imports';
 import { FunctionDefinition } from '../../reflection';
+import { SyntheticValue } from './synthetic';
 /**
  * The reason why a value cannot be determined statically.
  */
@@ -67,10 +68,15 @@ export declare const enum DynamicValueReason {
      * 'foo', 'bar' or any arbitrary string, so we evaluate it to a DynamicValue.
      */
     DYNAMIC_TYPE = 7,
+    /**
+     * A value could not be determined because one of the inputs to its evaluation is a synthetically
+     * produced value.
+     */
+    SYNTHETIC_INPUT = 8,
     /**
      * A value could not be determined statically for any reason other the above.
      */
-    UNKNOWN = 8
+    UNKNOWN = 9
 }
 /**
  * Represents a value which cannot be determined statically.
@@ -88,6 +94,7 @@ export declare class DynamicValue<R = unknown> {
     static fromInvalidExpressionType(node: ts.Node, value: unknown): DynamicValue<unknown>;
     static fromComplexFunctionCall(node: ts.Node, fn: FunctionDefinition): DynamicValue<FunctionDefinition>;
     static fromDynamicType(node: ts.TypeNode): DynamicValue;
+    static fromSyntheticInput(node: ts.Node, value: SyntheticValue<unknown>): DynamicValue<SyntheticValue<unknown>>;
     static fromUnknown(node: ts.Node): DynamicValue;
     isFromDynamicInput(this: DynamicValue<R>): this is DynamicValue<DynamicValue>;
     isFromDynamicString(this: DynamicValue<R>): this is DynamicValue;
@@ -109,5 +116,6 @@ export interface DynamicValueVisitor<R> {
     visitInvalidExpressionType(value: DynamicValue): R;
     visitComplexFunctionCall(value: DynamicValue<FunctionDefinition>): R;
     visitDynamicType(value: DynamicValue): R;
+    visitSyntheticInput(value: DynamicValue<SyntheticValue<unknown>>): R;
     visitUnknown(value: DynamicValue): R;
 }

package/src/ngtsc/partial_evaluator/src/interface.d.ts

@@ -10,8 +10,9 @@ import ts from 'typescript';
 import { Reference } from '../../imports';
 import { DependencyTracker } from '../../incremental/api';
 import { ReflectionHost } from '../../reflection';
+import { DynamicValue } from './dynamic';
 import { ResolvedValue } from './result';
-export declare type ForeignFunctionResolver = (node: Reference<ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression>, args: ReadonlyArray<ts.Expression>) => ts.Expression | null;
+export declare type ForeignFunctionResolver = (fn: Reference<ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression>, callExpr: ts.CallExpression, resolve: (expr: ts.Expression) => ResolvedValue, unresolvable: DynamicValue) => ResolvedValue;
 export declare class PartialEvaluator {
     private host;
     private checker;

package/src/ngtsc/partial_evaluator/src/result.d.ts

@@ -10,6 +10,7 @@ import ts from 'typescript';
 import { Reference } from '../../imports';
 import { Declaration } from '../../reflection';
 import { DynamicValue } from './dynamic';
+import { SyntheticValue } from './synthetic';
 /**
  * A value resulting from static resolution.
  *
@@ -17,7 +18,7 @@ import { DynamicValue } from './dynamic';
  * non-primitive value, or a special `DynamicValue` type which indicates the value was not
  * available statically.
  */
-export declare type ResolvedValue = number | boolean | string | null | undefined | Reference | EnumValue | ResolvedValueArray | ResolvedValueMap | ResolvedModule | KnownFn | DynamicValue<unknown>;
+export declare type ResolvedValue = number | boolean | string | null | undefined | Reference | EnumValue | ResolvedValueArray | ResolvedValueMap | ResolvedModule | KnownFn | SyntheticValue<unknown> | DynamicValue<unknown>;
 /**
  * An array of `ResolvedValue`s.
  *

package/src/ngtsc/partial_evaluator/src/synthetic.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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.io/license
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/partial_evaluator/src/synthetic" />
+/**
+ * A value produced which originated in a `ForeignFunctionResolver` and doesn't come from the
+ * template itself.
+ *
+ * Synthetic values cannot be further evaluated, and attempts to do so produce `DynamicValue`s
+ * instead.
+ */
+export declare class SyntheticValue<T> {
+    readonly value: T;
+    constructor(value: T);
+}

package/src/ngtsc/program_driver/src/ts_create_program_driver.d.ts

@@ -32,12 +32,12 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     getEnvironmentVariable: ((name: string) => string | undefined) | undefined;
     getNewLine: () => string;
     getParsedCommandLine: ((fileName: string) => ts.ParsedCommandLine | undefined) | undefined;
-    getSourceFileByPath: ((fileName: string, path: ts.Path, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
+    getSourceFileByPath: ((fileName: string, path: ts.Path, languageVersionOrOptions: ts.ScriptTarget | ts.CreateSourceFileOptions, onError?: ((message: string) => void) | undefined, shouldCreateNewSourceFile?: boolean | undefined) => ts.SourceFile | undefined) | undefined;
     readDirectory: ((rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number | undefined) => string[]) | undefined;
     readFile: (fileName: string) => string | undefined;
     realpath: ((path: string) => string) | undefined;
     resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingSourceFile?: ts.SourceFile | undefined) => (ts.ResolvedModule | undefined)[]) | undefined;
-    resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
+    resolveTypeReferenceDirectives: ((typeReferenceDirectiveNames: string[] | readonly ts.FileReference[], containingFile: string, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions, containingFileMode?: ts.ModuleKind.CommonJS | ts.ModuleKind.ESNext | undefined) => (ts.ResolvedTypeReferenceDirective | undefined)[]) | undefined;
     trace: ((s: string) => void) | undefined;
     useCaseSensitiveFileNames: () => boolean;
     getModuleResolutionCache: (() => ts.ModuleResolutionCache | undefined) | undefined;

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

@@ -6,8 +6,9 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/scope" />
-export { ExportScope, ScopeData } from './src/api';
-export { ComponentScopeReader, CompoundComponentScopeReader } from './src/component_scope';
+export { ComponentScopeKind, ComponentScopeReader, ExportScope, LocalModuleScope, ScopeData, StandaloneScope } from './src/api';
+export { CompoundComponentScopeReader } from './src/component_scope';
 export { DtsModuleScopeResolver, MetadataDtsModuleScopeResolver } from './src/dependency';
-export { DeclarationData, LocalModuleScope, LocalModuleScopeRegistry, LocalNgModuleData } from './src/local';
+export { DeclarationData, LocalModuleScopeRegistry, LocalNgModuleData } from './src/local';
 export { TypeCheckScope, TypeCheckScopeRegistry } from './src/typecheck';
+export { makeNotStandaloneDiagnostic, makeUnknownComponentImportDiagnostic } from './src/util';

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

@@ -6,25 +6,15 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/scope/src/api" />
-import { Reference } from '../../imports';
-import { DirectiveMeta, PipeMeta } from '../../metadata';
+import { SchemaMetadata } from '@angular/compiler';
+import { Reexport, Reference } from '../../imports';
+import { DirectiveMeta, NgModuleMeta, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 /**
  * Data for one of a given NgModule's scopes (either compilation scope or export scopes).
  */
 export interface ScopeData {
-    /**
-     * Directives in the exported scope of the module.
-     */
-    directives: DirectiveMeta[];
-    /**
-     * Pipes in the exported scope of the module.
-     */
-    pipes: PipeMeta[];
-    /**
-     * NgModules which contributed to the scope of the module.
-     */
-    ngModules: ClassDeclaration[];
+    dependencies: Array<DirectiveMeta | PipeMeta>;
     /**
      * Whether some module or component in this scope contains errors and is thus semantically
      * unreliable.
@@ -55,3 +45,35 @@ export interface RemoteScope {
      */
     pipes: Reference[];
 }
+export declare enum ComponentScopeKind {
+    NgModule = 0,
+    Standalone = 1
+}
+export interface LocalModuleScope extends ExportScope {
+    kind: ComponentScopeKind.NgModule;
+    ngModule: ClassDeclaration;
+    compilation: ScopeData;
+    reexports: Reexport[] | null;
+    schemas: SchemaMetadata[];
+}
+export interface StandaloneScope {
+    kind: ComponentScopeKind.Standalone;
+    dependencies: Array<DirectiveMeta | PipeMeta | NgModuleMeta>;
+    component: ClassDeclaration;
+    schemas: SchemaMetadata[];
+    isPoisoned: boolean;
+}
+export declare type ComponentScope = LocalModuleScope | StandaloneScope;
+/**
+ * Read information about the compilation scope of components.
+ */
+export interface ComponentScopeReader {
+    getScopeForComponent(clazz: ClassDeclaration): ComponentScope | null;
+    /**
+     * Get the `RemoteScope` required for this component, if any.
+     *
+     * If the component requires remote scoping, then retrieve the directives/pipes registered for
+     * that component. If remote scoping is not required (the common case), returns `null`.
+     */
+    getRemoteScope(clazz: ClassDeclaration): RemoteScope | null;
+}

package/src/ngtsc/scope/src/component_scope.d.ts

@@ -7,21 +7,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { ClassDeclaration } from '../../reflection';
-import { RemoteScope } from './api';
-import { LocalModuleScope } from './local';
-/**
- * Read information about the compilation scope of components.
- */
-export interface ComponentScopeReader {
-    getScopeForComponent(clazz: ClassDeclaration): LocalModuleScope | null;
-    /**
-     * Get the `RemoteScope` required for this component, if any.
-     *
-     * If the component requires remote scoping, then retrieve the directives/pipes registered for
-     * that component. If remote scoping is not required (the common case), returns `null`.
-     */
-    getRemoteScope(clazz: ClassDeclaration): RemoteScope | null;
-}
+import { ComponentScope, ComponentScopeReader, RemoteScope } from './api';
 /**
  * A `ComponentScopeReader` that reads from an ordered set of child readers until it obtains the
  * requested scope.
@@ -32,6 +18,6 @@ export interface ComponentScopeReader {
 export declare class CompoundComponentScopeReader implements ComponentScopeReader {
     private readers;
     constructor(readers: ComponentScopeReader[]);
-    getScopeForComponent(clazz: ClassDeclaration): LocalModuleScope | null;
+    getScopeForComponent(clazz: ClassDeclaration): ComponentScope | null;
     getRemoteScope(clazz: ClassDeclaration): RemoteScope | null;
 }

package/src/ngtsc/scope/src/local.d.ts

@@ -6,25 +6,17 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/scope/src/local" />
-import { SchemaMetadata } from '@angular/compiler';
 import ts from 'typescript';
-import { AliasingHost, Reexport, Reference, ReferenceEmitter } from '../../imports';
+import { AliasingHost, Reference, ReferenceEmitter } from '../../imports';
 import { DirectiveMeta, MetadataReader, MetadataRegistry, NgModuleMeta, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
-import { ExportScope, RemoteScope, ScopeData } from './api';
-import { ComponentScopeReader } from './component_scope';
+import { ComponentScopeReader, LocalModuleScope, RemoteScope } from './api';
 import { DtsModuleScopeResolver } from './dependency';
 export interface LocalNgModuleData {
     declarations: Reference<ClassDeclaration>[];
     imports: Reference<ClassDeclaration>[];
     exports: Reference<ClassDeclaration>[];
 }
-export interface LocalModuleScope extends ExportScope {
-    ngModule: ClassDeclaration;
-    compilation: ScopeData;
-    reexports: Reexport[] | null;
-    schemas: SchemaMetadata[];
-}
 /**
  * A registry which collects information about NgModules, Directives, Components, and Pipes which
  * are local (declared in the ts.Program being compiled), and can produce `LocalModuleScope`s
@@ -46,6 +38,7 @@ export interface LocalModuleScope extends ExportScope {
  */
 export declare class LocalModuleScopeRegistry implements MetadataRegistry, ComponentScopeReader {
     private localReader;
+    private fullReader;
     private dependencyScopeReader;
     private refEmitter;
     private aliasingHost;
@@ -91,7 +84,7 @@ export declare class LocalModuleScopeRegistry implements MetadataRegistry, Compo
      * Tracks which NgModules have directives/pipes that are declared in more than one module.
      */
     private modulesWithStructuralErrors;
-    constructor(localReader: MetadataReader, dependencyScopeReader: DtsModuleScopeResolver, refEmitter: ReferenceEmitter, aliasingHost: AliasingHost | null);
+    constructor(localReader: MetadataReader, fullReader: MetadataReader, dependencyScopeReader: DtsModuleScopeResolver, refEmitter: ReferenceEmitter, aliasingHost: AliasingHost | null);
     /**
      * Add an NgModule's data to the registry.
      */

package/src/ngtsc/scope/src/standalone.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @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.io/license
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/scope/src/standalone" />
+import { MetadataReader } from '../../metadata';
+import { ClassDeclaration } from '../../reflection';
+import { ComponentScopeReader, StandaloneScope } from './api';
+import { DtsModuleScopeResolver } from './dependency';
+import { LocalModuleScopeRegistry } from './local';
+/**
+ * Computes scopes for standalone components based on their `imports`, expanding imported NgModule
+ * scopes where necessary.
+ */
+export declare class StandaloneComponentScopeReader implements ComponentScopeReader {
+    private metaReader;
+    private localModuleReader;
+    private dtsModuleReader;
+    private cache;
+    constructor(metaReader: MetadataReader, localModuleReader: LocalModuleScopeRegistry, dtsModuleReader: DtsModuleScopeResolver);
+    getScopeForComponent(clazz: ClassDeclaration): StandaloneScope | null;
+    getRemoteScope(): null;
+}

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

@@ -11,7 +11,7 @@ import ts from 'typescript';
 import { Reference } from '../../imports';
 import { DirectiveMeta, MetadataReader } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
-import { ComponentScopeReader } from './component_scope';
+import { ComponentScopeReader } from './api';
 /**
  * The scope that is used for type-check code generation of a component template.
  */

package/src/ngtsc/scope/src/util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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.io/license
+ */
+/// <amd-module name="@angular/compiler-cli/src/ngtsc/scope/src/util" />
+import ts from 'typescript';
+import { Reference } from '../../imports';
+import { ClassDeclaration } from '../../reflection';
+import { ComponentScopeReader } from './api';
+export declare function getDiagnosticNode(ref: Reference<ClassDeclaration>, rawExpr: ts.Expression | null): ts.Expression;
+export declare function makeNotStandaloneDiagnostic(scopeReader: ComponentScopeReader, ref: Reference<ClassDeclaration>, rawExpr: ts.Expression | null, kind: 'component' | 'directive' | 'pipe'): ts.Diagnostic;
+export declare function makeUnknownComponentImportDiagnostic(ref: Reference<ClassDeclaration>, rawExpr: ts.Expression): ts.DiagnosticWithLocation;

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

@@ -61,5 +61,4 @@ export interface FactoryInfo {
 }
 export interface ModuleInfo {
     name: string;
-    hasId: boolean;
 }

package/src/ngtsc/transform/src/compilation.d.ts

@@ -8,6 +8,7 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/transform/src/compilation" />
 import { ConstantPool } from '@angular/compiler';
 import ts from 'typescript';
+import { SourceFileTypeIdentifier } from '../../core/api';
 import { IncrementalBuild } from '../../incremental/api';
 import { SemanticDepGraphUpdater, SemanticSymbol } from '../../incremental/semantic_graph';
 import { IndexingContext } from '../../indexer';
@@ -65,6 +66,7 @@ export declare class TraitCompiler implements ProgramTypeCheckAdapter {
     private compilationMode;
     private dtsTransforms;
     private semanticDepGraphUpdater;
+    private sourceFileTypeIdentifier;
     /**
      * Maps class declarations to their `ClassRecord`, which tracks the Ivy traits being applied to
      * those classes.
@@ -82,7 +84,7 @@ export declare class TraitCompiler implements ProgramTypeCheckAdapter {
     protected filesWithoutTraits: Set<ts.SourceFile>;
     private reexportMap;
     private handlersByName;
-    constructor(handlers: DecoratorHandler<unknown, unknown, SemanticSymbol | null, unknown>[], reflector: ReflectionHost, perf: PerfRecorder, incrementalBuild: IncrementalBuild<ClassRecord, unknown>, compileNonExportedClasses: boolean, compilationMode: CompilationMode, dtsTransforms: DtsTransformRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null);
+    constructor(handlers: DecoratorHandler<unknown, unknown, SemanticSymbol | null, unknown>[], reflector: ReflectionHost, perf: PerfRecorder, incrementalBuild: IncrementalBuild<ClassRecord, unknown>, compileNonExportedClasses: boolean, compilationMode: CompilationMode, dtsTransforms: DtsTransformRegistry, semanticDepGraphUpdater: SemanticDepGraphUpdater | null, sourceFileTypeIdentifier: SourceFileTypeIdentifier);
     analyzeSync(sf: ts.SourceFile): void;
     analyzeAsync(sf: ts.SourceFile): Promise<void> | undefined;
     private analyze;

package/src/ngtsc/tsc_plugin.d.ts

@@ -13,7 +13,7 @@ import { UnifiedModulesHost } from './core/api';
  * A `ts.CompilerHost` which also returns a list of input files, out of which the `ts.Program`
  * should be created.
  *
- * Currently mirrored from @bazel/typescript/internal/tsc_wrapped/plugin_api (with the naming of
+ * Currently mirrored from @bazel/concatjs/internal/tsc_wrapped/plugin_api (with the naming of
  * `fileNameToModuleName` corrected).
  */
 interface PluginCompilerHost extends ts.CompilerHost, Partial<UnifiedModulesHost> {

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

@@ -13,7 +13,7 @@ import { ErrorCode } from '../../diagnostics';
 import { FullTemplateMapping, NgTemplateDiagnostic, TypeCheckableDirectiveMeta } from './api';
 import { GlobalCompletion } from './completion';
 import { DirectiveInScope, PipeInScope } from './scope';
-import { ElementSymbol, ShimLocation, Symbol, TemplateSymbol } from './symbols';
+import { ElementSymbol, Symbol, TcbLocation, TemplateSymbol } from './symbols';
 /**
  * Interface to the Angular Template Type Checker to extract diagnostics and intelligence from the
  * compiler's understanding of component templates.
@@ -51,7 +51,7 @@ export interface TemplateTypeChecker {
      * Given a `shim` and position within the file, returns information for mapping back to a template
      * location.
      */
-    getTemplateMappingAtShimLocation(shimLocation: ShimLocation): FullTemplateMapping | null;
+    getTemplateMappingAtTcbLocation(tcbLocation: TcbLocation): FullTemplateMapping | null;
     /**
      * Get all `ts.Diagnostic`s currently available that pertain to the given component.
      *
@@ -98,16 +98,16 @@ export interface TemplateTypeChecker {
      */
     getGlobalCompletions(context: TmplAstTemplate | null, component: ts.ClassDeclaration, node: AST | TmplAstNode): GlobalCompletion | null;
     /**
-     * For the given expression node, retrieve a `ShimLocation` that can be used to perform
+     * For the given expression node, retrieve a `TcbLocation` that can be used to perform
      * autocompletion at that point in the expression, if such a location exists.
      */
-    getExpressionCompletionLocation(expr: PropertyRead | SafePropertyRead, component: ts.ClassDeclaration): ShimLocation | null;
+    getExpressionCompletionLocation(expr: PropertyRead | SafePropertyRead, component: ts.ClassDeclaration): TcbLocation | null;
     /**
      * For the given node represents a `LiteralPrimitive`(the `TextAttribute` represents a string
-     * literal), retrieve a `ShimLocation` that can be used to perform autocompletion at that point in
+     * literal), retrieve a `TcbLocation` that can be used to perform autocompletion at that point in
      * the node, if such a location exists.
      */
-    getLiteralCompletionLocation(strNode: LiteralPrimitive | TmplAstTextAttribute, component: ts.ClassDeclaration): ShimLocation | null;
+    getLiteralCompletionLocation(strNode: LiteralPrimitive | TmplAstTextAttribute, component: ts.ClassDeclaration): TcbLocation | null;
     /**
      * Get basic metadata on the directives which are in scope for the given component.
      */

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

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/api/completion" />
 import { TmplAstReference, TmplAstVariable } from '@angular/compiler';
-import { ShimLocation } from './symbols';
+import { TcbLocation } from './symbols';
 /**
  * An autocompletion source of any kind.
  */
@@ -51,7 +51,7 @@ export interface GlobalCompletion {
      * A location within the type-checking shim where TypeScript's completion APIs can be used to
      * access completions for the template's component context (component class members).
      */
-    componentContext: ShimLocation;
+    componentContext: TcbLocation;
     /**
      * `Map` of local references and variables that are visible at the requested level of the
      * template.
@@ -65,5 +65,5 @@ export interface GlobalCompletion {
      * A location within the type-checking shim where TypeScript's completion APIs can be used to
      * access completions for the AST node of the cursor position (primitive constants).
      */
-    nodeContext: ShimLocation | null;
+    nodeContext: TcbLocation | null;
 }