@angular/compiler-cli 14.0.0-next.9 → 14.0.0-rc.2

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/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/typecheck/api/api.d.ts

@@ -65,6 +65,7 @@ export interface TypeCheckBlockMetadata {
      * Schemas that apply to this template.
      */
     schemas: SchemaMetadata[];
+    isStandalone: boolean;
 }
 export interface TypeCtorMetadata {
     /**

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

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

@@ -33,8 +33,9 @@ export interface TypeCheckContext {
      * 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.
      */
-    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null): void;
+    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null, isStandalone: boolean): void;
 }
 /**
  * Interface to trigger generation of type-checking code for a program given a new

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

@@ -32,15 +32,22 @@ export declare type Symbol = InputBindingSymbol | OutputBindingSymbol | ElementS
  * A `Symbol` which declares a new named entity in the template scope.
  */
 export declare type TemplateDeclarationSymbol = ReferenceSymbol | VariableSymbol;
-/** Information about where a `ts.Node` can be found in the type check block shim file. */
-export interface ShimLocation {
+/**
+ * Information about where a `ts.Node` can be found in the type check file. This can either be
+ * a type-checking shim file, or an original source file for inline type check blocks.
+ */
+export interface TcbLocation {
     /**
      * The fully qualified path of the file which contains the generated TypeScript type check
      * code for the component's template.
      */
-    shimPath: AbsoluteFsPath;
-    /** The location in the shim file where node appears. */
-    positionInShimFile: number;
+    tcbPath: AbsoluteFsPath;
+    /**
+     * Whether the type check block exists in a type-checking shim file or is inline.
+     */
+    isShimFile: boolean;
+    /** The location in the file where node appears. */
+    positionInFile: number;
 }
 /**
  * A generic representation of some node in a template.
@@ -51,7 +58,7 @@ export interface TsNodeSymbolInfo {
     /** The `ts.Symbol` for the template node */
     tsSymbol: ts.Symbol | null;
     /** The position of the most relevant part of the template node. */
-    shimLocation: ShimLocation;
+    tcbLocation: TcbLocation;
 }
 /**
  * A representation of an expression in a component template.
@@ -66,7 +73,7 @@ export interface ExpressionSymbol {
      */
     tsSymbol: ts.Symbol | null;
     /** The position of the most relevant part of the expression. */
-    shimLocation: ShimLocation;
+    tcbLocation: TcbLocation;
 }
 /** Represents either an input or output binding in a template. */
 export interface BindingSymbol {
@@ -81,7 +88,7 @@ export interface BindingSymbol {
      */
     target: DirectiveSymbol | ElementSymbol | TemplateSymbol;
     /** The location in the shim file where the field access for the binding appears. */
-    shimLocation: ShimLocation;
+    tcbLocation: TcbLocation;
 }
 /**
  * A representation of an input binding in a component template.
@@ -141,14 +148,14 @@ export interface ReferenceSymbol {
      * ```
      * This `targetLocation` is `[_t1 variable declaration].getStart()`.
      */
-    targetLocation: ShimLocation;
+    targetLocation: TcbLocation;
     /**
      * The location in the TCB for the identifier node in the reference variable declaration.
      * For example, given a variable declaration statement for a template reference:
      * `var _t2 = _t1`, this location is `[_t2 node].getStart()`. This location can
      * be used to find references to the variable within the template.
      */
-    referenceVarLocation: ShimLocation;
+    referenceVarLocation: TcbLocation;
 }
 /**
  * A representation of a context variable in a component template.
@@ -175,12 +182,12 @@ export interface VariableSymbol {
     /**
      * The location in the shim file for the identifier that was declared for the template variable.
      */
-    localVarLocation: ShimLocation;
+    localVarLocation: TcbLocation;
     /**
      * The location in the shim file for the initializer node of the variable that represents the
      * template variable.
      */
