@angular/compiler-cli 7.0.0-rc.1 → 7.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/compiler-cli",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.3",
   "description": "Angular - the compiler CLI for Node.js",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -12,7 +12,7 @@
   "dependencies": {
     "reflect-metadata": "^0.1.2",
     "minimist": "^1.2.0",
-    "canonical-path": "0.0.2",
+    "canonical-path": "1.0.0",
     "chokidar": "^1.4.2",
     "convert-source-map": "^1.5.1",
     "dependency-graph": "^0.7.2",
@@ -22,7 +22,7 @@
     "yargs": "9.0.1"
   },
   "peerDependencies": {
-    "@angular/compiler": "7.0.0-rc.1",
+    "@angular/compiler": "7.0.3",
     "typescript": ">=3.1.1 <3.2"
   },
   "engines" : {

package/src/diagnostics/symbols.d.ts

@@ -10,7 +10,7 @@ import { StaticSymbol } from '@angular/compiler';
 /**
  * The range of a span of text in a source file.
  *
- * @experimental
+ * @publicApi
  */
 export interface Span {
     /**
@@ -39,7 +39,7 @@ export declare type Definition = Location[] | undefined;
  * A symbol describing a language element that can be referenced by expressions
  * in an Angular template.
  *
- * @experimental
+ * @publicApi
  */
 export interface Symbol {
     /**
@@ -106,7 +106,7 @@ export interface Symbol {
 /**
  * A table of `Symbol`s accessible by name.
  *
- * @experimental
+ * @publicApi
  */
 export interface SymbolTable {
     /**
@@ -131,7 +131,7 @@ export interface SymbolTable {
 /**
  * A description of a function or method signature.
  *
- * @experimental
+ * @publicApi
  */
 export interface Signature {
     /**
@@ -147,7 +147,7 @@ export interface Signature {
 /**
  * An enumeration of basic types.
  *
- * @experimental
+ * @publicApi
  */
 export declare enum BuiltinType {
     /**
@@ -186,13 +186,13 @@ export declare enum BuiltinType {
 /**
  * The kinds of definition.
  *
- * @experimental
+ * @publicApi
  */
 export declare type DeclarationKind = 'attribute' | 'html attribute' | 'component' | 'element' | 'entity' | 'key' | 'method' | 'pipe' | 'property' | 'type' | 'reference' | 'variable';
 /**
  * Describes a symbol to type binding used to build a symbol table.
  *
- * @experimental
+ * @publicApi
  */
 export interface SymbolDeclaration {
     /**
@@ -215,7 +215,7 @@ export interface SymbolDeclaration {
 /**
  * Information about the pipes that are available for use in a template.
  *
- * @experimental
+ * @publicApi
  */
 export interface PipeInfo {
     /**
@@ -230,13 +230,13 @@ export interface PipeInfo {
 /**
  * A sequence of pipe information.
  *
- * @experimental
+ * @publicApi
  */
 export declare type Pipes = PipeInfo[] | undefined;
 /**
  * Describes the language context in which an Angular expression is evaluated.
  *
- * @experimental
+ * @publicApi
  */
 export interface SymbolQuery {
     /**

package/src/diagnostics/symbols.js

@@ -19,7 +19,7 @@
     /**
      * An enumeration of basic types.
      *
-     * @experimental
+     * @publicApi
      */
     var BuiltinType;
     (function (BuiltinType) {
@@ -57,4 +57,4 @@
         BuiltinType[BuiltinType["Other"] = 7] = "Other";
     })(BuiltinType = exports.BuiltinType || (exports.BuiltinType = {}));
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"symbols.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/src/diagnostics/symbols.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;IAoKH;;;;OAIG;IACH,IAAY,WAwCX;IAxCD,WAAY,WAAW;QACrB;;WAEG;QACH,2CAAG,CAAA;QAEH;;WAEG;QACH,iDAAM,CAAA;QAEN;;WAEG;QACH,iDAAM,CAAA;QAEN;;WAEG;QACH,mDAAO,CAAA;QAEP;;WAEG;QACH,uDAAS,CAAA;QAET;;WAEG;QACH,6CAAI,CAAA;QAEJ;;WAEG;QACH,mDAAO,CAAA;QAEP;;WAEG;QACH,+CAAK,CAAA;IACP,CAAC,EAxCW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAwCtB","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {StaticSymbol} from '@angular/compiler';\n\n/**\n * The range of a span of text in a source file.\n *\n * @experimental\n */\nexport interface Span {\n  /**\n   * The first code-point of the span as an offset relative to the beginning of the source assuming\n   * a UTF-16 encoding.\n   */\n  start: number;\n\n  /**\n   * The first code-point after the span as an offset relative to the beginning of the source\n   * assuming a UTF-16 encoding.\n   */\n  end: number;\n}\n\n/**\n * A file and span.\n */\nexport interface Location {\n  fileName: string;\n  span: Span;\n}\n\n/**\n * A defnition location(s).\n */\nexport type Definition = Location[] | undefined;\n\n/**\n * A symbol describing a language element that can be referenced by expressions\n * in an Angular template.\n *\n * @experimental\n */\nexport interface Symbol {\n  /**\n   * The name of the symbol as it would be referenced in an Angular expression.\n   */\n  readonly name: string;\n\n  /**\n   * The kind of completion this symbol should generate if included.\n   */\n  readonly kind: string;\n\n  /**\n   * The language of the source that defines the symbol. (e.g. typescript for TypeScript,\n   * ng-template for an Angular template, etc.)\n   */\n  readonly language: string;\n\n  /**\n   * A symbol representing type of the symbol.\n   */\n  readonly type: Symbol|undefined;\n\n  /**\n   * A symbol for the container of this symbol. For example, if this is a method, the container\n   * is the class or interface of the method. If no container is appropriate, undefined is\n   * returned.\n   */\n  readonly container: Symbol|undefined;\n\n  /**\n   * The symbol is public in the container.\n   */\n  readonly public: boolean;\n\n  /**\n   * `true` if the symbol can be the target of a call.\n   */\n  readonly callable: boolean;\n\n  /**\n   * The location of the definition of the symbol\n   */\n  readonly definition: Definition|undefined;\n\n  /**\n   * `true` if the symbol is a type that is nullable (can be null or undefined).\n   */\n  readonly nullable: boolean;\n\n  /**\n   * A table of the members of the symbol; that is, the members that can appear\n   * after a `.` in an Angular expression.\n   */\n  members(): SymbolTable;\n\n  /**\n   * The list of overloaded signatures that can be used if the symbol is the\n   * target of a call.\n   */\n  signatures(): Signature[];\n\n  /**\n   * Return which signature of returned by `signatures()` would be used selected\n   * given the `types` supplied. If no signature would match, this method should\n   * return `undefined`.\n   */\n  selectSignature(types: Symbol[]): Signature|undefined;\n\n  /**\n   * Return the type of the expression if this symbol is indexed by `argument`.\n   * If the symbol cannot be indexed, this method should return `undefined`.\n   */\n  indexed(argument: Symbol): Symbol|undefined;\n}\n\n/**\n * A table of `Symbol`s accessible by name.\n *\n * @experimental\n */\nexport interface SymbolTable {\n  /**\n   * The number of symbols in the table.\n   */\n  readonly size: number;\n\n  /**\n   * Get the symbol corresponding to `key` or `undefined` if there is no symbol in the\n   * table by the name `key`.\n   */\n  get(key: string): Symbol|undefined;\n\n  /**\n   * Returns `true` if the table contains a `Symbol` with the name `key`.\n   */\n  has(key: string): boolean;\n\n  /**\n   * Returns all the `Symbol`s in the table. The order should be, but is not required to be,\n   * in declaration order.\n   */\n  values(): Symbol[];\n}\n\n/**\n * A description of a function or method signature.\n *\n * @experimental\n */\nexport interface Signature {\n  /**\n   * The arguments of the signture. The order of `arguments.symbols()` must be in the order\n   * of argument declaration.\n   */\n  readonly arguments: SymbolTable;\n\n  /**\n   * The symbol of the signature result type.\n   */\n  readonly result: Symbol;\n}\n\n/**\n * An enumeration of basic types.\n *\n * @experimental\n */\nexport enum BuiltinType {\n  /**\n   * The type is a type that can hold any other type.\n   */\n  Any,\n\n  /**\n   * The type of a string literal.\n   */\n  String,\n\n  /**\n   * The type of a numeric literal.\n   */\n  Number,\n\n  /**\n   * The type of the `true` and `false` literals.\n   */\n  Boolean,\n\n  /**\n   * The type of the `undefined` literal.\n   */\n  Undefined,\n\n  /**\n   * the type of the `null` literal.\n   */\n  Null,\n\n  /**\n   * the type is an unbound type parameter.\n   */\n  Unbound,\n\n  /**\n   * Not a built-in type.\n   */\n  Other\n}\n\n/**\n * The kinds of definition.\n *\n * @experimental\n */\nexport type DeclarationKind = 'attribute' | 'html attribute' | 'component' | 'element' | 'entity' |\n    'key' | 'method' | 'pipe' | 'property' | 'type' | 'reference' | 'variable';\n\n/**\n * Describes a symbol to type binding used to build a symbol table.\n *\n * @experimental\n */\nexport interface SymbolDeclaration {\n  /**\n   * The name of the symbol in table.\n   */\n  readonly name: string;\n\n  /**\n   * The kind of symbol to declare.\n   */\n  readonly kind: DeclarationKind;\n\n  /**\n   * Type of the symbol. The type symbol should refer to a symbol for a type.\n   */\n  readonly type: Symbol;\n\n  /**\n   * The definion of the symbol if one exists.\n   */\n  readonly definition?: Definition;\n}\n\n/**\n * Information about the pipes that are available for use in a template.\n *\n * @experimental\n */\nexport interface PipeInfo {\n  /**\n   * The name of the pipe.\n   */\n  name: string;\n\n  /**\n   * The static symbol for the pipe's constructor.\n   */\n  symbol: StaticSymbol;\n}\n\n/**\n * A sequence of pipe information.\n *\n * @experimental\n */\nexport type Pipes = PipeInfo[] | undefined;\n\n/**\n * Describes the language context in which an Angular expression is evaluated.\n *\n * @experimental\n */\nexport interface SymbolQuery {\n  /**\n   * Return the built-in type this symbol represents or Other if it is not a built-in type.\n   */\n  getTypeKind(symbol: Symbol): BuiltinType;\n\n  /**\n   * Return a symbol representing the given built-in type.\n   */\n  getBuiltinType(kind: BuiltinType): Symbol;\n\n  /**\n   * Return the symbol for a type that represents the union of all the types given. Any value\n   * of one of the types given should be assignable to the returned type. If no one type can\n   * be constructed then this should be the Any type.\n   */\n  getTypeUnion(...types: Symbol[]): Symbol;\n\n  /**\n   * Return a symbol for an array type that has the `type` as its element type.\n   */\n  getArrayType(type: Symbol): Symbol;\n\n  /**\n   * Return element type symbol for an array type if the `type` is an array type. Otherwise return\n   * undefined.\n   */\n  getElementType(type: Symbol): Symbol|undefined;\n\n  /**\n   * Return a type that is the non-nullable version of the given type. If `type` is already\n   * non-nullable, return `type`.\n   */\n  getNonNullableType(type: Symbol): Symbol;\n\n  /**\n   * Return a symbol table for the pipes that are in scope.\n   */\n  getPipes(): SymbolTable;\n\n  /**\n   * Return the type symbol for the given static symbol.\n   */\n  getTypeSymbol(type: StaticSymbol): Symbol|undefined;\n\n  /**\n   * Return the members that are in the context of a type's template reference.\n   */\n  getTemplateContext(type: StaticSymbol): SymbolTable|undefined;\n\n  /**\n   * Produce a symbol table with the given symbols. Used to produce a symbol table\n   * for use with mergeSymbolTables().\n   */\n  createSymbolTable(symbols: SymbolDeclaration[]): SymbolTable;\n\n  /**\n   * Produce a merged symbol table. If the symbol tables contain duplicate entries\n   * the entries of the latter symbol tables will obscure the entries in the prior\n   * symbol tables.\n   *\n   * The symbol tables passed to this routine MUST be produces by the same instance\n   * of SymbolQuery that is being called.\n   */\n  mergeSymbolTable(symbolTables: SymbolTable[]): SymbolTable;\n\n  /**\n   * Return the span of the narrowest non-token node at the given location.\n   */\n  getSpanAt(line: number, column: number): Span|undefined;\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"symbols.js","sourceRoot":"","sources":["../../../../../../../packages/compiler-cli/src/diagnostics/symbols.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;;;;;;;;;;;IAoKH;;;;OAIG;IACH,IAAY,WAwCX;IAxCD,WAAY,WAAW;QACrB;;WAEG;QACH,2CAAG,CAAA;QAEH;;WAEG;QACH,iDAAM,CAAA;QAEN;;WAEG;QACH,iDAAM,CAAA;QAEN;;WAEG;QACH,mDAAO,CAAA;QAEP;;WAEG;QACH,uDAAS,CAAA;QAET;;WAEG;QACH,6CAAI,CAAA;QAEJ;;WAEG;QACH,mDAAO,CAAA;QAEP;;WAEG;QACH,+CAAK,CAAA;IACP,CAAC,EAxCW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAwCtB","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {StaticSymbol} from '@angular/compiler';\n\n/**\n * The range of a span of text in a source file.\n *\n * @publicApi\n */\nexport interface Span {\n  /**\n   * The first code-point of the span as an offset relative to the beginning of the source assuming\n   * a UTF-16 encoding.\n   */\n  start: number;\n\n  /**\n   * The first code-point after the span as an offset relative to the beginning of the source\n   * assuming a UTF-16 encoding.\n   */\n  end: number;\n}\n\n/**\n * A file and span.\n */\nexport interface Location {\n  fileName: string;\n  span: Span;\n}\n\n/**\n * A defnition location(s).\n */\nexport type Definition = Location[] | undefined;\n\n/**\n * A symbol describing a language element that can be referenced by expressions\n * in an Angular template.\n *\n * @publicApi\n */\nexport interface Symbol {\n  /**\n   * The name of the symbol as it would be referenced in an Angular expression.\n   */\n  readonly name: string;\n\n  /**\n   * The kind of completion this symbol should generate if included.\n   */\n  readonly kind: string;\n\n  /**\n   * The language of the source that defines the symbol. (e.g. typescript for TypeScript,\n   * ng-template for an Angular template, etc.)\n   */\n  readonly language: string;\n\n  /**\n   * A symbol representing type of the symbol.\n   */\n  readonly type: Symbol|undefined;\n\n  /**\n   * A symbol for the container of this symbol. For example, if this is a method, the container\n   * is the class or interface of the method. If no container is appropriate, undefined is\n   * returned.\n   */\n  readonly container: Symbol|undefined;\n\n  /**\n   * The symbol is public in the container.\n   */\n  readonly public: boolean;\n\n  /**\n   * `true` if the symbol can be the target of a call.\n   */\n  readonly callable: boolean;\n\n  /**\n   * The location of the definition of the symbol\n   */\n  readonly definition: Definition|undefined;\n\n  /**\n   * `true` if the symbol is a type that is nullable (can be null or undefined).\n   */\n  readonly nullable: boolean;\n\n  /**\n   * A table of the members of the symbol; that is, the members that can appear\n   * after a `.` in an Angular expression.\n   */\n  members(): SymbolTable;\n\n  /**\n   * The list of overloaded signatures that can be used if the symbol is the\n   * target of a call.\n   */\n  signatures(): Signature[];\n\n  /**\n   * Return which signature of returned by `signatures()` would be used selected\n   * given the `types` supplied. If no signature would match, this method should\n   * return `undefined`.\n   */\n  selectSignature(types: Symbol[]): Signature|undefined;\n\n  /**\n   * Return the type of the expression if this symbol is indexed by `argument`.\n   * If the symbol cannot be indexed, this method should return `undefined`.\n   */\n  indexed(argument: Symbol): Symbol|undefined;\n}\n\n/**\n * A table of `Symbol`s accessible by name.\n *\n * @publicApi\n */\nexport interface SymbolTable {\n  /**\n   * The number of symbols in the table.\n   */\n  readonly size: number;\n\n  /**\n   * Get the symbol corresponding to `key` or `undefined` if there is no symbol in the\n   * table by the name `key`.\n   */\n  get(key: string): Symbol|undefined;\n\n  /**\n   * Returns `true` if the table contains a `Symbol` with the name `key`.\n   */\n  has(key: string): boolean;\n\n  /**\n   * Returns all the `Symbol`s in the table. The order should be, but is not required to be,\n   * in declaration order.\n   */\n  values(): Symbol[];\n}\n\n/**\n * A description of a function or method signature.\n *\n * @publicApi\n */\nexport interface Signature {\n  /**\n   * The arguments of the signture. The order of `arguments.symbols()` must be in the order\n   * of argument declaration.\n   */\n  readonly arguments: SymbolTable;\n\n  /**\n   * The symbol of the signature result type.\n   */\n  readonly result: Symbol;\n}\n\n/**\n * An enumeration of basic types.\n *\n * @publicApi\n */\nexport enum BuiltinType {\n  /**\n   * The type is a type that can hold any other type.\n   */\n  Any,\n\n  /**\n   * The type of a string literal.\n   */\n  String,\n\n  /**\n   * The type of a numeric literal.\n   */\n  Number,\n\n  /**\n   * The type of the `true` and `false` literals.\n   */\n  Boolean,\n\n  /**\n   * The type of the `undefined` literal.\n   */\n  Undefined,\n\n  /**\n   * the type of the `null` literal.\n   */\n  Null,\n\n  /**\n   * the type is an unbound type parameter.\n   */\n  Unbound,\n\n  /**\n   * Not a built-in type.\n   */\n  Other\n}\n\n/**\n * The kinds of definition.\n *\n * @publicApi\n */\nexport type DeclarationKind = 'attribute' | 'html attribute' | 'component' | 'element' | 'entity' |\n    'key' | 'method' | 'pipe' | 'property' | 'type' | 'reference' | 'variable';\n\n/**\n * Describes a symbol to type binding used to build a symbol table.\n *\n * @publicApi\n */\nexport interface SymbolDeclaration {\n  /**\n   * The name of the symbol in table.\n   */\n  readonly name: string;\n\n  /**\n   * The kind of symbol to declare.\n   */\n  readonly kind: DeclarationKind;\n\n  /**\n   * Type of the symbol. The type symbol should refer to a symbol for a type.\n   */\n  readonly type: Symbol;\n\n  /**\n   * The definion of the symbol if one exists.\n   */\n  readonly definition?: Definition;\n}\n\n/**\n * Information about the pipes that are available for use in a template.\n *\n * @publicApi\n */\nexport interface PipeInfo {\n  /**\n   * The name of the pipe.\n   */\n  name: string;\n\n  /**\n   * The static symbol for the pipe's constructor.\n   */\n  symbol: StaticSymbol;\n}\n\n/**\n * A sequence of pipe information.\n *\n * @publicApi\n */\nexport type Pipes = PipeInfo[] | undefined;\n\n/**\n * Describes the language context in which an Angular expression is evaluated.\n *\n * @publicApi\n */\nexport interface SymbolQuery {\n  /**\n   * Return the built-in type this symbol represents or Other if it is not a built-in type.\n   */\n  getTypeKind(symbol: Symbol): BuiltinType;\n\n  /**\n   * Return a symbol representing the given built-in type.\n   */\n  getBuiltinType(kind: BuiltinType): Symbol;\n\n  /**\n   * Return the symbol for a type that represents the union of all the types given. Any value\n   * of one of the types given should be assignable to the returned type. If no one type can\n   * be constructed then this should be the Any type.\n   */\n  getTypeUnion(...types: Symbol[]): Symbol;\n\n  /**\n   * Return a symbol for an array type that has the `type` as its element type.\n   */\n  getArrayType(type: Symbol): Symbol;\n\n  /**\n   * Return element type symbol for an array type if the `type` is an array type. Otherwise return\n   * undefined.\n   */\n  getElementType(type: Symbol): Symbol|undefined;\n\n  /**\n   * Return a type that is the non-nullable version of the given type. If `type` is already\n   * non-nullable, return `type`.\n   */\n  getNonNullableType(type: Symbol): Symbol;\n\n  /**\n   * Return a symbol table for the pipes that are in scope.\n   */\n  getPipes(): SymbolTable;\n\n  /**\n   * Return the type symbol for the given static symbol.\n   */\n  getTypeSymbol(type: StaticSymbol): Symbol|undefined;\n\n  /**\n   * Return the members that are in the context of a type's template reference.\n   */\n  getTemplateContext(type: StaticSymbol): SymbolTable|undefined;\n\n  /**\n   * Produce a symbol table with the given symbols. Used to produce a symbol table\n   * for use with mergeSymbolTables().\n   */\n  createSymbolTable(symbols: SymbolDeclaration[]): SymbolTable;\n\n  /**\n   * Produce a merged symbol table. If the symbol tables contain duplicate entries\n   * the entries of the latter symbol tables will obscure the entries in the prior\n   * symbol tables.\n   *\n   * The symbol tables passed to this routine MUST be produces by the same instance\n   * of SymbolQuery that is being called.\n   */\n  mergeSymbolTable(symbolTables: SymbolTable[]): SymbolTable;\n\n  /**\n   * Return the span of the narrowest non-token node at the given location.\n   */\n  getSpanAt(line: number, column: number): Span|undefined;\n}"]}

package/src/ngcc/src/analysis/decoration_analyzer.d.ts

@@ -0,0 +1,65 @@
+/// <amd-module name="@angular/compiler-cli/src/ngcc/src/analysis/decoration_analyzer" />
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import { ConstantPool } from '@angular/compiler';
+import * as ts from 'typescript';
+import { ResourceLoader, SelectorScopeRegistry } from '../../../ngtsc/annotations';
+import { CompileResult, DecoratorHandler } from '../../../ngtsc/transform';
+import { DecoratedClass } from '../host/decorated_class';
+import { DecoratedFile } from '../host/decorated_file';
+import { NgccReflectionHost } from '../host/ngcc_host';
+export interface AnalyzedClass<A = any, M = any> extends DecoratedClass {
+    handler: DecoratorHandler<A, M>;
+    analysis: any;
+    diagnostics?: ts.Diagnostic[];
+    compilation: CompileResult[];
+}
+export interface DecorationAnalysis {
+    analyzedClasses: AnalyzedClass[];
+    sourceFile: ts.SourceFile;
+    constantPool: ConstantPool;
+}
+export declare type DecorationAnalyses = Map<ts.SourceFile, DecorationAnalysis>;
+export declare const DecorationAnalyses: MapConstructor;
+export interface MatchingHandler<A, M> {
+    handler: DecoratorHandler<A, M>;
+    match: M;
+}
+/**
+ * `ResourceLoader` which directly uses the filesystem to resolve resources synchronously.
+ */
+export declare class FileResourceLoader implements ResourceLoader {
+    load(url: string): string;
+}
+/**
+ * This Analyzer will analyze the files that have decorated classes that need to be transformed.
+ */
+export declare class DecorationAnalyzer {
+    private typeChecker;
+    private host;
+    private rootDirs;
+    private isCore;
+    resourceLoader: FileResourceLoader;
+    scopeRegistry: SelectorScopeRegistry;
+    handlers: DecoratorHandler<any, any>[];
+    constructor(typeChecker: ts.TypeChecker, host: NgccReflectionHost, rootDirs: string[], isCore: boolean);
+    /**
+     * Analyze a program to find all the decorated files should be transformed.
+     * @param program The program whose files should be analysed.
+     * @returns a map of the source files to the analysis for those files.
+     */
+    analyzeProgram(program: ts.Program): DecorationAnalyses;
+    /**
+     * Analyze a decorated file to generate the information about decorated classes that
+     * should be converted to use ivy definitions.
+     * @param file The file to be analysed for decorated classes.
+     * @returns the analysis of the file
+     */
+    protected analyzeFile(file: DecoratedFile): DecorationAnalysis;
+    protected analyzeClass(pool: ConstantPool, clazz: DecoratedClass): AnalyzedClass | undefined;
+}

package/src/ngcc/src/analysis/decoration_analyzer.js

@@ -0,0 +1,116 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngcc/src/analysis/decoration_analyzer", ["require", "exports", "tslib", "@angular/compiler", "fs", "@angular/compiler-cli/src/ngtsc/annotations", "@angular/compiler-cli/src/ngcc/src/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var tslib_1 = require("tslib");
+    /**
+     * @license
+     * Copyright Google Inc. 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
+     */
+    var compiler_1 = require("@angular/compiler");
+    var fs = require("fs");
+    var annotations_1 = require("@angular/compiler-cli/src/ngtsc/annotations");
+    var utils_1 = require("@angular/compiler-cli/src/ngcc/src/utils");
+    exports.DecorationAnalyses = Map;
+    /**
+     * `ResourceLoader` which directly uses the filesystem to resolve resources synchronously.
+     */
+    var FileResourceLoader = /** @class */ (function () {
+        function FileResourceLoader() {
+        }
+        FileResourceLoader.prototype.load = function (url) { return fs.readFileSync(url, 'utf8'); };
+        return FileResourceLoader;
+    }());
+    exports.FileResourceLoader = FileResourceLoader;
+    /**
+     * This Analyzer will analyze the files that have decorated classes that need to be transformed.
+     */
+    var DecorationAnalyzer = /** @class */ (function () {
+        function DecorationAnalyzer(typeChecker, host, rootDirs, isCore) {
+            this.typeChecker = typeChecker;
+            this.host = host;
+            this.rootDirs = rootDirs;
+            this.isCore = isCore;
+            this.resourceLoader = new FileResourceLoader();
+            this.scopeRegistry = new annotations_1.SelectorScopeRegistry(this.typeChecker, this.host);
+            this.handlers = [
+                new annotations_1.BaseDefDecoratorHandler(this.typeChecker, this.host),
+                new annotations_1.ComponentDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore, this.resourceLoader, this.rootDirs),
+                new annotations_1.DirectiveDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore),
+                new annotations_1.InjectableDecoratorHandler(this.host, this.isCore),
+                new annotations_1.NgModuleDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore),
+                new annotations_1.PipeDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore),
+            ];
+        }
+        /**
+         * Analyze a program to find all the decorated files should be transformed.
+         * @param program The program whose files should be analysed.
+         * @returns a map of the source files to the analysis for those files.
+         */
+        DecorationAnalyzer.prototype.analyzeProgram = function (program) {
+            var _this = this;
+            var analyzedFiles = new exports.DecorationAnalyses();
+            program.getRootFileNames().forEach(function (fileName) {
+                var entryPoint = program.getSourceFile(fileName);
+                var decoratedFiles = _this.host.findDecoratedFiles(entryPoint);
+                decoratedFiles.forEach(function (decoratedFile) {
+                    return analyzedFiles.set(decoratedFile.sourceFile, _this.analyzeFile(decoratedFile));
+                });
+            });
+            return analyzedFiles;
+        };
+        /**
+         * Analyze a decorated file to generate the information about decorated classes that
+         * should be converted to use ivy definitions.
+         * @param file The file to be analysed for decorated classes.
+         * @returns the analysis of the file
+         */
+        DecorationAnalyzer.prototype.analyzeFile = function (file) {
+            var _this = this;
+            var constantPool = new compiler_1.ConstantPool();
+            var analyzedClasses = file.decoratedClasses.map(function (clazz) { return _this.analyzeClass(constantPool, clazz); })
+                .filter(utils_1.isDefined);
+            return {
+                analyzedClasses: analyzedClasses,
+                sourceFile: file.sourceFile, constantPool: constantPool,
+            };
+        };
+        DecorationAnalyzer.prototype.analyzeClass = function (pool, clazz) {
+            var matchingHandlers = this.handlers
+                .map(function (handler) { return ({
+                handler: handler,
+                match: handler.detect(clazz.declaration, clazz.decorators),
+            }); })
+                .filter(isMatchingHandler);
+            if (matchingHandlers.length > 1) {
+                throw new Error('TODO.Diagnostic: Class has multiple Angular decorators.');
+            }
+            if (matchingHandlers.length === 0) {
+                return undefined;
+            }
+            var _a = matchingHandlers[0], handler = _a.handler, match = _a.match;
+            var _b = handler.analyze(clazz.declaration, match), analysis = _b.analysis, diagnostics = _b.diagnostics;
+            var compilation = handler.compile(clazz.declaration, analysis, pool);
+            if (!Array.isArray(compilation)) {
+                compilation = [compilation];
+            }
+            return tslib_1.__assign({}, clazz, { handler: handler, analysis: analysis, diagnostics: diagnostics, compilation: compilation });
+        };
+        return DecorationAnalyzer;
+    }());
+    exports.DecorationAnalyzer = DecorationAnalyzer;
+    function isMatchingHandler(handler) {
+        return !!handler.match;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decoration_analyzer.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngcc/src/analysis/decoration_analyzer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {ConstantPool} from '@angular/compiler';\nimport * as fs from 'fs';\nimport * as ts from 'typescript';\n\nimport {BaseDefDecoratorHandler, ComponentDecoratorHandler, DirectiveDecoratorHandler, InjectableDecoratorHandler, NgModuleDecoratorHandler, PipeDecoratorHandler, ResourceLoader, SelectorScopeRegistry} from '../../../ngtsc/annotations';\nimport {CompileResult, DecoratorHandler} from '../../../ngtsc/transform';\n\nimport {DecoratedClass} from '../host/decorated_class';\nimport {DecoratedFile} from '../host/decorated_file';\nimport {NgccReflectionHost} from '../host/ngcc_host';\nimport {isDefined} from '../utils';\n\nexport interface AnalyzedClass<A = any, M = any> extends DecoratedClass {\n  handler: DecoratorHandler<A, M>;\n  analysis: any;\n  diagnostics?: ts.Diagnostic[];\n  compilation: CompileResult[];\n}\n\nexport interface DecorationAnalysis {\n  analyzedClasses: AnalyzedClass[];\n  sourceFile: ts.SourceFile;\n  constantPool: ConstantPool;\n}\n\nexport type DecorationAnalyses = Map<ts.SourceFile, DecorationAnalysis>;\nexport const DecorationAnalyses = Map;\n\nexport interface MatchingHandler<A, M> {\n  handler: DecoratorHandler<A, M>;\n  match: M;\n}\n\n/**\n * `ResourceLoader` which directly uses the filesystem to resolve resources synchronously.\n */\nexport class FileResourceLoader implements ResourceLoader {\n  load(url: string): string { return fs.readFileSync(url, 'utf8'); }\n}\n\n/**\n * This Analyzer will analyze the files that have decorated classes that need to be transformed.\n */\nexport class DecorationAnalyzer {\n  resourceLoader = new FileResourceLoader();\n  scopeRegistry = new SelectorScopeRegistry(this.typeChecker, this.host);\n  handlers: DecoratorHandler<any, any>[] = [\n    new BaseDefDecoratorHandler(this.typeChecker, this.host),\n    new ComponentDecoratorHandler(\n        this.typeChecker, this.host, this.scopeRegistry, this.isCore, this.resourceLoader,\n        this.rootDirs),\n    new DirectiveDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore),\n    new InjectableDecoratorHandler(this.host, this.isCore),\n    new NgModuleDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore),\n    new PipeDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore),\n  ];\n\n  constructor(\n      private typeChecker: ts.TypeChecker, private host: NgccReflectionHost,\n      private rootDirs: string[], private isCore: boolean) {}\n\n  /**\n   * Analyze a program to find all the decorated files should be transformed.\n   * @param program The program whose files should be analysed.\n   * @returns a map of the source files to the analysis for those files.\n   */\n  analyzeProgram(program: ts.Program): DecorationAnalyses {\n    const analyzedFiles = new DecorationAnalyses();\n    program.getRootFileNames().forEach(fileName => {\n      const entryPoint = program.getSourceFile(fileName) !;\n      const decoratedFiles = this.host.findDecoratedFiles(entryPoint);\n      decoratedFiles.forEach(\n          decoratedFile =>\n              analyzedFiles.set(decoratedFile.sourceFile, this.analyzeFile(decoratedFile)));\n    });\n    return analyzedFiles;\n  }\n\n  /**\n   * Analyze a decorated file to generate the information about decorated classes that\n   * should be converted to use ivy definitions.\n   * @param file The file to be analysed for decorated classes.\n   * @returns the analysis of the file\n   */\n  protected analyzeFile(file: DecoratedFile): DecorationAnalysis {\n    const constantPool = new ConstantPool();\n    const analyzedClasses =\n        file.decoratedClasses.map(clazz => this.analyzeClass(constantPool, clazz))\n            .filter(isDefined);\n\n    return {\n      analyzedClasses,\n      sourceFile: file.sourceFile, constantPool,\n    };\n  }\n\n  protected analyzeClass(pool: ConstantPool, clazz: DecoratedClass): AnalyzedClass|undefined {\n    const matchingHandlers = this.handlers\n                                 .map(handler => ({\n                                        handler,\n                                        match: handler.detect(clazz.declaration, clazz.decorators),\n                                      }))\n                                 .filter(isMatchingHandler);\n\n    if (matchingHandlers.length > 1) {\n      throw new Error('TODO.Diagnostic: Class has multiple Angular decorators.');\n    }\n\n    if (matchingHandlers.length === 0) {\n      return undefined;\n    }\n\n    const {handler, match} = matchingHandlers[0];\n    const {analysis, diagnostics} = handler.analyze(clazz.declaration, match);\n    let compilation = handler.compile(clazz.declaration, analysis, pool);\n    if (!Array.isArray(compilation)) {\n      compilation = [compilation];\n    }\n    return {...clazz, handler, analysis, diagnostics, compilation};\n  }\n}\n\nfunction isMatchingHandler<A, M>(handler: Partial<MatchingHandler<A, M>>):\n    handler is MatchingHandler<A, M> {\n  return !!handler.match;\n}\n"]}

package/src/ngcc/src/analysis/switch_marker_analyzer.d.ts

@@ -0,0 +1,33 @@
+/// <amd-module name="@angular/compiler-cli/src/ngcc/src/analysis/switch_marker_analyzer" />
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+import * as ts from 'typescript';
+import { NgccReflectionHost, SwitchableVariableDeclaration } from '../host/ngcc_host';
+export interface SwitchMarkerAnalysis {
+    sourceFile: ts.SourceFile;
+    declarations: SwitchableVariableDeclaration[];
+}
+export declare type SwitchMarkerAnalyses = Map<ts.SourceFile, SwitchMarkerAnalysis>;
+export declare const SwitchMarkerAnalyses: MapConstructor;
+/**
+ * This Analyzer will analyse the files that have an NGCC switch marker in them
+ * that will be replaced.
+ */
+export declare class SwitchMarkerAnalyzer {
+    private host;
+    constructor(host: NgccReflectionHost);
+    /**
+     * Analyze the files in the program to identify declarations that contain NGCC
+     * switch markers.
+     * @param program The program to analyze.
+     * @return A map of source files to analysis objects. The map will contain only the
+     * source files that had switch markers, and the analysis will contain an array of
+     * the declarations in that source file that contain the marker.
+     */
+    analyzeProgram(program: ts.Program): SwitchMarkerAnalyses;
+}

package/src/ngcc/src/analysis/switch_marker_analyzer.js

@@ -0,0 +1,44 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngcc/src/analysis/switch_marker_analyzer", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SwitchMarkerAnalyses = Map;
+    /**
+     * This Analyzer will analyse the files that have an NGCC switch marker in them
+     * that will be replaced.
+     */
+    var SwitchMarkerAnalyzer = /** @class */ (function () {
+        function SwitchMarkerAnalyzer(host) {
+            this.host = host;
+        }
+        /**
+         * Analyze the files in the program to identify declarations that contain NGCC
+         * switch markers.
+         * @param program The program to analyze.
+         * @return A map of source files to analysis objects. The map will contain only the
+         * source files that had switch markers, and the analysis will contain an array of
+         * the declarations in that source file that contain the marker.
+         */
+        SwitchMarkerAnalyzer.prototype.analyzeProgram = function (program) {
+            var _this = this;
+            var analyzedFiles = new exports.SwitchMarkerAnalyses();
+            program.getSourceFiles().forEach(function (sourceFile) {
+                var declarations = _this.host.getSwitchableDeclarations(sourceFile);
+                if (declarations.length) {
+                    analyzedFiles.set(sourceFile, { sourceFile: sourceFile, declarations: declarations });
+                }
+            });
+            return analyzedFiles;
+        };
+        return SwitchMarkerAnalyzer;
+    }());
+    exports.SwitchMarkerAnalyzer = SwitchMarkerAnalyzer;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngcc/src/{parsing/parsed_class.d.ts → host/decorated_class.d.ts}

@@ -5,19 +5,19 @@
  * 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/ngcc/src/parsing/parsed_class" />
+/// <amd-module name="@angular/compiler-cli/src/ngcc/src/host/decorated_class" />
 import * as ts from 'typescript';
 import { Decorator } from '../../../ngtsc/host';
 /**
  * A simple container that holds the details of a decorated class that has been
- * parsed out of a package.
+ * found in a `DecoratedFile`.
  */
-export declare class ParsedClass {
+export declare class DecoratedClass {
     name: string;
     declaration: ts.Declaration;
     decorators: Decorator[];
     /**
-     * Initialize a `DecoratedClass` that was found by parsing a package.
+     * Initialize a `DecoratedClass` that was found in a `DecoratedFile`.
      * @param name The name of the class that has been found. This is mostly used
      * for informational purposes.
      * @param declaration The TypeScript AST node where this class is declared

package/src/ngcc/src/host/decorated_class.js

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngcc/src/host/decorated_class", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * A simple container that holds the details of a decorated class that has been
+     * found in a `DecoratedFile`.
+     */
+    var DecoratedClass = /** @class */ (function () {
+        /**
+         * Initialize a `DecoratedClass` that was found in a `DecoratedFile`.
+         * @param name The name of the class that has been found. This is mostly used
+         * for informational purposes.
+         * @param declaration The TypeScript AST node where this class is declared
+         * @param decorators The collection of decorators that have been found on this class.
+         */
+        function DecoratedClass(name, declaration, decorators) {
+            this.name = name;
+            this.declaration = declaration;
+            this.decorators = decorators;
+        }
+        return DecoratedClass;
+    }());
+    exports.DecoratedClass = DecoratedClass;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdGVkX2NsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL3NyYy9uZ2NjL3NyYy9ob3N0L2RlY29yYXRlZF9jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQUtIOzs7T0FHRztJQUNIO1FBQ0U7Ozs7OztXQU1HO1FBQ0gsd0JBQ1csSUFBWSxFQUFTLFdBQTJCLEVBQVMsVUFBdUI7WUFBaEYsU0FBSSxHQUFKLElBQUksQ0FBUTtZQUFTLGdCQUFXLEdBQVgsV0FBVyxDQUFnQjtZQUFTLGVBQVUsR0FBVixVQUFVLENBQWE7UUFBSyxDQUFDO1FBQ25HLHFCQUFDO0lBQUQsQ0FBQyxBQVZELElBVUM7SUFWWSx3Q0FBYyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5pbXBvcnQge0RlY29yYXRvcn0gZnJvbSAnLi4vLi4vLi4vbmd0c2MvaG9zdCc7XG5cbi8qKlxuICogQSBzaW1wbGUgY29udGFpbmVyIHRoYXQgaG9sZHMgdGhlIGRldGFpbHMgb2YgYSBkZWNvcmF0ZWQgY2xhc3MgdGhhdCBoYXMgYmVlblxuICogZm91bmQgaW4gYSBgRGVjb3JhdGVkRmlsZWAuXG4gKi9cbmV4cG9ydCBjbGFzcyBEZWNvcmF0ZWRDbGFzcyB7XG4gIC8qKlxuICAgKiBJbml0aWFsaXplIGEgYERlY29yYXRlZENsYXNzYCB0aGF0IHdhcyBmb3VuZCBpbiBhIGBEZWNvcmF0ZWRGaWxlYC5cbiAgICogQHBhcmFtIG5hbWUgVGhlIG5hbWUgb2YgdGhlIGNsYXNzIHRoYXQgaGFzIGJlZW4gZm91bmQuIFRoaXMgaXMgbW9zdGx5IHVzZWRcbiAgICogZm9yIGluZm9ybWF0aW9uYWwgcHVycG9zZXMuXG4gICAqIEBwYXJhbSBkZWNsYXJhdGlvbiBUaGUgVHlwZVNjcmlwdCBBU1Qgbm9kZSB3aGVyZSB0aGlzIGNsYXNzIGlzIGRlY2xhcmVkXG4gICAqIEBwYXJhbSBkZWNvcmF0b3JzIFRoZSBjb2xsZWN0aW9uIG9mIGRlY29yYXRvcnMgdGhhdCBoYXZlIGJlZW4gZm91bmQgb24gdGhpcyBjbGFzcy5cbiAgICovXG4gIGNvbnN0cnVjdG9yKFxuICAgICAgcHVibGljIG5hbWU6IHN0cmluZywgcHVibGljIGRlY2xhcmF0aW9uOiB0cy5EZWNsYXJhdGlvbiwgcHVibGljIGRlY29yYXRvcnM6IERlY29yYXRvcltdLCApIHt9XG59XG4iXX0=

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

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google Inc. 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/ngcc/src/host/decorated_file" />
+import * as ts from 'typescript';
+import { DecoratedClass } from './decorated_class';
+/**
+ * Information about a source file that contains decorated exported classes.
+ */
+export declare class DecoratedFile {
+    sourceFile: ts.SourceFile;
+    /**
+     * The decorated exported classes that have been found in the file.
+     */
+    decoratedClasses: DecoratedClass[];
+    constructor(sourceFile: ts.SourceFile);
+}

package/src/ngcc/src/host/decorated_file.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google Inc. 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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/src/ngcc/src/host/decorated_file", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * Information about a source file that contains decorated exported classes.
+     */
+    var DecoratedFile = /** @class */ (function () {
+        function DecoratedFile(sourceFile) {
+            this.sourceFile = sourceFile;
+            /**
+             * The decorated exported classes that have been found in the file.
+             */
+            this.decoratedClasses = [];
+        }
+        return DecoratedFile;
+    }());
+    exports.DecoratedFile = DecoratedFile;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdGVkX2ZpbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvc3JjL25nY2Mvc3JjL2hvc3QvZGVjb3JhdGVkX2ZpbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7SUFLSDs7T0FFRztJQUNIO1FBS0UsdUJBQW1CLFVBQXlCO1lBQXpCLGVBQVUsR0FBVixVQUFVLENBQWU7WUFKNUM7O2VBRUc7WUFDSSxxQkFBZ0IsR0FBcUIsRUFBRSxDQUFDO1FBQ0EsQ0FBQztRQUNsRCxvQkFBQztJQUFELENBQUMsQUFORCxJQU1DO0lBTlksc0NBQWEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCAqIGFzIHRzIGZyb20gJ3R5cGVzY3JpcHQnO1xuaW1wb3J0IHtEZWNvcmF0ZWRDbGFzc30gZnJvbSAnLi9kZWNvcmF0ZWRfY2xhc3MnO1xuXG4vKipcbiAqIEluZm9ybWF0aW9uIGFib3V0IGEgc291cmNlIGZpbGUgdGhhdCBjb250YWlucyBkZWNvcmF0ZWQgZXhwb3J0ZWQgY2xhc3Nlcy5cbiAqL1xuZXhwb3J0IGNsYXNzIERlY29yYXRlZEZpbGUge1xuICAvKipcbiAgICogVGhlIGRlY29yYXRlZCBleHBvcnRlZCBjbGFzc2VzIHRoYXQgaGF2ZSBiZWVuIGZvdW5kIGluIHRoZSBmaWxlLlxuICAgKi9cbiAgcHVibGljIGRlY29yYXRlZENsYXNzZXM6IERlY29yYXRlZENsYXNzW10gPSBbXTtcbiAgY29uc3RydWN0b3IocHVibGljIHNvdXJjZUZpbGU6IHRzLlNvdXJjZUZpbGUpIHt9XG59XG4iXX0=

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

@@ -8,6 +8,7 @@
 /// <amd-module name="@angular/compiler-cli/src/ngcc/src/host/esm5_host" />
 import * as ts from 'typescript';
 import { ClassMember, Decorator, FunctionDefinition } from '../../../ngtsc/host';
+import { DecoratedFile } from './decorated_file';
 import { Fesm2015ReflectionHost, ParamInfo } from './fesm2015_host';
 /**
  * ESM5 packages contain ECMAScript IIFE functions that act like classes. For example:
@@ -60,6 +61,13 @@ export declare class Esm5ReflectionHost extends Fesm2015ReflectionHost {
      * @returns an object containing the node, statements and parameters of the function.
      */
     getDefinitionOfFunction<T extends ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression>(node: T): FunctionDefinition<T>;
+    /**
+       * Find all the files accessible via an entry-point, that contain decorated classes.
+       * @param entryPoint The starting point file for finding files that contain decorated classes.
+       * @returns A collection of files objects that hold info about the decorated classes and import
+       * information.
+       */
+    findDecoratedFiles(entryPoint: ts.SourceFile): Map<ts.SourceFile, DecoratedFile>;
     /**
      * Find the declarations of the constructor parameters of a class identified by its symbol.
      *