@angular/compiler-cli 13.1.0-next.1 → 13.2.0-next.0

package/index.d.ts

@@ -1,12 +1,9 @@
 /// <amd-module name="@angular/compiler-cli" />
-export { AotCompilerHost, AotCompilerHost as StaticReflectorHost, StaticReflector, StaticSymbol } from '@angular/compiler';
 export { VERSION } from './src/version';
-export * from './src/metadata';
 export * from './src/transformers/api';
 export * from './src/transformers/entry_points';
 export * from './src/perform_compile';
 export { CompilerOptions as AngularCompilerOptions } from './src/transformers/api';
-export { ngToTsDiagnostic } from './src/transformers/util';
 export * from './private/tooling';
 export * from './src/ngtsc/logging';
 export * from './src/ngtsc/file_system';

package/ngcc/src/host/delegating_host.d.ts

@@ -8,7 +8,7 @@
 /// <amd-module name="@angular/compiler-cli/ngcc/src/host/delegating_host" />
 import ts from 'typescript';
 import { ClassDeclaration, ClassMember, CtorParameter, Declaration, DeclarationNode, Decorator, FunctionDefinition, Import, ReflectionHost } from '../../../src/ngtsc/reflection';
-import { NgccClassSymbol, NgccReflectionHost, SwitchableVariableDeclaration } from './ngcc_host';
+import { NgccClassSymbol, NgccReflectionHost } from './ngcc_host';
 /**
  * A reflection host implementation that delegates reflector queries depending on whether they
  * reflect on declaration files (for dependent libraries) or source files within the entry-point
@@ -38,7 +38,6 @@ export declare class DelegatingReflectionHost implements NgccReflectionHost {
     findClassSymbols(sourceFile: ts.SourceFile): NgccClassSymbol[];
     getClassSymbol(node: ts.Node): NgccClassSymbol | undefined;
     getDecoratorsOfSymbol(symbol: NgccClassSymbol): Decorator[] | null;
-    getSwitchableDeclarations(module: ts.Node): SwitchableVariableDeclaration[];
     getEndOfClass(classSymbol: NgccClassSymbol): ts.Node;
     detectKnownDeclaration<T extends Declaration>(decl: T): T;
     isStaticallyExported(decl: ts.Node): boolean;

package/ngcc/src/host/esm2015_host.d.ts

@@ -10,7 +10,7 @@ import ts from 'typescript';
 import { Logger } from '../../../src/ngtsc/logging';
 import { ClassDeclaration, ClassMember, ClassMemberKind, CtorParameter, Declaration, DeclarationNode, Decorator, EnumMember, TypeScriptReflectionHost } from '../../../src/ngtsc/reflection';
 import { BundleProgram } from '../packages/bundle_program';
-import { NgccClassSymbol, NgccReflectionHost, SwitchableVariableDeclaration } from './ngcc_host';
+import { NgccClassSymbol, NgccReflectionHost } from './ngcc_host';
 export declare const DECORATORS: ts.__String;
 export declare const PROP_DECORATORS: ts.__String;
 export declare const CONSTRUCTOR: ts.__String;
@@ -186,13 +186,6 @@ export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost impl
      * injected by a migration will not be present in the returned collection.
      */
     getDecoratorsOfSymbol(symbol: NgccClassSymbol): Decorator[] | null;
-    /**
-     * Search the given module for variable declarations in which the initializer
-     * is an identifier marked with the `PRE_R3_MARKER`.
-     * @param module the module in which to search for switchable declarations.
-     * @returns an array of variable declarations that match.
-     */
-    getSwitchableDeclarations(module: ts.Node): SwitchableVariableDeclaration[];
     getVariableValue(declaration: ts.VariableDeclaration): ts.Expression | null;
     /**
      * Find all top-level class symbols in the given file.

package/ngcc/src/host/ngcc_host.d.ts

@@ -9,12 +9,6 @@
 import ts from 'typescript';
 import { ClassDeclaration, Declaration, Decorator, ReflectionHost } from '../../../src/ngtsc/reflection';
 import { SymbolWithValueDeclaration } from '../../../src/ngtsc/util/src/typescript';
-export declare const PRE_R3_MARKER = "__PRE_R3__";
-export declare const POST_R3_MARKER = "__POST_R3__";
-export declare type SwitchableVariableDeclaration = ts.VariableDeclaration & {
-    initializer: ts.Identifier;
-};
-export declare function isSwitchableVariableDeclaration(node: ts.Node): node is SwitchableVariableDeclaration;
 /**
  * The symbol corresponding to a "class" declaration. I.e. a `ts.Symbol` whose `valueDeclaration` is
  * a `ClassDeclaration`.
@@ -60,13 +54,6 @@ export interface NgccReflectionHost extends ReflectionHost {
      * a "class" or has no symbol.
      */
     getClassSymbol(declaration: ts.Node): NgccClassSymbol | undefined;