-    initializerLocation: ShimLocation;
+    initializerLocation: TcbLocation;
 }
 /**
  * A representation of an element in a component template.
@@ -194,7 +201,7 @@ export interface ElementSymbol {
     /** A list of directives applied to the element. */
     directives: DirectiveSymbol[];
     /** The location in the shim file for the variable that holds the type of the element. */
-    shimLocation: ShimLocation;
+    tcbLocation: TcbLocation;
     templateNode: TmplAstElement;
 }
 export interface TemplateSymbol {
@@ -212,7 +219,7 @@ export interface DirectiveSymbol extends DirectiveInScope {
     /** The `ts.Type` for the class declaration. */
     tsType: ts.Type;
     /** The location in the shim file for the variable that holds the type of the directive. */
-    shimLocation: ShimLocation;
+    tcbLocation: TcbLocation;
 }
 /**
  * A representation of an attribute on an element or template. These bindings aren't currently
@@ -237,7 +244,7 @@ export interface PipeSymbol {
      */
     tsSymbol: ts.Symbol | null;
     /** The position of the transform call in the template. */
-    shimLocation: ShimLocation;
+    tcbLocation: TcbLocation;
     /** The symbol for the pipe class as an instance that appears in the TCB. */
     classSymbol: ClassSymbol;
 }
@@ -248,5 +255,5 @@ export interface ClassSymbol {
     /** The `ts.Symbol` for class. */
     tsSymbol: SymbolWithValueDeclaration;
     /** The position for the variable declaration for the class instance. */
-    shimLocation: ShimLocation;
+    tcbLocation: TcbLocation;
 }

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

@@ -16,7 +16,7 @@ import { PerfRecorder } from '../../perf';
 import { ProgramDriver } from '../../program_driver';
 import { ReflectionHost } from '../../reflection';
 import { ComponentScopeReader, TypeCheckScopeRegistry } from '../../scope';
