@angular/compiler-cli 14.0.0-next.0 → 14.0.0-next.11

package/src/ngtsc/imports/src/emitter.d.ts

@@ -39,7 +39,20 @@ export declare enum ImportFlags {
      * declaration that is not retained during emit. Including this flag allows to emit references to
      * type-only declarations as used in e.g. template type-checking.
      */
-    AllowTypeImports = 4
+    AllowTypeImports = 4,
+    /**
+     * Indicates that importing from a declaration file using a relative import path is allowed.
+     *
+     * The generated imports should normally use module specifiers that are valid for use in
+     * production code, where arbitrary relative imports into e.g. node_modules are not allowed. For
+     * template type-checking code it is however acceptable to use relative imports, as such files are
+     * never emitted to JS code.
+     *
+     * Non-declaration files have to be contained within a configured `rootDir` so using relative
+     * paths may not be possible for those, hence this flag only applies when importing from a
+     * declaration file.
+     */
+    AllowRelativeDtsImports = 8
 }
 /**
  * An emitter strategy has the ability to indicate which `ts.SourceFile` is being imported by the
@@ -191,8 +204,9 @@ export declare class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
 export declare class LogicalProjectStrategy implements ReferenceEmitStrategy {
     private reflector;
     private logicalFs;
+    private relativePathStrategy;
     constructor(reflector: ReflectionHost, logicalFs: LogicalFileSystem);
-    emit(ref: Reference, context: ts.SourceFile): ReferenceEmitResult | null;
+    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): ReferenceEmitResult | null;
 }
 /**
  * A `ReferenceEmitStrategy` which constructs relatives paths between `ts.SourceFile`s.

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

@@ -120,5 +120,6 @@ export interface IndexedComponent {
         isInline: boolean;
         file: ParseSourceFile;
     };
+    errors: Error[];
 }
 export {};

package/src/ngtsc/indexer/src/template.d.ts

@@ -15,4 +15,7 @@ import { ComponentMeta } from './context';
  * @param boundTemplate bound template target, which can be used for querying expression targets.
  * @return identifiers in template
  */
-export declare function getTemplateIdentifiers(boundTemplate: BoundTarget<ComponentMeta>): Set<TopLevelIdentifier>;
+export declare function getTemplateIdentifiers(boundTemplate: BoundTarget<ComponentMeta>): {
+    identifiers: Set<TopLevelIdentifier>;
+    errors: Error[];
+};

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

@@ -27,6 +27,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.
@@ -106,6 +120,10 @@ export interface DirectiveMeta extends T2DirectiveMeta, DirectiveTypeCheckMeta {
      * Whether the directive is likely a structural directive (injects `TemplateRef`).
      */
     isStructural: boolean;
+    /**
+     * Whether the directive is a standalone entity.
+     */
+    isStandalone: boolean;
 }
 /**
  * Metadata that describes a template guard for one of the directive's inputs.
@@ -132,6 +150,7 @@ export interface PipeMeta {
     ref: Reference<ClassDeclaration>;
     name: string;
     nameExpr: ts.Expression | null;
+    isStandalone: boolean;
 }
 /**
  * Reads metadata for directives, pipes, and modules from a particular source, such as .d.ts files

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 { ComponentScopeReader, ExportScope, LocalModuleScope, ScopeData } 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 } from './src/util';

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

@@ -6,7 +6,8 @@
  * 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 { SchemaMetadata } from '@angular/compiler';
+import { Reexport, Reference } from '../../imports';
 import { DirectiveMeta, PipeMeta } from '../../metadata';
 import { ClassDeclaration } from '../../reflection';
 /**
@@ -21,10 +22,6 @@ export interface ScopeData {
      * Pipes in the exported scope of the module.
      */
     pipes: PipeMeta[];
-    /**
-     * NgModules which contributed to the scope of the module.
-     */
-    ngModules: ClassDeclaration[];
     /**
      * Whether some module or component in this scope contains errors and is thus semantically
      * unreliable.
@@ -55,3 +52,22 @@ export interface RemoteScope {
      */
     pipes: Reference[];
 }
