@angular/compiler-cli 13.1.0-next.2 → 13.1.2

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

@@ -30,8 +30,6 @@ export declare class TypeTranslatorVisitor implements o.ExpressionVisitor, o.Typ
     visitExternalExpr(ast: o.ExternalExpr, context: Context): ts.EntityName | ts.TypeReferenceNode;
     visitConditionalExpr(ast: o.ConditionalExpr, context: Context): void;
     visitNotExpr(ast: o.NotExpr, context: Context): void;
-    visitAssertNotNullExpr(ast: o.AssertNotNull, context: Context): void;
-    visitCastExpr(ast: o.CastExpr, context: Context): void;
     visitFunctionExpr(ast: o.FunctionExpr, context: Context): void;
     visitUnaryOperatorExpr(ast: o.UnaryOperatorExpr, context: Context): void;
     visitBinaryOperatorExpr(ast: o.BinaryOperatorExpr, context: Context): void;

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

@@ -6,24 +6,25 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/api/api" />
-import { AST, TmplAstNode } from '@angular/compiler';
+import { AST, ParseSourceSpan, TmplAstNode } from '@angular/compiler';
 import ts from 'typescript';
-import { ErrorCode } from '../../../diagnostics';
+import { NgCompilerOptions } from '../../../core/api';
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../diagnostics';
 import { NgTemplateDiagnostic, TemplateTypeChecker } from '../../api';
 /**
  * A Template Check receives information about the template it's checking and returns
  * information about the diagnostics to be generated.
  */