-    /**
-     * Search the given module for variable declarations in which the initializer
-     * is an identifier marked with the `PRE_R3_MARKER`.
-     * @param module The module in which to search for switchable declarations.
-     * @returns An array of variable declarations that match.
-     */
-    getSwitchableDeclarations(module: ts.Node): SwitchableVariableDeclaration[];
     /**
      * Retrieves all decorators of a given class symbol.
      * @param symbol Class symbol that can refer to a declaration which can hold decorators.

package/ngcc/src/host/umd_host.d.ts

@@ -79,5 +79,8 @@ export declare function getImportsOfUmdModule(umdModule: UmdModule): {
 interface UmdModule {
     wrapperFn: ts.FunctionExpression;
     factoryFn: ts.FunctionExpression;
+    factoryCalls: Record<'amdDefine' | 'commonJs' | 'commonJs2' | 'global', ts.CallExpression | null> & {
+        cjsCallForImports: ts.CallExpression;
+    };
 }
 export {};

package/ngcc/src/packages/build_marker.d.ts

@@ -9,7 +9,7 @@
 import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
 import { PackageJsonUpdater } from '../writing/package_json_updater';
 import { EntryPointPackageJson, PackageJsonFormatProperties } from './entry_point';
-export declare const NGCC_VERSION = "13.1.0-next.1";
+export declare const NGCC_VERSION = "13.2.0-next.0";
 /**
  * Returns true if there is a format in this entry-point that was compiled with an outdated version
  * of ngcc.

package/ngcc/src/packages/transformer.d.ts

@@ -12,7 +12,6 @@ import { ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
 import { Logger } from '../../../src/ngtsc/logging';
 import { ModuleWithProvidersAnalyses } from '../analysis/module_with_providers_analyzer';
 import { ExportInfo } from '../analysis/private_declarations_analyzer';
-import { SwitchMarkerAnalyses } from '../analysis/switch_marker_analyzer';
 import { CompiledFile } from '../analysis/types';
 import { NgccReflectionHost } from '../host/ngcc_host';
 import { RenderingFormatter } from '../rendering/rendering_formatter';
@@ -65,7 +64,6 @@ export declare class Transformer {
 export declare function hasErrors(diagnostics: ts.Diagnostic[]): boolean;
 interface ProgramAnalyses {
     decorationAnalyses: Map<ts.SourceFile, CompiledFile>;
-    switchMarkerAnalyses: SwitchMarkerAnalyses;
     privateDeclarationsAnalyses: ExportInfo[];
     moduleWithProvidersAnalyses: ModuleWithProvidersAnalyses | null;
     diagnostics: ts.Diagnostic[];

package/ngcc/src/rendering/esm_rendering_formatter.d.ts

@@ -15,7 +15,7 @@ import { Import, ImportManager } from '../../../src/ngtsc/translator';
 import { ModuleWithProvidersInfo } from '../analysis/module_with_providers_analyzer';
 import { ExportInfo } from '../analysis/private_declarations_analyzer';
 import { CompiledClass } from '../analysis/types';
-import { NgccReflectionHost, SwitchableVariableDeclaration } from '../host/ngcc_host';
+import { NgccReflectionHost } from '../host/ngcc_host';
 import { RedundantDecoratorMap, RenderingFormatter } from './rendering_formatter';
 /**
  * A RenderingFormatter that works with ECMAScript Module import and export statements.
@@ -57,10 +57,6 @@ export declare class EsmRenderingFormatter implements RenderingFormatter {
      * Remove static decorator properties from classes.
      */
     removeDecorators(output: MagicString, decoratorsToRemove: RedundantDecoratorMap): void;
