@angular/compiler-cli 7.2.0-beta.0 → 7.2.0

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

@@ -4,7 +4,7 @@
         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);
+        define("@angular/compiler-cli/src/ngcc/src/analysis/decoration_analyzer", ["require", "exports", "tslib", "@angular/compiler", "canonical-path", "fs", "@angular/compiler-cli/src/ngtsc/annotations", "@angular/compiler-cli/src/ngcc/src/utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -18,6 +18,7 @@
      * found in the LICENSE file at https://angular.io/license
      */
     var compiler_1 = require("@angular/compiler");
+    var path = require("canonical-path");
     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");
@@ -28,7 +29,10 @@
     var FileResourceLoader = /** @class */ (function () {
         function FileResourceLoader() {
         }
-        FileResourceLoader.prototype.load = function (url) { return fs.readFileSync(url, 'utf8'); };
+        FileResourceLoader.prototype.load = function (url, containingFile) {
+            url = path.resolve(path.dirname(containingFile), url);
+            return fs.readFileSync(url, 'utf8');
+        };
         return FileResourceLoader;
     }());
     exports.FileResourceLoader = FileResourceLoader;
@@ -36,19 +40,20 @@
      * 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) {
+        function DecorationAnalyzer(typeChecker, host, referencesRegistry, rootDirs, isCore) {
             this.typeChecker = typeChecker;
             this.host = host;
+            this.referencesRegistry = referencesRegistry;
             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.ComponentDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore, this.resourceLoader, this.rootDirs, /* defaultPreserveWhitespaces */ false, /* i18nUseExternalIds */ true),
                 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.NgModuleDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.referencesRegistry, this.isCore),
                 new annotations_1.PipeDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore),
             ];
         }