-export interface TemplateCheck<T extends ErrorCode> {
+export interface TemplateCheck<Code extends ErrorCode> {
     /** Unique template check code, used for configuration and searching the error. */
-    code: T;
+    code: Code;
     /** Runs check and returns information about the diagnostics to be generated. */
-    run(ctx: TemplateContext, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<T>[];
+    run(ctx: TemplateContext<Code>, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<Code>[];
 }
 /**
  * The TemplateContext provided to a Template Check to get diagnostic information.
  */
-export interface TemplateContext {
+export interface TemplateContext<Code extends ErrorCode> {
     /** Interface that provides information about template nodes. */
     templateTypeChecker: TemplateTypeChecker;
     /**
@@ -31,20 +32,39 @@ export interface TemplateContext {
      * in the template (it is not to query types outside the Angular component).
      */
     typeChecker: ts.TypeChecker;
+    /**
+     * Creates a template diagnostic with the given information for the template being processed and
+     * using the diagnostic category configured for the extended template diagnostic.
+     */
+    makeTemplateDiagnostic(sourceSpan: ParseSourceSpan, message: string, relatedInformation?: {
+        text: string;
+        start: number;
+        end: number;
+        sourceFile: ts.SourceFile;
+    }[]): NgTemplateDiagnostic<Code>;
+}
+/**
+ * A factory which creates a template check for a particular code and name. This binds the two
+ * together and associates them with a specific `TemplateCheck`.
+ */
+export interface TemplateCheckFactory<Code extends ErrorCode, Name extends ExtendedTemplateDiagnosticName> {
+    code: Code;
+    name: Name;
+    create(options: NgCompilerOptions): TemplateCheck<Code> | null;
 }
 /**
  * This abstract class provides a base implementation for the run method.
  */
-export declare abstract class TemplateCheckWithVisitor<T extends ErrorCode> implements TemplateCheck<T> {
-    abstract code: T;
+export declare abstract class TemplateCheckWithVisitor<Code extends ErrorCode> implements TemplateCheck<Code> {
+    abstract code: Code;
     /**
      * Base implementation for run function, visits all nodes in template and calls
      * `visitNode()` for each one.
      */
-    run(ctx: TemplateContext, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<T>[];
+    run(ctx: TemplateContext<Code>, component: ts.ClassDeclaration, template: TmplAstNode[]): NgTemplateDiagnostic<Code>[];
     /**
      * Visit a TmplAstNode or AST node of the template. Authors should override this
      * method to implement the check and return diagnostics.
      */
-    abstract visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<T>[];
+    abstract visitNode(ctx: TemplateContext<Code>, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<Code>[];
 }

package/src/ngtsc/typecheck/extended/checks/invalid_banana_in_box/index.d.ts

@@ -6,17 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/invalid_banana_in_box" />
-import { AST, TmplAstNode } from '@angular/compiler';
-import ts from 'typescript';
-import { ErrorCode } from '../../../../diagnostics';
-import { NgTemplateDiagnostic } from '../../../api';
-import { TemplateCheckWithVisitor, TemplateContext } from '../../api';
-/**
- * Ensures the two-way binding syntax is correct.
- * Parentheses should be inside the brackets "[()]".
- * Will return diagnostic information when "([])" is found.
- */
-export declare class InvalidBananaInBoxCheck extends TemplateCheckWithVisitor<ErrorCode.INVALID_BANANA_IN_BOX> {
-    code: ErrorCode.INVALID_BANANA_IN_BOX;
-    visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<ErrorCode.INVALID_BANANA_IN_BOX>[];
-}
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../../diagnostics';
+import { TemplateCheckFactory } from '../../api';
+export declare const factory: TemplateCheckFactory<ErrorCode.INVALID_BANANA_IN_BOX, ExtendedTemplateDiagnosticName.INVALID_BANANA_IN_BOX>;

package/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable/index.d.ts

@@ -6,18 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/checks/nullish_coalescing_not_nullable" />
-import { AST, TmplAstNode } from '@angular/compiler';
-import ts from 'typescript';
-import { ErrorCode } from '../../../../diagnostics';
-import { NgTemplateDiagnostic } from '../../../api';
-import { TemplateCheckWithVisitor, TemplateContext } from '../../api';
-/**
- * Ensures the left side of a nullish coalescing operation is nullable.
- * Returns diagnostics for the cases where the operator is useless.
- * This check should only be use if `strictNullChecks` is enabled,
- * otherwise it would produce inaccurate results.
- */
-export declare class NullishCoalescingNotNullableCheck extends TemplateCheckWithVisitor<ErrorCode.NULLISH_COALESCING_NOT_NULLABLE> {
-    code: ErrorCode.NULLISH_COALESCING_NOT_NULLABLE;
-    visitNode(ctx: TemplateContext, component: ts.ClassDeclaration, node: TmplAstNode | AST): NgTemplateDiagnostic<ErrorCode.NULLISH_COALESCING_NOT_NULLABLE>[];
-}
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../../diagnostics';
+import { TemplateCheckFactory } from '../../api';
+export declare const factory: TemplateCheckFactory<ErrorCode.NULLISH_COALESCING_NOT_NULLABLE, ExtendedTemplateDiagnosticName.NULLISH_COALESCING_NOT_NULLABLE>;

package/src/ngtsc/typecheck/extended/index.d.ts

@@ -6,4 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended" />
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../diagnostics';
+import { TemplateCheckFactory } from './api';
 export { ExtendedTemplateCheckerImpl } from './src/extended_template_checker';
+export declare const ALL_DIAGNOSTIC_FACTORIES: readonly TemplateCheckFactory<ErrorCode, ExtendedTemplateDiagnosticName>[];

package/src/ngtsc/typecheck/extended/src/extended_template_checker.d.ts

@@ -7,12 +7,13 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/typecheck/extended/src/extended_template_checker" />
 import ts from 'typescript';
-import { ErrorCode } from '../../../diagnostics';
+import { NgCompilerOptions } from '../../../core/api';
+import { ErrorCode, ExtendedTemplateDiagnosticName } from '../../../diagnostics';
 import { TemplateDiagnostic, TemplateTypeChecker } from '../../api';
-import { ExtendedTemplateChecker, TemplateCheck } from '../api';
+import { ExtendedTemplateChecker, TemplateCheckFactory } from '../api';
 export declare class ExtendedTemplateCheckerImpl implements ExtendedTemplateChecker {
+    private readonly partialCtx;
     private readonly templateChecks;
-    private ctx;
-    constructor(templateTypeChecker: TemplateTypeChecker, typeChecker: ts.TypeChecker, templateChecks: TemplateCheck<ErrorCode>[]);
+    constructor(templateTypeChecker: TemplateTypeChecker, typeChecker: ts.TypeChecker, templateCheckFactories: readonly TemplateCheckFactory<ErrorCode, ExtendedTemplateDiagnosticName>[], options: NgCompilerOptions);
     getDiagnosticsForComponent(component: ts.ClassDeclaration): TemplateDiagnostic[];
 }

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

@@ -12,6 +12,7 @@ import { Reference, ReferenceEmitter } from '../../imports';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { ImportManager } from '../../translator';
 import { TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
+import { ReferenceEmitEnvironment } from './tcb_util';
 /**
  * A context which hosts one or more Type Check Blocks (TCBs).
  *
@@ -23,7 +24,7 @@ import { TypeCheckableDirectiveMeta, TypeCheckingConfig } from '../api';
  * `Environment` can be used in a standalone fashion, or can be extended to support more specialized
  * usage.
  */
-export declare class Environment {
+export declare class Environment implements ReferenceEmitEnvironment {
     readonly config: TypeCheckingConfig;
     protected importManager: ImportManager;
     private refEmitter;
@@ -49,6 +50,7 @@ export declare class Environment {
      * This may involve importing the node into the file if it's not declared there already.
      */
     reference(ref: Reference<ClassDeclaration<ts.ClassDeclaration>>): ts.Expression;
+    canReferenceType(ref: Reference): boolean;
     /**
      * Generate a `ts.TypeNode` that references the given node as a type.
      *

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

@@ -11,6 +11,14 @@ import ts from 'typescript';
 import { ClassDeclaration, ReflectionHost } from '../../../../src/ngtsc/reflection';
 import { Reference } from '../../imports';
 import { FullTemplateMapping, SourceLocation, TemplateId, TemplateSourceMapping } from '../api';
+/**
+ * Represents the origin environment from where reference will be emitted. This interface exists
+ * as an indirection for the `Environment` type, which would otherwise introduce a (type-only)
+ * import cycle.
+ */
+export interface ReferenceEmitEnvironment {
+    canReferenceType(ref: Reference): boolean;
+}
 /**
  * Adapter interface which allows the template type-checking diagnostics code to interpret offsets
  * in a TCB and map them back to original locations in the template.
@@ -50,7 +58,7 @@ export declare enum TcbInliningRequirement {
      */
     None = 2
 }
-export declare function requiresInlineTypeCheckBlock(node: ClassDeclaration<ts.ClassDeclaration>, usedPipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, reflector: ReflectionHost): TcbInliningRequirement;
+export declare function requiresInlineTypeCheckBlock(node: ClassDeclaration<ts.ClassDeclaration>, env: ReferenceEmitEnvironment, usedPipes: Map<string, Reference<ClassDeclaration<ts.ClassDeclaration>>>, reflector: ReflectionHost): TcbInliningRequirement;
 /** Maps a shim position back to a template location. */
 export declare function getTemplateMapping(shimSf: ts.SourceFile, position: number, resolver: TemplateSourceResolver, isDiagnosticRequest: boolean): FullTemplateMapping | null;
 export declare function findTypeCheckBlock(file: ts.SourceFile, id: TemplateId, isDiagnosticRequest: boolean): ts.Node | null;
@@ -61,4 +69,4 @@ export declare function findTypeCheckBlock(file: ts.SourceFile, id: TemplateId,
  * returns null.
  */
 export declare function findSourceLocation(node: ts.Node, sourceFile: ts.SourceFile, isDiagnosticsRequest: boolean): SourceLocation | null;
-export declare function checkIfGenericTypeBoundsAreContextFree(node: ClassDeclaration<ts.ClassDeclaration>, reflector: ReflectionHost): boolean;
+export declare function checkIfGenericTypeBoundsCanBeEmitted(node: ClassDeclaration<ts.ClassDeclaration>, reflector: ReflectionHost, env: ReferenceEmitEnvironment): boolean;

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

@@ -9,7 +9,8 @@
 import ts from 'typescript';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
 import { TypeCtorMetadata } from '../api';
-export declare function generateTypeCtorDeclarationFn(node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: ts.TypeParameterDeclaration[] | undefined, reflector: ReflectionHost): ts.Statement;
+import { ReferenceEmitEnvironment } from './tcb_util';
+export declare function generateTypeCtorDeclarationFn(node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName, typeParams: ts.TypeParameterDeclaration[] | undefined): ts.Statement;
 /**
  * Generate an inline type constructor for the given class and metadata.
  *
@@ -46,4 +47,4 @@ export declare function generateTypeCtorDeclarationFn(node: ClassDeclaration<ts.
  * @returns a `ts.MethodDeclaration` for the type constructor.
  */
 export declare function generateInlineTypeCtor(node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata): ts.MethodDeclaration;
-export declare function requiresInlineTypeCtor(node: ClassDeclaration<ts.ClassDeclaration>, host: ReflectionHost): boolean;
+export declare function requiresInlineTypeCtor(node: ClassDeclaration<ts.ClassDeclaration>, host: ReflectionHost, env: ReferenceEmitEnvironment): boolean;

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

@@ -7,18 +7,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import ts from 'typescript';
-import { Reference } from '../../imports';
 /**
- * A resolved type reference can either be a `Reference`, the original `ts.TypeReferenceNode` itself
- * or null. A value of null indicates that no reference could be resolved or that the reference can
- * not be emitted.
+ * A type reference resolver function is responsible for translating a type reference from the
+ * origin source file into a type reference that is valid in the desired source file. If the type
+ * cannot be translated to the desired source file, then null can be returned.
  */
-export declare type ResolvedTypeReference = Reference | ts.TypeReferenceNode | null;
-/**
- * A type reference resolver function is responsible for finding the declaration of the type
- * reference and verifying whether it can be emitted.
- */
-export declare type TypeReferenceResolver = (type: ts.TypeReferenceNode) => ResolvedTypeReference;
+export declare type TypeReferenceTranslator = (type: ts.TypeReferenceNode) => ts.TypeReferenceNode | null;
 /**
  * Determines whether the provided type can be emitted, which means that it can be safely emitted
  * into a different location.
@@ -27,7 +21,7 @@ export declare type TypeReferenceResolver = (type: ts.TypeReferenceNode) => Reso
  * function returns false, then using the `TypeEmitter` should not be attempted as it is known to
  * fail.
  */
-export declare function canEmitType(type: ts.TypeNode, resolver: TypeReferenceResolver): boolean;
+export declare function canEmitType(type: ts.TypeNode, canEmit: (type: ts.TypeReferenceNode) => boolean): boolean;
 /**
  * Given a `ts.TypeNode`, this class derives an equivalent `ts.TypeNode` that has been emitted into
  * a different context.
@@ -58,16 +52,8 @@ export declare function canEmitType(type: ts.TypeNode, resolver: TypeReferenceRe
  * referring to the namespace import that was created.
  */
 export declare class TypeEmitter {
-    /**
-     * Resolver function that computes a `Reference` corresponding with a `ts.TypeReferenceNode`.
-     */
-    private resolver;
-    /**
-     * Given a `Reference`, this function is responsible for the actual emitting work. It should
-     * produce a `ts.TypeNode` that is valid within the desired context.
-     */
-    private emitReference;
-    constructor(resolver: TypeReferenceResolver, emitReference: (ref: Reference) => ts.TypeNode);
+    private translator;
+    constructor(translator: TypeReferenceTranslator);
     emitType(type: ts.TypeNode): ts.TypeNode;
     private emitTypeReference;
 }

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

@@ -21,13 +21,13 @@ export declare class TypeParameterEmitter {
      * `emit` is known to succeed. Vice versa, if false is returned then `emit` should not be
      * called, as it would fail.
      */
-    canEmit(): boolean;
+    canEmit(canEmitReference: (ref: Reference) => boolean): boolean;
     private canEmitType;
     /**
      * Emits the type parameters using the provided emitter function for `Reference`s.
      */
     emit(emitReference: (ref: Reference) => ts.TypeNode): ts.TypeParameterDeclaration[] | undefined;
     private resolveTypeReference;
-    private isTopLevelExport;
+    private translateTypeReference;
     private isLocalTypeParameter;
 }

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

@@ -62,3 +62,8 @@ 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;

package/src/perform_compile.d.ts

@@ -6,15 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/perform_compile" />
-import { Position } from '@angular/compiler';
 import ts from 'typescript';
 import { AbsoluteFsPath, ReadonlyFileSystem } from '../src/ngtsc/file_system';
 import * as api from './transformers/api';
-export declare type Diagnostics = ReadonlyArray<ts.Diagnostic | api.Diagnostic>;
-export declare function formatDiagnosticPosition(position: Position, host?: ts.FormatDiagnosticsHost): string;
-export declare function flattenDiagnosticMessageChain(chain: api.DiagnosticMessageChain, host?: ts.FormatDiagnosticsHost, indent?: number): string;
-export declare function formatDiagnostic(diagnostic: api.Diagnostic, host?: ts.FormatDiagnosticsHost): string;
-export declare function formatDiagnostics(diags: Diagnostics, host?: ts.FormatDiagnosticsHost): string;
+export declare function formatDiagnostics(diags: ReadonlyArray<ts.Diagnostic>, host?: ts.FormatDiagnosticsHost): string;
 /** Used to read configuration files. */
 export declare type ConfigurationHost = Pick<ReadonlyFileSystem, 'readFile' | 'exists' | 'lstat' | 'resolve' | 'join' | 'dirname' | 'extname' | 'pwd'>;
 export interface ParsedConfiguration {
@@ -31,11 +26,11 @@ export declare function calcProjectFileAndBasePath(project: string, host?: Confi
 };
 export declare function readConfiguration(project: string, existingOptions?: api.CompilerOptions, host?: ConfigurationHost): ParsedConfiguration;
 export interface PerformCompilationResult {
-    diagnostics: Diagnostics;
+    diagnostics: ReadonlyArray<ts.Diagnostic>;
     program?: api.Program;
     emitResult?: ts.EmitResult;
 }
-export declare function exitCodeFromResult(diags: Diagnostics | undefined): number;
+export declare function exitCodeFromResult(diags: ReadonlyArray<ts.Diagnostic> | undefined): number;
 export declare function performCompilation({ rootNames, options, host, oldProgram, emitCallback, mergeEmitResultsCallback, gatherDiagnostics, customTransformers, emitFlags, modifiedResourceFiles }: {
     rootNames: string[];
     options: api.CompilerOptions;
@@ -43,9 +38,9 @@ export declare function performCompilation({ rootNames, options, host, oldProgra
     oldProgram?: api.Program;
     emitCallback?: api.TsEmitCallback;
     mergeEmitResultsCallback?: api.TsMergeEmitResultsCallback;
-    gatherDiagnostics?: (program: api.Program) => Diagnostics;
+    gatherDiagnostics?: (program: api.Program) => ReadonlyArray<ts.Diagnostic>;
     customTransformers?: api.CustomTransformers;
     emitFlags?: api.EmitFlags;
     modifiedResourceFiles?: Set<string> | null;
 }): PerformCompilationResult;
-export declare function defaultGatherDiagnostics(program: api.Program): Diagnostics;
+export declare function defaultGatherDiagnostics(program: api.Program): ReadonlyArray<ts.Diagnostic>;

package/src/perform_watch.d.ts

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/perform_watch" />
 import ts from 'typescript';
-import { Diagnostics, ParsedConfiguration } from './perform_compile';
+import { ParsedConfiguration } from './perform_compile';
 import * as api from './transformers/api';
 export declare enum FileChangeEvent {
     Change = 0,
@@ -15,7 +15,7 @@ export declare enum FileChangeEvent {
     CreateDeleteDir = 2
 }
 export interface PerformWatchHost {
-    reportDiagnostics(diagnostics: Diagnostics): void;
+    reportDiagnostics(diagnostics: ReadonlyArray<ts.Diagnostic>): void;
     readConfiguration(): ParsedConfiguration;
     createCompilerHost(options: api.CompilerOptions): api.CompilerHost;
     createEmitCallback(options: api.CompilerOptions): api.TsEmitCallback | undefined;
@@ -25,12 +25,12 @@ export interface PerformWatchHost {
     setTimeout(callback: () => void, ms: number): any;
     clearTimeout(timeoutId: any): void;
 }
-export declare function createPerformWatchHost(configFileName: string, reportDiagnostics: (diagnostics: Diagnostics) => void, existingOptions?: ts.CompilerOptions, createEmitCallback?: (options: api.CompilerOptions) => api.TsEmitCallback | undefined): PerformWatchHost;
+export declare function createPerformWatchHost(configFileName: string, reportDiagnostics: (diagnostics: ReadonlyArray<ts.Diagnostic>) => void, existingOptions?: ts.CompilerOptions, createEmitCallback?: (options: api.CompilerOptions) => api.TsEmitCallback | undefined): PerformWatchHost;
 /**
  * The logic in this function is adapted from `tsc.ts` from TypeScript.
  */
 export declare function performWatchCompilation(host: PerformWatchHost): {
     close: () => void;
     ready: (cb: () => void) => void;
-    firstCompileResult: Diagnostics;
+    firstCompileResult: ReadonlyArray<ts.Diagnostic>;
 };

package/src/transformers/api.d.ts

@@ -6,28 +6,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/transformers/api" />
-import { ParseSourceSpan, Position } from '@angular/compiler';
 import ts from 'typescript';
 import { ExtendedTsCompilerHost, NgCompilerOptions } from '../ngtsc/core/api';
 export declare const DEFAULT_ERROR_CODE = 100;
 export declare const UNKNOWN_ERROR_CODE = 500;
 export declare const SOURCE: "angular";
-export interface DiagnosticMessageChain {
-    messageText: string;
-    position?: Position;
-    next?: DiagnosticMessageChain[];
-}
-export interface Diagnostic {
-    messageText: string;
-    span?: ParseSourceSpan;
-    position?: Position;
-    chain?: DiagnosticMessageChain;
-    category: ts.DiagnosticCategory;
-    code: number;
-    source: 'angular';
-}
 export declare function isTsDiagnostic(diagnostic: any): diagnostic is ts.Diagnostic;
-export declare function isNgDiagnostic(diagnostic: any): diagnostic is Diagnostic;
 export interface CompilerOptions extends NgCompilerOptions, ts.CompilerOptions {
     genDir?: string;
     basePath?: string;
@@ -122,11 +106,6 @@ export interface TsEmitCallback {
 export interface TsMergeEmitResultsCallback {
     (results: ts.EmitResult[]): ts.EmitResult;
 }
-export interface LibrarySummary {
-    fileName: string;
-    text: string;
-    sourceFile?: ts.SourceFile;
-}
 export interface LazyRoute {
     route: string;
     module: {
@@ -154,7 +133,7 @@ export interface Program {
     /**
      * Retrieve options diagnostics for the Angular options used to create the program.
      */
-    getNgOptionDiagnostics(cancellationToken?: ts.CancellationToken): ReadonlyArray<ts.Diagnostic | Diagnostic>;
+    getNgOptionDiagnostics(cancellationToken?: ts.CancellationToken): ReadonlyArray<ts.Diagnostic>;
     /**
      * Retrieve the syntax diagnostics from TypeScript. This is faster than calling
      * `getTsProgram().getSyntacticDiagnostics()` since it does not need to collect Angular structural
@@ -172,7 +151,7 @@ export interface Program {
      *
      * Angular structural information is required to produce these diagnostics.
      */
-    getNgStructuralDiagnostics(cancellationToken?: ts.CancellationToken): ReadonlyArray<Diagnostic>;
+    getNgStructuralDiagnostics(cancellationToken?: ts.CancellationToken): ReadonlyArray<ts.Diagnostic>;
     /**
      * Retrieve the semantic diagnostics from TypeScript. This is equivalent to calling
      * `getTsProgram().getSemanticDiagnostics()` directly and is included for completeness.
@@ -183,7 +162,7 @@ export interface Program {
      *
      * Angular structural information is required to produce these diagnostics.
      */
-    getNgSemanticDiagnostics(fileName?: string, cancellationToken?: ts.CancellationToken): ReadonlyArray<ts.Diagnostic | Diagnostic>;
+    getNgSemanticDiagnostics(fileName?: string, cancellationToken?: ts.CancellationToken): ReadonlyArray<ts.Diagnostic>;
     /**
      * Load Angular structural information asynchronously. If this method is not called then the
      * Angular structural information, including referenced HTML and CSS files, are loaded
@@ -207,10 +186,4 @@ export interface Program {
         emitCallback?: TsEmitCallback;
         mergeEmitResultsCallback?: TsMergeEmitResultsCallback;
     }): ts.EmitResult;
-    /**
-     * Returns the .d.ts / .ngsummary.json / .ngfactory.d.ts files of libraries that have been emitted
-     * in this program or previous programs with paths that emulate the fact that these libraries
-     * have been compiled before with no outDir.
-     */
-    getLibrarySummaries(): Map<string, LibrarySummary>;
 }

package/src/transformers/compiler_host.d.ts

@@ -6,106 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/transformers/compiler_host" />
-import { AotCompilerHost, GeneratedFile, ParseSourceSpan } from '@angular/compiler';
 import ts from 'typescript';
-import { TypeCheckHost } from '../diagnostics/translate_diagnostics';
-import { ModuleMetadata } from '../metadata/index';
-import { CompilerHost, CompilerOptions, LibrarySummary } from './api';
+import { CompilerHost, CompilerOptions } from './api';
 export declare function setWrapHostForTest(wrapFn: ((host: ts.CompilerHost) => ts.CompilerHost) | null): void;
 export declare function createCompilerHost({ options, tsHost }: {
     options: CompilerOptions;
     tsHost?: ts.CompilerHost;
 }): CompilerHost;
-export interface MetadataProvider {
-    getMetadata(sourceFile: ts.SourceFile): ModuleMetadata | undefined;
-}
-export interface CodeGenerator {
-    generateFile(genFileName: string, baseFileName?: string): GeneratedFile;
-    findGeneratedFileNames(fileName: string): string[];
-}
-/**
- * Implements the following hosts based on an api.CompilerHost:
- * - ts.CompilerHost to be consumed by a ts.Program
- * - AotCompilerHost for @angular/compiler
- * - TypeCheckHost for mapping ts errors to ng errors (via translateDiagnostics)
- */
-export declare class TsCompilerAotCompilerTypeCheckHostAdapter implements ts.CompilerHost, AotCompilerHost, TypeCheckHost {
-    private rootFiles;
-    private options;
-    private context;
-    private metadataProvider;
-    private codeGenerator;
-    private librarySummaries;
-    private metadataReaderCache;
-    private fileNameToModuleNameCache;
-    private flatModuleIndexCache;
-    private flatModuleIndexNames;
-    private flatModuleIndexRedirectNames;
-    private rootDirs;
-    private moduleResolutionCache;
-    private originalSourceFiles;
-    private originalFileExistsCache;
-    private generatedSourceFiles;
-    private generatedCodeFor;
-    private emitter;
-    private metadataReaderHost;
-    getCancellationToken: () => ts.CancellationToken;
-    getDefaultLibLocation: () => string;
-    trace: (s: string) => void;
-    getDirectories: (path: string) => string[];
-    resolveTypeReferenceDirectives?: (names: string[], containingFile: string) => ts.ResolvedTypeReferenceDirective[];
-    directoryExists?: (directoryName: string) => boolean;
-    constructor(rootFiles: ReadonlyArray<string>, options: CompilerOptions, context: CompilerHost, metadataProvider: MetadataProvider, codeGenerator: CodeGenerator, librarySummaries?: Map<string, LibrarySummary>);
-    private resolveModuleName;
-    resolveModuleNames(moduleNames: string[], containingFile: string): ts.ResolvedModule[];
-    moduleNameToFileName(m: string, containingFile?: string): string | null;
-    /**
-     * We want a moduleId that will appear in import statements in the generated code
-     * which will be written to `containingFile`.
-     *
-     * Note that we also generate files for files in node_modules, as libraries
-     * only ship .metadata.json files but not the generated code.
-     *
-     * Logic:
-     * 1. if the importedFile and the containingFile are from the project sources
-     *    or from the same node_modules package, use a relative path
-     * 2. if the importedFile is in a node_modules package,
-     *    use a path that starts with the package name.
-     * 3. Error if the containingFile is in the node_modules package
-     *    and the importedFile is in the project soures,
-     *    as that is a violation of the principle that node_modules packages cannot
-     *    import project sources.
-     */
-    fileNameToModuleName(importedFile: string, containingFile: string): string;
-    resourceNameToFileName(resourceName: string, containingFile: string): string | null;
-    toSummaryFileName(fileName: string, referringSrcFileName: string): string;
-    fromSummaryFileName(fileName: string, referringLibFileName: string): string;
-    parseSourceSpanOf(fileName: string, line: number, character: number): ParseSourceSpan | null;
-    private getOriginalSourceFile;
-    updateGeneratedFile(genFile: GeneratedFile): ts.SourceFile;
-    private addGeneratedFile;
-    shouldGenerateFile(fileName: string): {
-        generate: boolean;
-        baseFileName?: string;
-    };
-    shouldGenerateFilesFor(fileName: string): string | boolean | null;
-    getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void) | undefined): ts.SourceFile;
-    private getGeneratedFile;
-    private originalFileExists;
-    fileExists(fileName: string): boolean;
-    loadSummary(filePath: string): string | null;
-    isSourceFile(filePath: string): boolean;
-    readFile(fileName: string): string | undefined;
-    getMetadataFor(filePath: string): ModuleMetadata[] | undefined;
-    loadResource(filePath: string): Promise<string> | string;
-    getOutputName(filePath: string): string;
-    private hasBundleIndex;
-    getDefaultLibFileName: (options: ts.CompilerOptions) => string;
-    getCurrentDirectory: () => string;
-    getCanonicalFileName: (fileName: string) => string;
-    useCaseSensitiveFileNames: () => boolean;
-    getNewLine: () => string;
-    realpath: (p: string) => string;
-    writeFile: ts.WriteFileCallback;
-}
-export declare function getOriginalReferences(sourceFile: ts.SourceFile): ts.FileReference[] | undefined;

package/src/transformers/program.d.ts

@@ -6,29 +6,10 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/transformers/program" />
-import * as path from 'path';
-import ts from 'typescript';
 import { CompilerHost, CompilerOptions, Program } from './api';
-export declare function setTempProgramHandlerForTest(handler: (program: ts.Program) => void): void;
-export declare function resetTempProgramHandlerForTest(): void;
 export declare function createProgram({ rootNames, options, host, oldProgram }: {
     rootNames: ReadonlyArray<string>;
     options: CompilerOptions;
     host: CompilerHost;
     oldProgram?: Program;
 }): Program;
-/**
- * Returns a function that can adjust a path from source path to out path,
- * based on an existing mapping from source to out path.
- *
- * TODO(tbosch): talk to the TypeScript team to expose their logic for calculating the `rootDir`
- * if none was specified.
- *
- * Note: This function works on normalized paths from typescript but should always return
- * POSIX normalized paths for output paths.
- */
-export declare function createSrcToOutPathMapper(outDir: string | undefined, sampleSrcFileName: string | undefined, sampleOutFileName: string | undefined, host?: {
-    dirname: typeof path.dirname;
-    resolve: typeof path.resolve;
-    relative: typeof path.relative;
-}): (srcFileName: string) => string;

package/src/transformers/util.d.ts

@@ -7,28 +7,9 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/transformers/util" />
 import ts from 'typescript';
-import { CompilerOptions, Diagnostic } from './api';
 export declare const GENERATED_FILES: RegExp;
-export declare const DTS: RegExp;
-export declare const TS: RegExp;
-export declare const enum StructureIsReused {
-    Not = 0,
-    SafeModules = 1,
-    Completely = 2
-}
-export declare function tsStructureIsReused(program: ts.Program): StructureIsReused;
 export declare function error(msg: string): never;
-export declare function userError(msg: string): never;
-export declare function createMessageDiagnostic(messageText: string): ts.Diagnostic & Diagnostic;
-export declare function isInRootDir(fileName: string, options: CompilerOptions): string | true | null;
-export declare function relativeToRootDirs(filePath: string, rootDirs: string[]): string;
-/**
- * Converts a ng.Diagnostic into a ts.Diagnostic.
- * This looses some information, and also uses an incomplete object as `file`.
- *
- * I.e. only use this where the API allows only a ts.Diagnostic.
- */
-export declare function ngToTsDiagnostic(ng: Diagnostic): ts.Diagnostic;
+export declare function createMessageDiagnostic(messageText: string): ts.Diagnostic;
 /**
  * Strip multiline comment start and end markers from the `commentText` string.
  *