-    /**
-     * Rewrite the IVY switch markers to indicate we are in IVY mode.
-     */
-    rewriteSwitchableDeclarations(outputText: MagicString, sourceFile: ts.SourceFile, declarations: SwitchableVariableDeclaration[]): void;
     /**
      * Add the type parameters to the appropriate functions that return `ModuleWithProviders`
      * structures.

package/ngcc/src/rendering/renderer.d.ts

@@ -13,7 +13,6 @@ import { Logger } from '../../../src/ngtsc/logging';
 import { ImportManager } from '../../../src/ngtsc/translator';
 import { ParsedConfiguration } from '../../../src/perform_compile';
 import { PrivateDeclarationsAnalyses } from '../analysis/private_declarations_analyzer';
-import { SwitchMarkerAnalyses, SwitchMarkerAnalysis } from '../analysis/switch_marker_analyzer';
 import { CompiledFile, DecorationAnalyses } from '../analysis/types';
 import { NgccReflectionHost } from '../host/ngcc_host';
 import { EntryPointBundle } from '../packages/entry_point_bundle';
@@ -33,13 +32,13 @@ export declare class Renderer {
     private bundle;
     private tsConfig;
     constructor(host: NgccReflectionHost, srcFormatter: RenderingFormatter, fs: ReadonlyFileSystem, logger: Logger, bundle: EntryPointBundle, tsConfig?: ParsedConfiguration | null);
-    renderProgram(decorationAnalyses: DecorationAnalyses, switchMarkerAnalyses: SwitchMarkerAnalyses, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses): FileToWrite[];
+    renderProgram(decorationAnalyses: DecorationAnalyses, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses): FileToWrite[];
     /**
      * Render the source code and source-map for an Analyzed file.
      * @param compiledFile The analyzed file to render.
      * @param targetPath The absolute path where the rendered file will be written.
      */
-    renderFile(sourceFile: ts.SourceFile, compiledFile: CompiledFile | undefined, switchMarkerAnalysis: SwitchMarkerAnalysis | undefined, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses): FileToWrite[];
+    renderFile(sourceFile: ts.SourceFile, compiledFile: CompiledFile | undefined, privateDeclarationsAnalyses: PrivateDeclarationsAnalyses): FileToWrite[];
     /**
      * From the given list of classes, computes a map of decorators that should be removed.
      * The decorators to remove are keyed by their container node, such that we can tell if

package/ngcc/src/rendering/rendering_formatter.d.ts

@@ -14,7 +14,6 @@ import { Import, ImportManager } from '../../../src/ngtsc/translator';
 import { ModuleWithProvidersInfo } from '../analysis/module_with_providers_analyzer';
 import { ExportInfo } from '../analysis/private_declarations_analyzer';
 import { CompiledClass } from '../analysis/types';
-import { SwitchableVariableDeclaration } from '../host/ngcc_host';
 /**
  * The collected decorators that have become redundant after the compilation
  * of Ivy static fields. The map is keyed by the container node, such that we
@@ -34,7 +33,6 @@ export interface RenderingFormatter {
     addDefinitions(output: MagicString, compiledClass: CompiledClass, definitions: string): void;
     addAdjacentStatements(output: MagicString, compiledClass: CompiledClass, statements: string): void;
     removeDecorators(output: MagicString, decoratorsToRemove: RedundantDecoratorMap): void;
-    rewriteSwitchableDeclarations(outputText: MagicString, sourceFile: ts.SourceFile, declarations: SwitchableVariableDeclaration[]): void;
     addModuleWithProvidersParams(outputText: MagicString, moduleWithProviders: ModuleWithProvidersInfo[], importManager: ImportManager): void;
     printStatement(stmt: Statement, sourceFile: ts.SourceFile, importManager: ImportManager): string;
 }

package/ngcc/src/utils.d.ts

@@ -31,13 +31,6 @@ export interface PartiallyOrderedList<T> extends Array<T> {
 export declare function getOriginalSymbol(checker: ts.TypeChecker): (symbol: ts.Symbol) => ts.Symbol;
 export declare function isDefined<T>(value: T | undefined | null): value is T;
 export declare function getNameText(name: ts.PropertyName | ts.BindingName): string;
-/**
- * Parse down the AST and capture all the nodes that satisfy the test.
- * @param node The start node.
- * @param test The function that tests whether a node should be included.
- * @returns a collection of nodes that satisfy the test.
- */
-export declare function findAll<T>(node: ts.Node, test: (node: ts.Node) => node is ts.Node & T): T[];
 /**
  * Does the given declaration have a name which is an identifier?
  * @param declaration The declaration to test.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "13.1.0-next.1",
+  "version": "13.2.0-next.0",
   "description": "Angular - the compiler CLI for Node.js",
   "typings": "index.d.ts",
   "bin": {
@@ -66,8 +66,8 @@
     "yargs": "^17.2.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "13.1.0-next.1",
-    "typescript": ">=4.4.2 <4.5"
+    "@angular/compiler": "13.2.0-next.0",
+    "typescript": ">=4.4.2 <4.6"
   },
   "repository": {
     "type": "git",

package/src/main.d.ts

@@ -7,7 +7,7 @@
  */
 /// <amd-module name="@angular/compiler-cli/src/main" />
 import ts from 'typescript';