@@ -114,4 +119,4 @@
         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 {NgccReflectionHost} from '../host/ngcc_host';\nimport {isDefined} from '../utils';\n\nexport interface AnalyzedFile {\n  sourceFile: ts.SourceFile;\n  analyzedClasses: AnalyzedClass[];\n}\n\nexport interface AnalyzedClass extends DecoratedClass {\n  diagnostics?: ts.Diagnostic[];\n  handler: DecoratorHandler<any, any>;\n  analysis: any;\n}\n\nexport interface CompiledClass extends AnalyzedClass { compilation: CompileResult[]; }\n\nexport interface CompiledFile {\n  compiledClasses: CompiledClass[];\n  sourceFile: ts.SourceFile;\n  constantPool: ConstantPool;\n}\n\nexport type DecorationAnalyses = Map<ts.SourceFile, CompiledFile>;\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 decorationAnalyses = new DecorationAnalyses();\n    const analysedFiles =\n        program.getSourceFiles().map(sourceFile => this.analyzeFile(sourceFile)).filter(isDefined);\n    const compiledFiles = analysedFiles.map(analysedFile => this.compileFile(analysedFile));\n    compiledFiles.forEach(\n        compiledFile => decorationAnalyses.set(compiledFile.sourceFile, compiledFile));\n    return decorationAnalyses;\n  }\n\n  protected analyzeFile(sourceFile: ts.SourceFile): AnalyzedFile|undefined {\n    const decoratedClasses = this.host.findDecoratedClasses(sourceFile);\n    return decoratedClasses.length ? {\n      sourceFile,\n      analyzedClasses: decoratedClasses.map(clazz => this.analyzeClass(clazz)).filter(isDefined)\n    } :\n                                     undefined;\n  }\n\n  protected analyzeClass(clazz: DecoratedClass): AnalyzedClass|null {\n    const matchingHandlers = this.handlers\n                                 .map(handler => {\n                                   const match =\n                                       handler.detect(clazz.declaration, clazz.decorators);\n                                   return {handler, match};\n                                 })\n                                 .filter(isMatchingHandler);\n\n    if (matchingHandlers.length > 1) {\n      throw new Error('TODO.Diagnostic: Class has multiple Angular decorators.');\n    }\n    if (matchingHandlers.length === 0) {\n      return null;\n    }\n    const {handler, match} = matchingHandlers[0];\n    const {analysis, diagnostics} = handler.analyze(clazz.declaration, match);\n    return {...clazz, handler, analysis, diagnostics};\n  }\n\n  protected compileFile(analyzedFile: AnalyzedFile): CompiledFile {\n    const constantPool = new ConstantPool();\n    const compiledClasses: CompiledClass[] = analyzedFile.analyzedClasses.map(analyzedClass => {\n      const compilation = this.compileClass(analyzedClass, constantPool);\n      return {...analyzedClass, compilation};\n    });\n    return {constantPool, sourceFile: analyzedFile.sourceFile, compiledClasses};\n  }\n\n  protected compileClass(clazz: AnalyzedClass, constantPool: ConstantPool): CompileResult[] {\n    let compilation = clazz.handler.compile(clazz.declaration, clazz.analysis, constantPool);\n    if (!Array.isArray(compilation)) {\n      compilation = [compilation];\n    }\n    return 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"]}
+//# 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 path from 'canonical-path';\nimport * as fs from 'fs';\nimport * as ts from 'typescript';\n\nimport {BaseDefDecoratorHandler, ComponentDecoratorHandler, DirectiveDecoratorHandler, InjectableDecoratorHandler, NgModuleDecoratorHandler, PipeDecoratorHandler, ReferencesRegistry, ResourceLoader, SelectorScopeRegistry} from '../../../ngtsc/annotations';\nimport {CompileResult, DecoratorHandler} from '../../../ngtsc/transform';\nimport {DecoratedClass} from '../host/decorated_class';\nimport {NgccReflectionHost} from '../host/ngcc_host';\nimport {isDefined} from '../utils';\n\nexport interface AnalyzedFile {\n  sourceFile: ts.SourceFile;\n  analyzedClasses: AnalyzedClass[];\n}\n\nexport interface AnalyzedClass extends DecoratedClass {\n  diagnostics?: ts.Diagnostic[];\n  handler: DecoratorHandler<any, any>;\n  analysis: any;\n}\n\nexport interface CompiledClass extends AnalyzedClass { compilation: CompileResult[]; }\n\nexport interface CompiledFile {\n  compiledClasses: CompiledClass[];\n  sourceFile: ts.SourceFile;\n  constantPool: ConstantPool;\n}\n\nexport type DecorationAnalyses = Map<ts.SourceFile, CompiledFile>;\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, containingFile: string): string {\n    url = path.resolve(path.dirname(containingFile), url);\n    return fs.readFileSync(url, 'utf8');\n  }\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, /* defaultPreserveWhitespaces */ false, /* i18nUseExternalIds */ true),\n    new DirectiveDecoratorHandler(this.typeChecker, this.host, this.scopeRegistry, this.isCore),\n    new InjectableDecoratorHandler(this.host, this.isCore),\n    new NgModuleDecoratorHandler(\n        this.typeChecker, this.host, this.scopeRegistry, this.referencesRegistry, 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 referencesRegistry: ReferencesRegistry, private rootDirs: string[],\n      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 decorationAnalyses = new DecorationAnalyses();\n    const analysedFiles =\n        program.getSourceFiles().map(sourceFile => this.analyzeFile(sourceFile)).filter(isDefined);\n    const compiledFiles = analysedFiles.map(analysedFile => this.compileFile(analysedFile));\n    compiledFiles.forEach(\n        compiledFile => decorationAnalyses.set(compiledFile.sourceFile, compiledFile));\n    return decorationAnalyses;\n  }\n\n  protected analyzeFile(sourceFile: ts.SourceFile): AnalyzedFile|undefined {\n    const decoratedClasses = this.host.findDecoratedClasses(sourceFile);\n    return decoratedClasses.length ? {\n      sourceFile,\n      analyzedClasses: decoratedClasses.map(clazz => this.analyzeClass(clazz)).filter(isDefined)\n    } :\n                                     undefined;\n  }\n\n  protected analyzeClass(clazz: DecoratedClass): AnalyzedClass|null {\n    const matchingHandlers = this.handlers\n                                 .map(handler => {\n                                   const match =\n                                       handler.detect(clazz.declaration, clazz.decorators);\n                                   return {handler, match};\n                                 })\n                                 .filter(isMatchingHandler);\n\n    if (matchingHandlers.length > 1) {\n      throw new Error('TODO.Diagnostic: Class has multiple Angular decorators.');\n    }\n    if (matchingHandlers.length === 0) {\n      return null;\n    }\n    const {handler, match} = matchingHandlers[0];\n    const {analysis, diagnostics} = handler.analyze(clazz.declaration, match);\n    return {...clazz, handler, analysis, diagnostics};\n  }\n\n  protected compileFile(analyzedFile: AnalyzedFile): CompiledFile {\n    const constantPool = new ConstantPool();\n    const compiledClasses: CompiledClass[] = analyzedFile.analyzedClasses.map(analyzedClass => {\n      const compilation = this.compileClass(analyzedClass, constantPool);\n      return {...analyzedClass, compilation};\n    });\n    return {constantPool, sourceFile: analyzedFile.sourceFile, compiledClasses};\n  }\n\n  protected compileClass(clazz: AnalyzedClass, constantPool: ConstantPool): CompileResult[] {\n    let compilation = clazz.handler.compile(clazz.declaration, clazz.analysis, constantPool);\n    if (!Array.isArray(compilation)) {\n      compilation = [compilation];\n    }\n    return 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/module_with_providers_analyzer.d.ts

@@ -0,0 +1,34 @@
+/// <amd-module name="@angular/compiler-cli/src/ngcc/src/analysis/module_with_providers_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 { ReferencesRegistry } from '../../../ngtsc/annotations';
+import { Declaration } from '../../../ngtsc/host';
+import { NgccReflectionHost } from '../host/ngcc_host';
+export interface ModuleWithProvidersInfo {
+    /**
+     * The declaration (in the .d.ts file) of the function that returns
+     * a `ModuleWithProviders object, but has a signature that needs
+     * a type parameter adding.
+     */
+    declaration: ts.MethodDeclaration | ts.FunctionDeclaration;
+    /**
+     * The NgModule class declaration (in the .d.ts file) to add as a type parameter.
+     */
+    ngModule: Declaration;
+}
+export declare type ModuleWithProvidersAnalyses = Map<ts.SourceFile, ModuleWithProvidersInfo[]>;
+export declare const ModuleWithProvidersAnalyses: MapConstructor;
+export declare class ModuleWithProvidersAnalyzer {
+    private host;
+    private referencesRegistry;
+    constructor(host: NgccReflectionHost, referencesRegistry: ReferencesRegistry);
+    analyzeProgram(program: ts.Program): ModuleWithProvidersAnalyses;
+    private getRootFiles;
+    private getDtsDeclaration;
+}

package/src/ngcc/src/analysis/module_with_providers_analyzer.js

@@ -0,0 +1,105 @@
+(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/module_with_providers_analyzer", ["require", "exports", "typescript", "@angular/compiler-cli/src/ngtsc/metadata", "@angular/compiler-cli/src/ngcc/src/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /**
+     * @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 ts = require("typescript");
+    var metadata_1 = require("@angular/compiler-cli/src/ngtsc/metadata");
+    var utils_1 = require("@angular/compiler-cli/src/ngcc/src/utils");
+    exports.ModuleWithProvidersAnalyses = Map;
+    var ModuleWithProvidersAnalyzer = /** @class */ (function () {
+        function ModuleWithProvidersAnalyzer(host, referencesRegistry) {
+            this.host = host;
+            this.referencesRegistry = referencesRegistry;
+        }
+        ModuleWithProvidersAnalyzer.prototype.analyzeProgram = function (program) {
+            var _this = this;
+            var analyses = new exports.ModuleWithProvidersAnalyses();
+            var rootFiles = this.getRootFiles(program);
+            rootFiles.forEach(function (f) {
+                var fns = _this.host.getModuleWithProvidersFunctions(f);
+                fns && fns.forEach(function (fn) {
+                    var dtsFn = _this.getDtsDeclaration(fn.declaration);
+                    var typeParam = dtsFn.type && ts.isTypeReferenceNode(dtsFn.type) &&
+                        dtsFn.type.typeArguments && dtsFn.type.typeArguments[0] ||
+                        null;
+                    if (!typeParam || isAnyKeyword(typeParam)) {
+                        // Either we do not have a parameterized type or the type is `any`.
+                        var ngModule = _this.host.getDeclarationOfIdentifier(fn.ngModule);
+                        if (!ngModule) {
+                            throw new Error("Cannot find a declaration for NgModule " + fn.ngModule.text + " referenced in " + fn.declaration.getText());
+                        }
+                        // For internal (non-library) module references, redirect the module's value declaration
+                        // to its type declaration.
+                        if (ngModule.viaModule === null) {
+                            var dtsNgModule = _this.host.getDtsDeclaration(ngModule.node);
+                            if (!dtsNgModule) {
+                                throw new Error("No typings declaration can be found for the referenced NgModule class in " + fn.declaration.getText() + ".");
+                            }
+                            if (!ts.isClassDeclaration(dtsNgModule)) {
+                                throw new Error("The referenced NgModule in " + fn.declaration.getText() + " is not a class declaration in the typings program; instead we get " + dtsNgModule.getText());
+                            }
+                            // Record the usage of the internal module as it needs to become an exported symbol
+                            _this.referencesRegistry.add(new metadata_1.ResolvedReference(ngModule.node, fn.ngModule));
+                            ngModule = { node: dtsNgModule, viaModule: null };
+                        }
+                        var dtsFile = dtsFn.getSourceFile();
+                        var analysis = analyses.get(dtsFile) || [];
+                        analysis.push({ declaration: dtsFn, ngModule: ngModule });
+                        analyses.set(dtsFile, analysis);
+                    }
+                });
+            });
+            return analyses;
+        };
+        ModuleWithProvidersAnalyzer.prototype.getRootFiles = function (program) {
+            return program.getRootFileNames().map(function (f) { return program.getSourceFile(f); }).filter(utils_1.isDefined);
+        };
+        ModuleWithProvidersAnalyzer.prototype.getDtsDeclaration = function (fn) {
+            var dtsFn = null;
+            var containerClass = this.host.getClassSymbol(fn.parent);
+            var fnName = fn.name && ts.isIdentifier(fn.name) && fn.name.text;
+            if (containerClass && fnName) {
+                var dtsClass = this.host.getDtsDeclaration(containerClass.valueDeclaration);
+                // Get the declaration of the matching static method
+                dtsFn = dtsClass && ts.isClassDeclaration(dtsClass) ?
+                    dtsClass.members
+                        .find(function (member) { return ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) &&
+                        member.name.text === fnName; }) :
+                    null;
+            }
+            else {
+                dtsFn = this.host.getDtsDeclaration(fn);
+            }
+            if (!dtsFn) {
+                throw new Error("Matching type declaration for " + fn.getText() + " is missing");
+            }
+            if (!isFunctionOrMethod(dtsFn)) {
+                throw new Error("Matching type declaration for " + fn.getText() + " is not a function: " + dtsFn.getText());
+            }
+            return dtsFn;
+        };
+        return ModuleWithProvidersAnalyzer;
+    }());
+    exports.ModuleWithProvidersAnalyzer = ModuleWithProvidersAnalyzer;
+    function isFunctionOrMethod(declaration) {
+        return ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration);
+    }
+    function isAnyKeyword(typeParam) {
+        return typeParam.kind === ts.SyntaxKind.AnyKeyword;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module_with_providers_analyzer.js","sourceRoot":"../../../../","sources":["packages/compiler-cli/src/ngcc/src/analysis/module_with_providers_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 * as ts from 'typescript';\n\nimport {ReferencesRegistry} from '../../../ngtsc/annotations';\nimport {Declaration} from '../../../ngtsc/host';\nimport {ResolvedReference} from '../../../ngtsc/metadata';\nimport {NgccReflectionHost} from '../host/ngcc_host';\nimport {isDefined} from '../utils';\n\nexport interface ModuleWithProvidersInfo {\n  /**\n   * The declaration (in the .d.ts file) of the function that returns\n   * a `ModuleWithProviders object, but has a signature that needs\n   * a type parameter adding.\n   */\n  declaration: ts.MethodDeclaration|ts.FunctionDeclaration;\n  /**\n   * The NgModule class declaration (in the .d.ts file) to add as a type parameter.\n   */\n  ngModule: Declaration;\n}\n\nexport type ModuleWithProvidersAnalyses = Map<ts.SourceFile, ModuleWithProvidersInfo[]>;\nexport const ModuleWithProvidersAnalyses = Map;\n\nexport class ModuleWithProvidersAnalyzer {\n  constructor(private host: NgccReflectionHost, private referencesRegistry: ReferencesRegistry) {}\n\n  analyzeProgram(program: ts.Program): ModuleWithProvidersAnalyses {\n    const analyses = new ModuleWithProvidersAnalyses();\n    const rootFiles = this.getRootFiles(program);\n    rootFiles.forEach(f => {\n      const fns = this.host.getModuleWithProvidersFunctions(f);\n      fns && fns.forEach(fn => {\n        const dtsFn = this.getDtsDeclaration(fn.declaration);\n        const typeParam = dtsFn.type && ts.isTypeReferenceNode(dtsFn.type) &&\n                dtsFn.type.typeArguments && dtsFn.type.typeArguments[0] ||\n            null;\n        if (!typeParam || isAnyKeyword(typeParam)) {\n          // Either we do not have a parameterized type or the type is `any`.\n          let ngModule = this.host.getDeclarationOfIdentifier(fn.ngModule);\n          if (!ngModule) {\n            throw new Error(\n                `Cannot find a declaration for NgModule ${fn.ngModule.text} referenced in ${fn.declaration.getText()}`);\n          }\n          // For internal (non-library) module references, redirect the module's value declaration\n          // to its type declaration.\n          if (ngModule.viaModule === null) {\n            const dtsNgModule = this.host.getDtsDeclaration(ngModule.node);\n            if (!dtsNgModule) {\n              throw new Error(\n                  `No typings declaration can be found for the referenced NgModule class in ${fn.declaration.getText()}.`);\n            }\n            if (!ts.isClassDeclaration(dtsNgModule)) {\n              throw new Error(\n                  `The referenced NgModule in ${fn.declaration.getText()} is not a class declaration in the typings program; instead we get ${dtsNgModule.getText()}`);\n            }\n            // Record the usage of the internal module as it needs to become an exported symbol\n            this.referencesRegistry.add(new ResolvedReference(ngModule.node, fn.ngModule));\n\n            ngModule = {node: dtsNgModule, viaModule: null};\n          }\n          const dtsFile = dtsFn.getSourceFile();\n          const analysis = analyses.get(dtsFile) || [];\n          analysis.push({declaration: dtsFn, ngModule});\n          analyses.set(dtsFile, analysis);\n        }\n      });\n    });\n    return analyses;\n  }\n\n  private getRootFiles(program: ts.Program): ts.SourceFile[] {\n    return program.getRootFileNames().map(f => program.getSourceFile(f)).filter(isDefined);\n  }\n\n  private getDtsDeclaration(fn: ts.SignatureDeclaration) {\n    let dtsFn: ts.Declaration|null = null;\n    const containerClass = this.host.getClassSymbol(fn.parent);\n    const fnName = fn.name && ts.isIdentifier(fn.name) && fn.name.text;\n    if (containerClass && fnName) {\n      const dtsClass = this.host.getDtsDeclaration(containerClass.valueDeclaration);\n      // Get the declaration of the matching static method\n      dtsFn = dtsClass && ts.isClassDeclaration(dtsClass) ?\n          dtsClass.members\n              .find(\n                  member => ts.isMethodDeclaration(member) && ts.isIdentifier(member.name) &&\n                      member.name.text === fnName) as ts.Declaration :\n          null;\n    } else {\n      dtsFn = this.host.getDtsDeclaration(fn);\n    }\n    if (!dtsFn) {\n      throw new Error(`Matching type declaration for ${fn.getText()} is missing`);\n    }\n    if (!isFunctionOrMethod(dtsFn)) {\n      throw new Error(\n          `Matching type declaration for ${fn.getText()} is not a function: ${dtsFn.getText()}`);\n    }\n    return dtsFn;\n  }\n}\n\n\nfunction isFunctionOrMethod(declaration: ts.Declaration): declaration is ts.FunctionDeclaration|\n    ts.MethodDeclaration {\n  return ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration);\n}\n\nfunction isAnyKeyword(typeParam: ts.TypeNode): typeParam is ts.KeywordTypeNode {\n  return typeParam.kind === ts.SyntaxKind.AnyKeyword;\n}\n"]}

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

@@ -0,0 +1,35 @@
+/**
+ * @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/analysis/ngcc_references_registry" />
+import * as ts from 'typescript';
+import { ReferencesRegistry } from '../../../ngtsc/annotations';
+import { Declaration, ReflectionHost } from '../../../ngtsc/host';
+import { Reference } from '../../../ngtsc/metadata';
+/**
+ * This is a place for DecoratorHandlers to register references that they
+ * find in their analysis of the code.
+ *
+ * This registry is used to ensure that these references are publicly exported
+ * from libraries that are compiled by ngcc.
+ */
+export declare class NgccReferencesRegistry implements ReferencesRegistry {
+    private host;
+    private map;
+    constructor(host: ReflectionHost);
+    /**
+     * Register one or more references in the registry.
+     * Only `ResolveReference` references are stored. Other types are ignored.
+     * @param references A collection of references to register.
+     */
+    add(...references: Reference<ts.Declaration>[]): void;
+    /**
+     * Create and return a mapping for the registered resolved references.
+     * @returns A map of reference identifiers to reference declarations.
+     */
+    getDeclarationMap(): Map<ts.Identifier, Declaration>;
+}

package/src/ngcc/src/analysis/ngcc_references_registry.js

@@ -0,0 +1,63 @@
+/**
+ * @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/analysis/ngcc_references_registry", ["require", "exports", "@angular/compiler-cli/src/ngtsc/metadata", "@angular/compiler-cli/src/ngcc/src/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var metadata_1 = require("@angular/compiler-cli/src/ngtsc/metadata");
+    var utils_1 = require("@angular/compiler-cli/src/ngcc/src/utils");
+    /**
+     * This is a place for DecoratorHandlers to register references that they
+     * find in their analysis of the code.
+     *
+     * This registry is used to ensure that these references are publicly exported
+     * from libraries that are compiled by ngcc.
+     */
+    var NgccReferencesRegistry = /** @class */ (function () {
+        function NgccReferencesRegistry(host) {
+            this.host = host;
+            this.map = new Map();
+        }
+        /**
+         * Register one or more references in the registry.
+         * Only `ResolveReference` references are stored. Other types are ignored.
+         * @param references A collection of references to register.
+         */
+        NgccReferencesRegistry.prototype.add = function () {
+            var _this = this;
+            var references = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                references[_i] = arguments[_i];
+            }
+            references.forEach(function (ref) {
+                // Only store resolved references. We are not interested in literals.
+                if (ref instanceof metadata_1.ResolvedReference && utils_1.hasNameIdentifier(ref.node)) {
+                    var declaration = _this.host.getDeclarationOfIdentifier(ref.node.name);
+                    if (declaration && utils_1.hasNameIdentifier(declaration.node)) {
+                        _this.map.set(declaration.node.name, declaration);
+                    }
+                }
+            });
+        };
+        /**
+         * Create and return a mapping for the registered resolved references.
+         * @returns A map of reference identifiers to reference declarations.
+         */
+        NgccReferencesRegistry.prototype.getDeclarationMap = function () { return this.map; };
+        return NgccReferencesRegistry;
+    }());
+    exports.NgccReferencesRegistry = NgccReferencesRegistry;
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,29 @@
+/// <amd-module name="@angular/compiler-cli/src/ngcc/src/analysis/private_declarations_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 { ReferencesRegistry } from '../../../ngtsc/annotations';
+import { NgccReflectionHost } from '../host/ngcc_host';
+export interface ExportInfo {
+    identifier: string;
+    from: string;
+    dtsFrom?: string | null;
+}
+export declare type PrivateDeclarationsAnalyses = ExportInfo[];
+/**
+ * This class will analyze a program to find all the declared classes
+ * (i.e. on an NgModule) that are not publicly exported via an entry-point.
+ */
+export declare class PrivateDeclarationsAnalyzer {
+    private host;
+    private referencesRegistry;
+    constructor(host: NgccReflectionHost, referencesRegistry: ReferencesRegistry);
+    analyzeProgram(program: ts.Program): PrivateDeclarationsAnalyses;
+    private getRootFiles;
+    private getPrivateDeclarations;
+}

package/src/ngcc/src/analysis/private_declarations_analyzer.js

@@ -0,0 +1,54 @@
+(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/private_declarations_analyzer", ["require", "exports", "@angular/compiler-cli/src/ngcc/src/utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var utils_1 = require("@angular/compiler-cli/src/ngcc/src/utils");
+    /**
+     * This class will analyze a program to find all the declared classes
+     * (i.e. on an NgModule) that are not publicly exported via an entry-point.
+     */
+    var PrivateDeclarationsAnalyzer = /** @class */ (function () {
+        function PrivateDeclarationsAnalyzer(host, referencesRegistry) {
+            this.host = host;
+            this.referencesRegistry = referencesRegistry;
+        }
+        PrivateDeclarationsAnalyzer.prototype.analyzeProgram = function (program) {
+            var rootFiles = this.getRootFiles(program);
+            return this.getPrivateDeclarations(rootFiles, this.referencesRegistry.getDeclarationMap());
+        };
+        PrivateDeclarationsAnalyzer.prototype.getRootFiles = function (program) {
+            return program.getRootFileNames().map(function (f) { return program.getSourceFile(f); }).filter(utils_1.isDefined);
+        };
+        PrivateDeclarationsAnalyzer.prototype.getPrivateDeclarations = function (rootFiles, declarations) {
+            var _this = this;
+            var privateDeclarations = new Map(declarations);
+            rootFiles.forEach(function (f) {
+                var exports = _this.host.getExportsOfModule(f);
+                if (exports) {
+                    exports.forEach(function (declaration, exportedName) {
+                        if (utils_1.hasNameIdentifier(declaration.node) && declaration.node.name.text === exportedName) {
+                            privateDeclarations.delete(declaration.node.name);
+                        }
+                    });
+                }
+            });
+            return Array.from(privateDeclarations.keys()).map(function (id) {
+                var from = id.getSourceFile().fileName;
+                var declaration = privateDeclarations.get(id);
+                var dtsDeclaration = _this.host.getDtsDeclaration(declaration.node);
+                var dtsFrom = dtsDeclaration && dtsDeclaration.getSourceFile().fileName;
+                return { identifier: id.text, from: from, dtsFrom: dtsFrom };
+            });
+        };
+        return PrivateDeclarationsAnalyzer;
+    }());
+    exports.PrivateDeclarationsAnalyzer = PrivateDeclarationsAnalyzer;
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -41,4 +41,4 @@
     }());
     exports.SwitchMarkerAnalyzer = SwitchMarkerAnalyzer;
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/src/ngcc/src/constants.js

@@ -18,4 +18,4 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.IMPORT_PREFIX = 'ɵngcc';
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL3NyYy9uZ2NjL3NyYy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7SUFFVSxRQUFBLGFBQWEsR0FBRyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCBjb25zdCBJTVBPUlRfUFJFRklYID0gJ8m1bmdjYyc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLyIsInNvdXJjZXMiOlsicGFja2FnZXMvY29tcGlsZXItY2xpL3NyYy9uZ2NjL3NyYy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOzs7Ozs7Ozs7Ozs7SUFFVSxRQUFBLGFBQWEsR0FBRyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCBjb25zdCBJTVBPUlRfUFJFRklYID0gJ8m1bmdjYyc7XG4iXX0=

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

@@ -37,4 +37,4 @@
     }());
     exports.DecoratedClass = DecoratedClass;
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdGVkX2NsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL3NyYy9uZ2NjL3NyYy9ob3N0L2RlY29yYXRlZF9jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQUtIOzs7T0FHRztJQUNIO1FBQ0U7Ozs7OztXQU1HO1FBQ0gsd0JBQ1csSUFBWSxFQUFTLFdBQTJCLEVBQVMsVUFBdUI7WUFBaEYsU0FBSSxHQUFKLElBQUksQ0FBUTtZQUFTLGdCQUFXLEdBQVgsV0FBVyxDQUFnQjtZQUFTLGVBQVUsR0FBVixVQUFVLENBQWE7UUFBSyxDQUFDO1FBQ25HLHFCQUFDO0lBQUQsQ0FBQyxBQVZELElBVUM7SUFWWSx3Q0FBYyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5pbXBvcnQge0RlY29yYXRvcn0gZnJvbSAnLi4vLi4vLi4vbmd0c2MvaG9zdCc7XG5cbi8qKlxuICogQSBzaW1wbGUgY29udGFpbmVyIHRoYXQgaG9sZHMgdGhlIGRldGFpbHMgb2YgYSBkZWNvcmF0ZWQgY2xhc3MgdGhhdCBoYXMgYmVlblxuICogZm91bmQgaW4gYSBgRGVjb3JhdGVkRmlsZWAuXG4gKi9cbmV4cG9ydCBjbGFzcyBEZWNvcmF0ZWRDbGFzcyB7XG4gIC8qKlxuICAgKiBJbml0aWFsaXplIGEgYERlY29yYXRlZENsYXNzYCB0aGF0IHdhcyBmb3VuZCBpbiBhIGBEZWNvcmF0ZWRGaWxlYC5cbiAgICogQHBhcmFtIG5hbWUgVGhlIG5hbWUgb2YgdGhlIGNsYXNzIHRoYXQgaGFzIGJlZW4gZm91bmQuIFRoaXMgaXMgbW9zdGx5IHVzZWRcbiAgICogZm9yIGluZm9ybWF0aW9uYWwgcHVycG9zZXMuXG4gICAqIEBwYXJhbSBkZWNsYXJhdGlvbiBUaGUgVHlwZVNjcmlwdCBBU1Qgbm9kZSB3aGVyZSB0aGlzIGNsYXNzIGlzIGRlY2xhcmVkXG4gICAqIEBwYXJhbSBkZWNvcmF0b3JzIFRoZSBjb2xsZWN0aW9uIG9mIGRlY29yYXRvcnMgdGhhdCBoYXZlIGJlZW4gZm91bmQgb24gdGhpcyBjbGFzcy5cbiAgICovXG4gIGNvbnN0cnVjdG9yKFxuICAgICAgcHVibGljIG5hbWU6IHN0cmluZywgcHVibGljIGRlY2xhcmF0aW9uOiB0cy5EZWNsYXJhdGlvbiwgcHVibGljIGRlY29yYXRvcnM6IERlY29yYXRvcltdLCApIHt9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdGVkX2NsYXNzLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLyIsInNvdXJjZXMiOlsicGFja2FnZXMvY29tcGlsZXItY2xpL3NyYy9uZ2NjL3NyYy9ob3N0L2RlY29yYXRlZF9jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7Ozs7Ozs7Ozs7OztJQUtIOzs7T0FHRztJQUNIO1FBQ0U7Ozs7OztXQU1HO1FBQ0gsd0JBQ1csSUFBWSxFQUFTLFdBQTJCLEVBQVMsVUFBdUI7WUFBaEYsU0FBSSxHQUFKLElBQUksQ0FBUTtZQUFTLGdCQUFXLEdBQVgsV0FBVyxDQUFnQjtZQUFTLGVBQVUsR0FBVixVQUFVLENBQWE7UUFBSyxDQUFDO1FBQ25HLHFCQUFDO0lBQUQsQ0FBQyxBQVZELElBVUM7SUFWWSx3Q0FBYyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0ICogYXMgdHMgZnJvbSAndHlwZXNjcmlwdCc7XG5pbXBvcnQge0RlY29yYXRvcn0gZnJvbSAnLi4vLi4vLi4vbmd0c2MvaG9zdCc7XG5cbi8qKlxuICogQSBzaW1wbGUgY29udGFpbmVyIHRoYXQgaG9sZHMgdGhlIGRldGFpbHMgb2YgYSBkZWNvcmF0ZWQgY2xhc3MgdGhhdCBoYXMgYmVlblxuICogZm91bmQgaW4gYSBgRGVjb3JhdGVkRmlsZWAuXG4gKi9cbmV4cG9ydCBjbGFzcyBEZWNvcmF0ZWRDbGFzcyB7XG4gIC8qKlxuICAgKiBJbml0aWFsaXplIGEgYERlY29yYXRlZENsYXNzYCB0aGF0IHdhcyBmb3VuZCBpbiBhIGBEZWNvcmF0ZWRGaWxlYC5cbiAgICogQHBhcmFtIG5hbWUgVGhlIG5hbWUgb2YgdGhlIGNsYXNzIHRoYXQgaGFzIGJlZW4gZm91bmQuIFRoaXMgaXMgbW9zdGx5IHVzZWRcbiAgICogZm9yIGluZm9ybWF0aW9uYWwgcHVycG9zZXMuXG4gICAqIEBwYXJhbSBkZWNsYXJhdGlvbiBUaGUgVHlwZVNjcmlwdCBBU1Qgbm9kZSB3aGVyZSB0aGlzIGNsYXNzIGlzIGRlY2xhcmVkXG4gICAqIEBwYXJhbSBkZWNvcmF0b3JzIFRoZSBjb2xsZWN0aW9uIG9mIGRlY29yYXRvcnMgdGhhdCBoYXZlIGJlZW4gZm91bmQgb24gdGhpcyBjbGFzcy5cbiAgICovXG4gIGNvbnN0cnVjdG9yKFxuICAgICAgcHVibGljIG5hbWU6IHN0cmluZywgcHVibGljIGRlY2xhcmF0aW9uOiB0cy5EZWNsYXJhdGlvbiwgcHVibGljIGRlY29yYXRvcnM6IERlY29yYXRvcltdLCApIHt9XG59XG4iXX0=

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

@@ -9,8 +9,9 @@
 import * as ts from 'typescript';
 import { ClassMember, CtorParameter, Decorator, Import } from '../../../ngtsc/host';
 import { TypeScriptReflectionHost } from '../../../ngtsc/metadata';
+import { BundleProgram } from '../packages/bundle_program';
 import { DecoratedClass } from './decorated_class';
-import { NgccReflectionHost, SwitchableVariableDeclaration } from './ngcc_host';
+import { ModuleWithProvidersFunction, NgccReflectionHost, SwitchableVariableDeclaration } from './ngcc_host';
 export declare const DECORATORS: ts.__String;
 export declare const PROP_DECORATORS: ts.__String;
 export declare const CONSTRUCTOR: ts.__String;
@@ -44,8 +45,8 @@ export declare const CONSTRUCTOR_PARAMS: ts.__String;
  */
 export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost implements NgccReflectionHost {
     protected isCore: boolean;
-    protected dtsClassMap: Map<string, ts.ClassDeclaration> | null;
-    constructor(isCore: boolean, checker: ts.TypeChecker, dtsRootFileName?: string, dtsProgram?: ts.Program | null);
+    protected dtsDeclarationMap: Map<string, ts.Declaration> | null;
+    constructor(isCore: boolean, checker: ts.TypeChecker, dts?: BundleProgram | null);
     /**
      * Examine a declaration (for example, of a class or function) and return metadata about any
      * decorators present on the declaration.
@@ -130,7 +131,7 @@ export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost impl
      */
     getGenericArityOfClass(clazz: ts.Declaration): number | null;
     /**
-     * Take an exported declaration of a class (maybe downleveled to a variable) and look up the
+     * Take an exported declaration of a class (maybe down-leveled to a variable) and look up the
      * declaration of its type in a separate .d.ts tree.
      *
      * This function is allowed to return `null` if the current compilation unit does not have a
@@ -141,7 +142,15 @@ export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost impl
      * Note that the `ts.ClassDeclaration` returned from this function may not be from the same
      * `ts.Program` as the input declaration.
      */
-    getDtsDeclarationOfClass(declaration: ts.Declaration): ts.ClassDeclaration | null;
+    getDtsDeclaration(declaration: ts.Declaration): ts.Declaration | null;
+    /**
+     * Search the given source file for exported functions and static class methods that return
+     * ModuleWithProviders objects.
+     * @param f The source file to search for these functions
+     * @returns An array of function declarations that look like they return ModuleWithProviders
+     * objects.
+     */
+    getModuleWithProvidersFunctions(f: ts.SourceFile): ModuleWithProvidersFunction[];
     protected getDecoratorsOfSymbol(symbol: ts.Symbol): Decorator[] | null;
     protected getDecoratedClassFromSymbol(symbol: ts.Symbol | undefined): DecoratedClass | null;
     /**
@@ -326,8 +335,8 @@ export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost impl
      */
     protected getParamInfoFromStaticProperty(paramDecoratorsProperty: ts.Symbol): ParamInfo[] | null;
     /**
-     * Get the parmeter type and decorators for a class where the information is stored on
-     * in calls to `__decorate` helpers.
+     * Get the parameter type and decorators for a class where the information is stored via
+     * calls to `__decorate` helpers.
      *
      * Reflect over the helpers to find the decorators and types about each of
      * the class's constructor parameters.
@@ -375,7 +384,7 @@ export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost impl
      * Test whether a decorator was imported from `@angular/core`.
      *
      * Is the decorator:
-     * * externally imported from `@angulare/core`?
+     * * externally imported from `@angular/core`?
      * * the current hosted program is actually `@angular/core` and
      *   - relatively internally imported; or
      *   - not imported, from the current file.
@@ -383,11 +392,34 @@ export declare class Esm2015ReflectionHost extends TypeScriptReflectionHost impl
      * @param decorator the decorator to test.
      */
     protected isFromCore(decorator: Decorator): boolean;
-    protected computeDtsClassMap(dtsRootFileName: string, dtsProgram: ts.Program): Map<string, ts.ClassDeclaration>;
+    /**
+     * Extract all the class declarations from the dtsTypings program, storing them in a map
+     * where the key is the declared name of the class and the value is the declaration itself.
+     *
+     * It is possible for there to be multiple class declarations with the same local name.
+     * Only the first declaration with a given name is added to the map; subsequent classes will be
+     * ignored.
+     *
+     * We are most interested in classes that are publicly exported from the entry point, so these are
+     * added to the map first, to ensure that they are not ignored.
+     *
+     * @param dtsRootFileName The filename of the entry-point to the `dtsTypings` program.
+     * @param dtsProgram The program containing all the typings files.
+     * @returns a map of class names to class declarations.
+     */
+    protected computeDtsDeclarationMap(dtsRootFileName: string, dtsProgram: ts.Program): Map<string, ts.Declaration>;
+    /**
+     * Parse the given node, to see if it is a function that returns a `ModuleWithProviders` object.
+     * @param node a node to check to see if it is a function that returns a `ModuleWithProviders`
+     * object.
+     * @returns info about the function if it does return a `ModuleWithProviders` object; `null`
+     * otherwise.
+     */
+    protected parseForModuleWithProviders(node: ts.Node | null): ModuleWithProvidersFunction | null;
 }
 export declare type ParamInfo = {
     decorators: Decorator[] | null;
-    type: ts.Expression | null;
+    typeExpression: ts.Expression | null;
 };
 /**
  * A statement node that represents an assignment.