+export interface LocalModuleScope extends ExportScope {
+    ngModule: ClassDeclaration;
+    compilation: ScopeData;
+    reexports: Reexport[] | null;
+    schemas: SchemaMetadata[];
+}
+/**
+ * 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;
+}

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 { ComponentScopeReader, LocalModuleScope, RemoteScope } from './api';
 /**
  * A `ComponentScopeReader` that reads from an ordered set of child readers until it obtains the
  * requested scope.

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/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,14 @@
+/**
+ * @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;

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

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

package/src/ngtsc/translator/src/typescript_ast_factory.d.ts

@@ -21,10 +21,7 @@ export declare class TypeScriptAstFactory implements AstFactory<ts.Statement, ts
     createBinaryExpression(leftOperand: ts.Expression, operator: BinaryOperator, rightOperand: ts.Expression): ts.Expression;
     createBlock(body: ts.Statement[]): ts.Statement;
     createCallExpression(callee: ts.Expression, args: ts.Expression[], pure: boolean): ts.Expression;
-    createConditional: {
-        (condition: ts.Expression, whenTrue: ts.Expression, whenFalse: ts.Expression): ts.ConditionalExpression;
-        (condition: ts.Expression, questionToken: ts.QuestionToken, whenTrue: ts.Expression, colonToken: ts.ColonToken, whenFalse: ts.Expression): ts.ConditionalExpression;
-    };
+    createConditional(condition: ts.Expression, whenTrue: ts.Expression, whenFalse: ts.Expression): ts.Expression;
     createElementAccess: (expression: ts.Expression, index: number | ts.Expression) => ts.ElementAccessExpression;
     createExpressionStatement: (expression: ts.Expression) => ts.ExpressionStatement;
     createFunctionDeclaration(functionName: string, parameters: string[], body: ts.Statement): ts.Statement;

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

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

@@ -12,8 +12,9 @@ import { TemplateDiagnostic, TemplateId } from '../api';
 import { TemplateSourceResolver } 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.createParen` with the benefit that it signifies that the
- * inserted parenthesis are for diagnostic purposes, not for correctness of the rendered TCB code.
+ * node. This is an alias for `ts.factory.createParenthesizedExpression` with the benefit that it
+ * signifies that the inserted parenthesis are for diagnostic purposes, not for correctness of the
+ * rendered TCB code.
  *
  * Note that it is important that nodes and its attached comment are not wrapped into parenthesis
  * by default, as it prevents correct translation of e.g. diagnostics produced for incorrect method
@@ -23,9 +24,9 @@ import { TemplateSourceResolver } from './tcb_util';
 export declare function wrapForDiagnostics(expr: ts.Expression): ts.Expression;
 /**
  * Wraps the node in parenthesis such that inserted span comments become attached to the proper
- * node. This is an alias for `ts.createParen` with the benefit that it signifies that the
- * inserted parenthesis are for use by the type checker, not for correctness of the rendered TCB
- * code.
+ * node. This is an alias for `ts.factory.createParenthesizedExpression` with the benefit that it
+ * signifies that the inserted parenthesis are for use by the type checker, not for correctness of
+ * the rendered TCB code.
  */
 export declare function wrapForTypeChecker(expr: ts.Expression): ts.Expression;
 /**

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/util/src/typescript.d.ts

@@ -62,8 +62,3 @@ export declare type RequiredDelegations<T> = {
  * Obtains the non-redirected source file for `sf`.
  */
 export declare function toUnredirectedSourceFile(sf: ts.SourceFile): ts.SourceFile;
-/**
- * Backwards-compatible version of `ts.createExportSpecifier`
- * to handle a breaking change between 4.4 and 4.5.
- */
-export declare function createExportSpecifier(propertyName: string | ts.Identifier | undefined, name: string | ts.Identifier, isTypeOnly?: boolean): ts.ExportSpecifier;