-import { DirectiveInScope, ElementSymbol, FullTemplateMapping, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PipeInScope, ProgramTypeCheckAdapter, ShimLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
+import { DirectiveInScope, ElementSymbol, FullTemplateMapping, GlobalCompletion, NgTemplateDiagnostic, OptimizeFor, PipeInScope, ProgramTypeCheckAdapter, TcbLocation, TemplateSymbol, TemplateTypeChecker, TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
 import { ShimTypeCheckingData } from './context';
 import { TemplateSourceManager } from './source';
 /**
@@ -75,8 +75,9 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     getTemplate(component: ts.ClassDeclaration): TmplAstNode[] | null;
     private getLatestComponentState;
     isTrackedTypeCheckFile(filePath: AbsoluteFsPath): boolean;
+    private getFileRecordForTcbLocation;
     private getFileAndShimRecordsForPath;
-    getTemplateMappingAtShimLocation({ shimPath, positionInShimFile }: ShimLocation): FullTemplateMapping | null;
+    getTemplateMappingAtTcbLocation(tcbLocation: TcbLocation): FullTemplateMapping | null;
     generateAllTypeCheckBlocks(): void;
     /**
      * Retrieve type-checking and template parse diagnostics from the given `ts.SourceFile` using the
@@ -86,8 +87,8 @@ export declare class TemplateTypeCheckerImpl implements TemplateTypeChecker {
     getDiagnosticsForComponent(component: ts.ClassDeclaration): ts.Diagnostic[];
     getTypeCheckBlock(component: ts.ClassDeclaration): ts.Node | null;
     getGlobalCompletions(context: TmplAstTemplate | null, component: ts.ClassDeclaration, node: AST | TmplAstNode): GlobalCompletion | null;
-    getExpressionCompletionLocation(ast: PropertyRead | SafePropertyRead, component: ts.ClassDeclaration): ShimLocation | null;
-    getLiteralCompletionLocation(node: LiteralPrimitive | TmplAstTextAttribute, component: ts.ClassDeclaration): ShimLocation | null;
+    getExpressionCompletionLocation(ast: PropertyRead | SafePropertyRead, component: ts.ClassDeclaration): TcbLocation | null;
+    getLiteralCompletionLocation(node: LiteralPrimitive | TmplAstTextAttribute, component: ts.ClassDeclaration): TcbLocation | null;
     invalidateClass(clazz: ts.ClassDeclaration): void;
     makeTemplateDiagnostic<T extends ErrorCode>(clazz: ts.ClassDeclaration, sourceSpan: ParseSourceSpan, category: ts.DiagnosticCategory, errorCode: T, message: string, relatedInformation?: {
         text: string;

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

@@ -9,7 +9,7 @@
 import { AST, LiteralPrimitive, PropertyRead, PropertyWrite, SafePropertyRead, TmplAstNode, TmplAstTemplate, TmplAstTextAttribute } from '@angular/compiler';
 import ts from 'typescript';
 import { AbsoluteFsPath } from '../../file_system';
-import { GlobalCompletion, ShimLocation } from '../api';
+import { GlobalCompletion, TcbLocation } from '../api';
 import { TemplateData } from './context';
 /**
  * Powers autocompletion for a specific component.
@@ -20,7 +20,8 @@ import { TemplateData } from './context';
 export declare class CompletionEngine {
     private tcb;
     private data;
-    private shimPath;
+    private tcbPath;
+    private tcbIsShim;
     private componentContext;
     /**
      * Cache of completions for various levels of the template, including the root template (`null`).
@@ -28,7 +29,7 @@ export declare class CompletionEngine {
      */
     private templateContextCache;
     private expressionCompletionCache;
-    constructor(tcb: ts.Node, data: TemplateData, shimPath: AbsoluteFsPath);
+    constructor(tcb: ts.Node, data: TemplateData, tcbPath: AbsoluteFsPath, tcbIsShim: boolean);
     /**
      * Get global completions within the given template context and AST node.
      *
@@ -38,8 +39,8 @@ export declare class CompletionEngine {
      * @param node the given AST node
      */
     getGlobalCompletions(context: TmplAstTemplate | null, node: AST | TmplAstNode): GlobalCompletion | null;
-    getExpressionCompletionLocation(expr: PropertyRead | PropertyWrite | SafePropertyRead): ShimLocation | null;
-    getLiteralCompletionLocation(expr: LiteralPrimitive | TmplAstTextAttribute): ShimLocation | null;
+    getExpressionCompletionLocation(expr: PropertyRead | PropertyWrite | SafePropertyRead): TcbLocation | null;
+    getLiteralCompletionLocation(expr: LiteralPrimitive | TmplAstTextAttribute): TcbLocation | null;
     /**
      * Get global completions within the given template context - either a `TmplAstTemplate` embedded
      * view, or `null` for the root context.

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

@@ -167,7 +167,7 @@ export declare class TypeCheckContextImpl implements TypeCheckContext {
      *
      * Implements `TypeCheckContext.addTemplate`.
      */
-    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null): void;
+    addTemplate(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, binder: R3TargetBinder<TypeCheckableDirectiveMeta>, template: TmplAstNode[], pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[], sourceMapping: TemplateSourceMapping, file: ParseSourceFile, parseErrors: ParseError[] | null, isStandalone: boolean): void;
     /**
      * Record a type constructor for the given `node` with the given `ctorMetadata`.
      */

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

@@ -31,8 +31,10 @@ export interface DomSchemaChecker {
      * @param element the element node in question.
      * @param schemas any active schemas for the template, which might affect the validity of the
      * element.
+     * @param hostIsStandalone boolean indicating whether the element's host is a standalone
+     *     component.
      */
-    checkElement(id: string, element: TmplAstElement, schemas: SchemaMetadata[]): void;
+    checkElement(id: string, element: TmplAstElement, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
     /**
      * Check a property binding on an element and record any diagnostics about it.
      *
@@ -55,6 +57,6 @@ export declare class RegistryDomSchemaChecker implements DomSchemaChecker {
     private _diagnostics;
     get diagnostics(): ReadonlyArray<TemplateDiagnostic>;
     constructor(resolver: TemplateSourceResolver);
-    checkElement(id: TemplateId, element: TmplAstElement, schemas: SchemaMetadata[]): void;
+    checkElement(id: TemplateId, element: TmplAstElement, schemas: SchemaMetadata[], hostIsStandalone: boolean): void;
     checkProperty(id: TemplateId, element: TmplAstElement, name: string, span: ParseSourceSpan, schemas: SchemaMetadata[]): void;
 }

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

@@ -19,13 +19,14 @@ import { TemplateData } from './context';
  * replaced if the component's template changes.
  */
 export declare class SymbolBuilder {
-    private readonly shimPath;
+    private readonly tcbPath;
+    private readonly tcbIsShim;
     private readonly typeCheckBlock;
     private readonly templateData;
     private readonly componentScopeReader;
     private readonly getTypeChecker;
     private symbolCache;
-    constructor(shimPath: AbsoluteFsPath, typeCheckBlock: ts.Node, templateData: TemplateData, componentScopeReader: ComponentScopeReader, getTypeChecker: () => ts.TypeChecker);
+    constructor(tcbPath: AbsoluteFsPath, tcbIsShim: boolean, typeCheckBlock: ts.Node, templateData: TemplateData, componentScopeReader: ComponentScopeReader, getTypeChecker: () => ts.TypeChecker);
     getSymbol(node: TmplAstTemplate | TmplAstElement): TemplateSymbol | ElementSymbol | null;
     getSymbol(node: TmplAstReference | TmplAstVariable): ReferenceSymbol | VariableSymbol | null;
     getSymbol(node: AST | TmplAstNode): Symbol | null;
@@ -42,5 +43,5 @@ export declare class SymbolBuilder {
     private getSymbolOfPipe;
     private getSymbolOfTemplateExpression;
     private getSymbolOfTsNode;
-    private getShimPositionForNode;
+    private getTcbPositionForNode;
 }

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

@@ -45,6 +45,13 @@ export declare function tsCreateVariable(id: ts.Identifier, initializer: ts.Expr
  * Construct a `ts.CallExpression` that calls a method on a receiver.
  */
 export declare function tsCallMethod(receiver: ts.Expression, methodName: string, args?: ts.Expression[]): ts.CallExpression;
+/**
+ * Updates a `ts.TypeParameter` declaration.
+ *
+ * TODO(crisbeto): this is a backwards-compatibility layer for versions of TypeScript less than 4.7.
+ * We should remove it once we have dropped support for the older versions.
+ */
+export declare function tsUpdateTypeParameterDeclaration(node: ts.TypeParameterDeclaration, name: ts.Identifier, constraint: ts.TypeNode | undefined, defaultType: ts.TypeNode | undefined): ts.TypeParameterDeclaration;
 export declare function checkIfClassIsExported(node: ClassDeclaration): boolean;
 export declare function checkIfGenericTypesAreUnbound(node: ClassDeclaration<ts.ClassDeclaration>): boolean;
 export declare function isAccessExpression(node: ts.Node): node is ts.ElementAccessExpression | ts.PropertyAccessExpression;

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

@@ -129,8 +129,9 @@ export declare class Context {
     readonly boundTarget: BoundTarget<TypeCheckableDirectiveMeta>;
     private pipes;
     readonly schemas: SchemaMetadata[];
+    readonly hostIsStandalone: boolean;
     private nextId;
-    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TemplateId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[]);
+    constructor(env: Environment, domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder, id: TemplateId, boundTarget: BoundTarget<TypeCheckableDirectiveMeta>, pipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, schemas: SchemaMetadata[], hostIsStandalone: boolean);
     /**
      * Allocate a new variable name for use within the `Context`.
      *