-import { Diagnostics, ParsedConfiguration } from './perform_compile';
+import { ParsedConfiguration } from './perform_compile';
 import * as api from './transformers/api';
 declare type TsickleModule = typeof import('tsickle');
 export declare function main(args: string[], consoleError?: (s: string) => void, config?: NgcParsedConfiguration, customTransformers?: api.CustomTransformers, programReuse?: {
@@ -17,7 +17,7 @@ export declare function mainDiagnosticsForTest(args: string[], config?: NgcParse
     program: api.Program | undefined;
 }, modifiedResourceFiles?: Set<string> | null, tsickle?: TsickleModule): {
     exitCode: number;
-    diagnostics: ReadonlyArray<ts.Diagnostic | api.Diagnostic>;
+    diagnostics: ReadonlyArray<ts.Diagnostic>;
 };
 export interface NgcParsedConfiguration extends ParsedConfiguration {
     watch?: boolean;
@@ -27,6 +27,6 @@ export declare function readCommandLineAndConfiguration(args: string[], existing
 export declare function watchMode(project: string, options: api.CompilerOptions, consoleError: (s: string) => void): {
     close: () => void;
     ready: (cb: () => void) => void;
-    firstCompileResult: Diagnostics;
+    firstCompileResult: readonly ts.Diagnostic[];
 };
 export {};

package/src/ngtsc/core/src/host.d.ts

@@ -42,12 +42,13 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     readResource: ((fileName: string) => string | Promise<string>) | undefined;
     transformResource: ((data: string, context: import("@angular/compiler-cli/src/ngtsc/core/api/index").ResourceHostContext) => Promise<import("@angular/compiler-cli/src/ngtsc/core/api/index").TransformResourceResult | null>) | undefined;
     realpath: ((path: string) => string) | undefined;
-    resolveModuleNames: ((moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ts.ResolvedProjectReference | undefined, options: ts.CompilerOptions) => (ts.ResolvedModule | undefined)[]) | 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;
     resourceNameToFileName: ((resourceName: string, containingFilePath: string, fallbackResolve?: ((url: string, fromFile: string) => string | null) | undefined) => string | null) | undefined;
     trace: ((s: string) => void) | undefined;
     useCaseSensitiveFileNames: () => boolean;
     writeFile: ts.WriteFileCallback;
+    getModuleResolutionCache: any;
 }
 /**
  * A wrapper around `ts.CompilerHost` (plus any extension methods from `ExtendedTsCompilerHost`).

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

@@ -18,6 +18,11 @@ export declare class ArrayConcatBuiltinFn extends KnownFn {
     constructor(lhs: ResolvedValueArray);
     evaluate(node: ts.CallExpression, args: ResolvedValueArray): ResolvedValue;
 }
+export declare class StringConcatBuiltinFn extends KnownFn {
+    private lhs;
+    constructor(lhs: string);
+    evaluate(node: ts.CallExpression, args: ResolvedValueArray): ResolvedValue;
+}
 export declare class ObjectAssignBuiltinFn extends KnownFn {
     evaluate(node: ts.CallExpression, args: ResolvedValueArray): ResolvedValue;
 }

package/src/ngtsc/program.d.ts

@@ -6,7 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/program" />
-import { GeneratedFile } from '@angular/compiler';
 import ts from 'typescript';
 import * as api from '../transformers/api';
 import { NgCompiler } from './core';
@@ -33,9 +32,9 @@ export declare class NgtscProgram implements api.Program {
     getTsOptionDiagnostics(cancellationToken?: ts.CancellationToken | undefined): readonly ts.Diagnostic[];
     getTsSyntacticDiagnostics(sourceFile?: ts.SourceFile | undefined, cancellationToken?: ts.CancellationToken | undefined): readonly ts.Diagnostic[];
     getTsSemanticDiagnostics(sourceFile?: ts.SourceFile | undefined, cancellationToken?: ts.CancellationToken | undefined): readonly ts.Diagnostic[];
-    getNgOptionDiagnostics(cancellationToken?: ts.CancellationToken | undefined): readonly (ts.Diagnostic | api.Diagnostic)[];
-    getNgStructuralDiagnostics(cancellationToken?: ts.CancellationToken | undefined): readonly api.Diagnostic[];
-    getNgSemanticDiagnostics(fileName?: string | undefined, cancellationToken?: ts.CancellationToken | undefined): readonly (ts.Diagnostic | api.Diagnostic)[];
+    getNgOptionDiagnostics(cancellationToken?: ts.CancellationToken | undefined): readonly ts.Diagnostic[];
+    getNgStructuralDiagnostics(cancellationToken?: ts.CancellationToken | undefined): readonly ts.Diagnostic[];
+    getNgSemanticDiagnostics(fileName?: string | undefined, cancellationToken?: ts.CancellationToken | undefined): readonly ts.Diagnostic[];
     /**
      * Ensure that the `NgCompiler` has properly analyzed the program, and allow for the asynchronous
      * loading of any resources during the process.
@@ -54,7 +53,5 @@ export declare class NgtscProgram implements api.Program {
         mergeEmitResultsCallback?: api.TsMergeEmitResultsCallback | undefined;
     } | undefined): ts.EmitResult;
     getIndexedComponents(): Map<DeclarationNode, IndexedComponent>;
-    getLibrarySummaries(): Map<string, api.LibrarySummary>;
-    getEmittedGeneratedFiles(): Map<string, GeneratedFile>;
     getEmittedSourceFiles(): Map<string, ts.SourceFile>;
 }

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

@@ -36,10 +36,11 @@ export declare class DelegatingCompilerHost implements Omit<RequiredDelegations<
     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) => (ts.ResolvedModule | undefined)[]) | 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;
     trace: ((s: string) => void) | undefined;
     useCaseSensitiveFileNames: () => boolean;
+    getModuleResolutionCache: any;
 }
 /**
  * Updates a `ts.Program` instance with a new one that incorporates specific changes, using the

package/src/ngtsc/reflection/src/host.d.ts

@@ -290,7 +290,7 @@ export interface NoValueDeclaration {
 export interface TypeOnlyImport {
     kind: ValueUnavailableKind.TYPE_ONLY_IMPORT;
     typeNode: ts.TypeNode;
-    importClause: ts.ImportClause;
+    node: ts.ImportClause | ts.ImportSpecifier;
 }
 export interface NamespaceImport {
     kind: ValueUnavailableKind.NAMESPACE;

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

@@ -62,3 +62,13 @@ 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;
+/**
+ * Backwards-compatible version of `ts.createImportSpecifier`
+ * to handle a breaking change between 4.4 and 4.5.
+ */
+export declare function createImportSpecifier(propertyName: string | ts.Identifier | undefined, name: string | ts.Identifier, isTypeOnly?: boolean): ts.ImportSpecifier;

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;