@angular/compiler-cli 9.0.0-rc.6 → 9.0.0

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

@@ -8,9 +8,10 @@
 /// <amd-module name="@angular/compiler-cli/src/ngtsc/imports/src/alias" />
 import { Expression } from '@angular/compiler';
 import * as ts from 'typescript';
+import { UnifiedModulesHost } from '../../core/api';
 import { ClassDeclaration, ReflectionHost } from '../../reflection';
-import { FileToModuleHost, ReferenceEmitStrategy } from './emitter';
-import { ImportMode, Reference } from './references';
+import { ImportFlags, ReferenceEmitStrategy } from './emitter';
+import { Reference } from './references';
 /**
  * A host for the aliasing system, which allows for alternative exports/imports of directives/pipes.
  *
@@ -26,8 +27,8 @@ import { ImportMode, Reference } from './references';
  *
  * 1) It can be used to create "alias" re-exports from different files, which can be used when the
  *    user hasn't exported the directive(s) from the ES module containing the NgModule. These re-
- *    exports can also be helpful when using a `FileToModuleHost`, which overrides the import logic
- *    described above.
+ *    exports can also be helpful when using a `UnifiedModulesHost`, which overrides the import
+ *    logic described above.
  *
  * 2) It can be used to get an alternative import expression for a directive or pipe, instead of
  *    the import that the normal logic would apply. The alias used depends on the provenance of the
@@ -73,16 +74,16 @@ export interface AliasingHost {
 }
 /**
  * An `AliasingHost` which generates and consumes alias re-exports when module names for each file
- * are determined by a `FileToModuleHost`.
+ * are determined by a `UnifiedModulesHost`.
  *
- * When using a `FileToModuleHost`, aliasing prevents issues with transitive dependencies. See the
+ * When using a `UnifiedModulesHost`, aliasing prevents issues with transitive dependencies. See the
  * README.md for more details.
  */
-export declare class FileToModuleAliasingHost implements AliasingHost {
-    private fileToModuleHost;
-    constructor(fileToModuleHost: FileToModuleHost);
+export declare class UnifiedModulesAliasingHost implements AliasingHost {
+    private unifiedModulesHost;
+    constructor(unifiedModulesHost: UnifiedModulesHost);
     /**
-     * With a `FileToModuleHost`, aliases are chosen automatically without the need to look through
+     * With a `UnifiedModulesHost`, aliases are chosen automatically without the need to look through
      * the exports present in a .d.ts file, so we can avoid cluttering the .d.ts files.
      */
     readonly aliasExportsInDts = false;
@@ -135,5 +136,5 @@ export declare class PrivateExportAliasingHost implements AliasingHost {
  * directive or pipe, if it exists.
  */
 export declare class AliasStrategy implements ReferenceEmitStrategy {
-    emit(ref: Reference<ts.Node>, context: ts.SourceFile, importMode: ImportMode): Expression | null;
+    emit(ref: Reference<ts.Node>, context: ts.SourceFile, importMode: ImportFlags): Expression | null;
 }

package/src/ngtsc/imports/src/alias.js

@@ -11,33 +11,35 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/imports/src/alias", ["require", "exports", "@angular/compiler"], factory);
+        define("@angular/compiler-cli/src/ngtsc/imports/src/alias", ["require", "exports", "@angular/compiler", "@angular/compiler-cli/src/ngtsc/imports/src/emitter"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var compiler_1 = require("@angular/compiler");
+    var emitter_1 = require("@angular/compiler-cli/src/ngtsc/imports/src/emitter");
     // Escape anything that isn't alphanumeric, '/' or '_'.
     var CHARS_TO_ESCAPE = /[^a-zA-Z0-9/_]/g;
     /**
      * An `AliasingHost` which generates and consumes alias re-exports when module names for each file
-     * are determined by a `FileToModuleHost`.
+     * are determined by a `UnifiedModulesHost`.
      *
-     * When using a `FileToModuleHost`, aliasing prevents issues with transitive dependencies. See the
+     * When using a `UnifiedModulesHost`, aliasing prevents issues with transitive dependencies. See the
      * README.md for more details.
      */
-    var FileToModuleAliasingHost = /** @class */ (function () {
-        function FileToModuleAliasingHost(fileToModuleHost) {
-            this.fileToModuleHost = fileToModuleHost;
+    var UnifiedModulesAliasingHost = /** @class */ (function () {
+        function UnifiedModulesAliasingHost(unifiedModulesHost) {
+            this.unifiedModulesHost = unifiedModulesHost;
             /**
-             * With a `FileToModuleHost`, aliases are chosen automatically without the need to look through
+             * With a `UnifiedModulesHost`, aliases are chosen automatically without the need to look through
              * the exports present in a .d.ts file, so we can avoid cluttering the .d.ts files.
              */
             this.aliasExportsInDts = false;
         }
-        FileToModuleAliasingHost.prototype.maybeAliasSymbolAs = function (ref, context, ngModuleName, isReExport) {
+        UnifiedModulesAliasingHost.prototype.maybeAliasSymbolAs = function (ref, context, ngModuleName, isReExport) {
             if (!isReExport) {
-                // Aliasing is used with a FileToModuleHost to prevent transitive dependencies. Thus, aliases
+                // Aliasing is used with a UnifiedModulesHost to prevent transitive dependencies. Thus,
+                // aliases
                 // only need to be created for directives/pipes which are not direct declarations of an
                 // NgModule which exports them.
                 return null;
@@ -48,29 +50,29 @@
          * Generates an `Expression` to import `decl` from `via`, assuming an export was added when `via`
          * was compiled per `maybeAliasSymbolAs` above.
          */
-        FileToModuleAliasingHost.prototype.getAliasIn = function (decl, via, isReExport) {
+        UnifiedModulesAliasingHost.prototype.getAliasIn = function (decl, via, isReExport) {
             if (!isReExport) {
                 // Directly exported directives/pipes don't require an alias, per the logic in
                 // `maybeAliasSymbolAs`.
                 return null;
             }
             // viaModule is the module it'll actually be imported from.
-            var moduleName = this.fileToModuleHost.fileNameToModuleName(via.fileName, via.fileName);
+            var moduleName = this.unifiedModulesHost.fileNameToModuleName(via.fileName, via.fileName);
             return new compiler_1.ExternalExpr({ moduleName: moduleName, name: this.aliasName(decl, via) });
         };
         /**
          * Generates an alias name based on the full module name of the file which declares the aliased
          * directive/pipe.
          */
-        FileToModuleAliasingHost.prototype.aliasName = function (decl, context) {
+        UnifiedModulesAliasingHost.prototype.aliasName = function (decl, context) {
             // The declared module is used to get the name of the alias.
-            var declModule = this.fileToModuleHost.fileNameToModuleName(decl.getSourceFile().fileName, context.fileName);
+            var declModule = this.unifiedModulesHost.fileNameToModuleName(decl.getSourceFile().fileName, context.fileName);
             var replaced = declModule.replace(CHARS_TO_ESCAPE, '_').replace(/\//g, '$');
             return 'ɵng$' + replaced + '$$' + decl.name.text;
         };
-        return FileToModuleAliasingHost;
+        return UnifiedModulesAliasingHost;
     }());
-    exports.FileToModuleAliasingHost = FileToModuleAliasingHost;
+    exports.UnifiedModulesAliasingHost = UnifiedModulesAliasingHost;
     /**
      * An `AliasingHost` which exports directives from any file containing an NgModule in which they're
      * declared/exported, under a private symbol name.
@@ -141,10 +143,13 @@
         function AliasStrategy() {
         }
         AliasStrategy.prototype.emit = function (ref, context, importMode) {
+            if (importMode & emitter_1.ImportFlags.NoAliasing) {
+                return null;
+            }
             return ref.alias;
         };
         return AliasStrategy;
     }());
     exports.AliasStrategy = AliasStrategy;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alias.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/imports/src/alias.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 */\n\nimport {Expression, ExternalExpr} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {ClassDeclaration, ReflectionHost, isNamedClassDeclaration} from '../../reflection';\nimport {FileToModuleHost, ReferenceEmitStrategy} from './emitter';\nimport {ImportMode, Reference} from './references';\n\n// Escape anything that isn't alphanumeric, '/' or '_'.\nconst CHARS_TO_ESCAPE = /[^a-zA-Z0-9/_]/g;\n\n/**\n * A host for the aliasing system, which allows for alternative exports/imports of directives/pipes.\n *\n * Given an import of an NgModule (e.g. `CommonModule`), the compiler must generate imports to the\n * directives and pipes exported by this module (e.g. `NgIf`) when they're used in a particular\n * template. In its default configuration, if the compiler is not directly able to import the\n * component from another file within the same project, it will attempt to import the component\n * from the same (absolute) path by which the module was imported. So in the above example if\n * `CommonModule` was imported from '@angular/common', the compiler will attempt to import `NgIf`\n * from '@angular/common' as well.\n *\n * The aliasing system interacts with the above logic in two distinct ways.\n *\n * 1) It can be used to create \"alias\" re-exports from different files, which can be used when the\n *    user hasn't exported the directive(s) from the ES module containing the NgModule. These re-\n *    exports can also be helpful when using a `FileToModuleHost`, which overrides the import logic\n *    described above.\n *\n * 2) It can be used to get an alternative import expression for a directive or pipe, instead of\n *    the import that the normal logic would apply. The alias used depends on the provenance of the\n *    `Reference` which was obtained for the directive/pipe, which is usually a property of how it\n *    came to be in a template's scope (e.g. by which NgModule).\n *\n * See the README.md for more information on how aliasing works within the compiler.\n */\nexport interface AliasingHost {\n  /**\n   * Controls whether any alias re-exports are rendered into .d.ts files.\n   *\n   * This is not always necessary for aliasing to function correctly, so this flag allows an\n   * `AliasingHost` to avoid cluttering the .d.ts files if exports are not strictly needed.\n   */\n  readonly aliasExportsInDts: boolean;\n\n  /**\n   * Determine a name by which `decl` should be re-exported from `context`, depending on the\n   * particular set of aliasing rules in place.\n   *\n   * `maybeAliasSymbolAs` can return `null`, in which case no alias export should be generated.\n   *\n   * @param ref a `Reference` to the directive/pipe to consider for aliasing.\n   * @param context the `ts.SourceFile` in which the alias re-export might need to be generated.\n   * @param ngModuleName the declared name of the `NgModule` within `context` for which the alias\n   * would be generated.\n   * @param isReExport whether the directive/pipe under consideration is re-exported from another\n   * NgModule (as opposed to being declared by it directly).\n   */\n  maybeAliasSymbolAs(\n      ref: Reference<ClassDeclaration>, context: ts.SourceFile, ngModuleName: string,\n      isReExport: boolean): string|null;\n\n  /**\n   * Determine an `Expression` by which `decl` should be imported from `via` using an alias export\n   * (which should have been previously created when compiling `via`).\n   *\n   * `getAliasIn` can return `null`, in which case no alias is needed to import `decl` from `via`\n   * (and the normal import rules should be used).\n   *\n   * @param decl the declaration of the directive/pipe which is being imported, and which might be\n   * aliased.\n   * @param via the `ts.SourceFile` which might contain an alias to the\n   */\n  getAliasIn(decl: ClassDeclaration, via: ts.SourceFile, isReExport: boolean): Expression|null;\n}\n\n/**\n * An `AliasingHost` which generates and consumes alias re-exports when module names for each file\n * are determined by a `FileToModuleHost`.\n *\n * When using a `FileToModuleHost`, aliasing prevents issues with transitive dependencies. See the\n * README.md for more details.\n */\nexport class FileToModuleAliasingHost implements AliasingHost {\n  constructor(private fileToModuleHost: FileToModuleHost) {}\n\n  /**\n   * With a `FileToModuleHost`, aliases are chosen automatically without the need to look through\n   * the exports present in a .d.ts file, so we can avoid cluttering the .d.ts files.\n   */\n  readonly aliasExportsInDts = false;\n\n  maybeAliasSymbolAs(\n      ref: Reference<ClassDeclaration>, context: ts.SourceFile, ngModuleName: string,\n      isReExport: boolean): string|null {\n    if (!isReExport) {\n      // Aliasing is used with a FileToModuleHost to prevent transitive dependencies. Thus, aliases\n      // only need to be created for directives/pipes which are not direct declarations of an\n      // NgModule which exports them.\n      return null;\n    }\n    return this.aliasName(ref.node, context);\n  }\n\n  /**\n   * Generates an `Expression` to import `decl` from `via`, assuming an export was added when `via`\n   * was compiled per `maybeAliasSymbolAs` above.\n   */\n  getAliasIn(decl: ClassDeclaration, via: ts.SourceFile, isReExport: boolean): Expression|null {\n    if (!isReExport) {\n      // Directly exported directives/pipes don't require an alias, per the logic in\n      // `maybeAliasSymbolAs`.\n      return null;\n    }\n    // viaModule is the module it'll actually be imported from.\n    const moduleName = this.fileToModuleHost.fileNameToModuleName(via.fileName, via.fileName);\n    return new ExternalExpr({moduleName, name: this.aliasName(decl, via)});\n  }\n\n  /**\n   * Generates an alias name based on the full module name of the file which declares the aliased\n   * directive/pipe.\n   */\n  private aliasName(decl: ClassDeclaration, context: ts.SourceFile): string {\n    // The declared module is used to get the name of the alias.\n    const declModule =\n        this.fileToModuleHost.fileNameToModuleName(decl.getSourceFile().fileName, context.fileName);\n\n    const replaced = declModule.replace(CHARS_TO_ESCAPE, '_').replace(/\\//g, '$');\n    return 'ɵng$' + replaced + '$$' + decl.name.text;\n  }\n}\n\n/**\n * An `AliasingHost` which exports directives from any file containing an NgModule in which they're\n * declared/exported, under a private symbol name.\n *\n * These exports support cases where an NgModule is imported deeply from an absolute module path\n * (that is, it's not part of an Angular Package Format entrypoint), and the compiler needs to\n * import any matched directives/pipes from the same path (to the NgModule file). See README.md for\n * more details.\n */\nexport class PrivateExportAliasingHost implements AliasingHost {\n  constructor(private host: ReflectionHost) {}\n\n  /**\n   * Under private export aliasing, the `AbsoluteModuleStrategy` used for emitting references will\n   * will select aliased exports that it finds in the .d.ts file for an NgModule's file. Thus,\n   * emitting these exports in .d.ts is a requirement for the `PrivateExportAliasingHost` to\n   * function correctly.\n   */\n  readonly aliasExportsInDts = true;\n\n  maybeAliasSymbolAs(\n      ref: Reference<ClassDeclaration>, context: ts.SourceFile, ngModuleName: string): string|null {\n    if (ref.hasOwningModuleGuess) {\n      // Skip nodes that already have an associated absolute module specifier, since they can be\n      // safely imported from that specifier.\n      return null;\n    }\n    // Look for a user-provided export of `decl` in `context`. If one exists, then an alias export\n    // is not needed.\n    // TODO(alxhub): maybe add a host method to check for the existence of an export without going\n    // through the entire list of exports.\n    const exports = this.host.getExportsOfModule(context);\n    if (exports === null) {\n      // Something went wrong, and no exports were available at all. Bail rather than risk creating\n      // re-exports when they're not needed.\n      throw new Error(`Could not determine the exports of: ${context.fileName}`);\n    }\n    let found: boolean = false;\n    exports.forEach(value => {\n      if (value.node === ref.node) {\n        found = true;\n      }\n    });\n    if (found) {\n      // The module exports the declared class directly, no alias is necessary.\n      return null;\n    }\n    return `ɵngExportɵ${ngModuleName}ɵ${ref.node.name.text}`;\n  }\n\n  /**\n   * A `PrivateExportAliasingHost` only generates re-exports and does not direct the compiler to\n   * directly consume the aliases it creates.\n   *\n   * Instead, they're consumed indirectly: `AbsoluteModuleStrategy` `ReferenceEmitterStrategy` will\n   * select these alias exports automatically when looking for an export of the directive/pipe from\n   * the same path as the NgModule was imported.\n   *\n   * Thus, `getAliasIn` always returns `null`.\n   */\n  getAliasIn(): null { return null; }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will consume the alias attached to a particular `Reference` to a\n * directive or pipe, if it exists.\n */\nexport class AliasStrategy implements ReferenceEmitStrategy {\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile, importMode: ImportMode): Expression|null {\n    return ref.alias;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alias.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/imports/src/alias.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 */\n\nimport {Expression, ExternalExpr} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {UnifiedModulesHost} from '../../core/api';\nimport {ClassDeclaration, ReflectionHost, isNamedClassDeclaration} from '../../reflection';\n\nimport {ImportFlags, ReferenceEmitStrategy} from './emitter';\nimport {Reference} from './references';\n\n\n\n// Escape anything that isn't alphanumeric, '/' or '_'.\nconst CHARS_TO_ESCAPE = /[^a-zA-Z0-9/_]/g;\n\n/**\n * A host for the aliasing system, which allows for alternative exports/imports of directives/pipes.\n *\n * Given an import of an NgModule (e.g. `CommonModule`), the compiler must generate imports to the\n * directives and pipes exported by this module (e.g. `NgIf`) when they're used in a particular\n * template. In its default configuration, if the compiler is not directly able to import the\n * component from another file within the same project, it will attempt to import the component\n * from the same (absolute) path by which the module was imported. So in the above example if\n * `CommonModule` was imported from '@angular/common', the compiler will attempt to import `NgIf`\n * from '@angular/common' as well.\n *\n * The aliasing system interacts with the above logic in two distinct ways.\n *\n * 1) It can be used to create \"alias\" re-exports from different files, which can be used when the\n *    user hasn't exported the directive(s) from the ES module containing the NgModule. These re-\n *    exports can also be helpful when using a `UnifiedModulesHost`, which overrides the import\n *    logic described above.\n *\n * 2) It can be used to get an alternative import expression for a directive or pipe, instead of\n *    the import that the normal logic would apply. The alias used depends on the provenance of the\n *    `Reference` which was obtained for the directive/pipe, which is usually a property of how it\n *    came to be in a template's scope (e.g. by which NgModule).\n *\n * See the README.md for more information on how aliasing works within the compiler.\n */\nexport interface AliasingHost {\n  /**\n   * Controls whether any alias re-exports are rendered into .d.ts files.\n   *\n   * This is not always necessary for aliasing to function correctly, so this flag allows an\n   * `AliasingHost` to avoid cluttering the .d.ts files if exports are not strictly needed.\n   */\n  readonly aliasExportsInDts: boolean;\n\n  /**\n   * Determine a name by which `decl` should be re-exported from `context`, depending on the\n   * particular set of aliasing rules in place.\n   *\n   * `maybeAliasSymbolAs` can return `null`, in which case no alias export should be generated.\n   *\n   * @param ref a `Reference` to the directive/pipe to consider for aliasing.\n   * @param context the `ts.SourceFile` in which the alias re-export might need to be generated.\n   * @param ngModuleName the declared name of the `NgModule` within `context` for which the alias\n   * would be generated.\n   * @param isReExport whether the directive/pipe under consideration is re-exported from another\n   * NgModule (as opposed to being declared by it directly).\n   */\n  maybeAliasSymbolAs(\n      ref: Reference<ClassDeclaration>, context: ts.SourceFile, ngModuleName: string,\n      isReExport: boolean): string|null;\n\n  /**\n   * Determine an `Expression` by which `decl` should be imported from `via` using an alias export\n   * (which should have been previously created when compiling `via`).\n   *\n   * `getAliasIn` can return `null`, in which case no alias is needed to import `decl` from `via`\n   * (and the normal import rules should be used).\n   *\n   * @param decl the declaration of the directive/pipe which is being imported, and which might be\n   * aliased.\n   * @param via the `ts.SourceFile` which might contain an alias to the\n   */\n  getAliasIn(decl: ClassDeclaration, via: ts.SourceFile, isReExport: boolean): Expression|null;\n}\n\n/**\n * An `AliasingHost` which generates and consumes alias re-exports when module names for each file\n * are determined by a `UnifiedModulesHost`.\n *\n * When using a `UnifiedModulesHost`, aliasing prevents issues with transitive dependencies. See the\n * README.md for more details.\n */\nexport class UnifiedModulesAliasingHost implements AliasingHost {\n  constructor(private unifiedModulesHost: UnifiedModulesHost) {}\n\n  /**\n   * With a `UnifiedModulesHost`, aliases are chosen automatically without the need to look through\n   * the exports present in a .d.ts file, so we can avoid cluttering the .d.ts files.\n   */\n  readonly aliasExportsInDts = false;\n\n  maybeAliasSymbolAs(\n      ref: Reference<ClassDeclaration>, context: ts.SourceFile, ngModuleName: string,\n      isReExport: boolean): string|null {\n    if (!isReExport) {\n      // Aliasing is used with a UnifiedModulesHost to prevent transitive dependencies. Thus,\n      // aliases\n      // only need to be created for directives/pipes which are not direct declarations of an\n      // NgModule which exports them.\n      return null;\n    }\n    return this.aliasName(ref.node, context);\n  }\n\n  /**\n   * Generates an `Expression` to import `decl` from `via`, assuming an export was added when `via`\n   * was compiled per `maybeAliasSymbolAs` above.\n   */\n  getAliasIn(decl: ClassDeclaration, via: ts.SourceFile, isReExport: boolean): Expression|null {\n    if (!isReExport) {\n      // Directly exported directives/pipes don't require an alias, per the logic in\n      // `maybeAliasSymbolAs`.\n      return null;\n    }\n    // viaModule is the module it'll actually be imported from.\n    const moduleName = this.unifiedModulesHost.fileNameToModuleName(via.fileName, via.fileName);\n    return new ExternalExpr({moduleName, name: this.aliasName(decl, via)});\n  }\n\n  /**\n   * Generates an alias name based on the full module name of the file which declares the aliased\n   * directive/pipe.\n   */\n  private aliasName(decl: ClassDeclaration, context: ts.SourceFile): string {\n    // The declared module is used to get the name of the alias.\n    const declModule = this.unifiedModulesHost.fileNameToModuleName(\n        decl.getSourceFile().fileName, context.fileName);\n\n    const replaced = declModule.replace(CHARS_TO_ESCAPE, '_').replace(/\\//g, '$');\n    return 'ɵng$' + replaced + '$$' + decl.name.text;\n  }\n}\n\n/**\n * An `AliasingHost` which exports directives from any file containing an NgModule in which they're\n * declared/exported, under a private symbol name.\n *\n * These exports support cases where an NgModule is imported deeply from an absolute module path\n * (that is, it's not part of an Angular Package Format entrypoint), and the compiler needs to\n * import any matched directives/pipes from the same path (to the NgModule file). See README.md for\n * more details.\n */\nexport class PrivateExportAliasingHost implements AliasingHost {\n  constructor(private host: ReflectionHost) {}\n\n  /**\n   * Under private export aliasing, the `AbsoluteModuleStrategy` used for emitting references will\n   * will select aliased exports that it finds in the .d.ts file for an NgModule's file. Thus,\n   * emitting these exports in .d.ts is a requirement for the `PrivateExportAliasingHost` to\n   * function correctly.\n   */\n  readonly aliasExportsInDts = true;\n\n  maybeAliasSymbolAs(\n      ref: Reference<ClassDeclaration>, context: ts.SourceFile, ngModuleName: string): string|null {\n    if (ref.hasOwningModuleGuess) {\n      // Skip nodes that already have an associated absolute module specifier, since they can be\n      // safely imported from that specifier.\n      return null;\n    }\n    // Look for a user-provided export of `decl` in `context`. If one exists, then an alias export\n    // is not needed.\n    // TODO(alxhub): maybe add a host method to check for the existence of an export without going\n    // through the entire list of exports.\n    const exports = this.host.getExportsOfModule(context);\n    if (exports === null) {\n      // Something went wrong, and no exports were available at all. Bail rather than risk creating\n      // re-exports when they're not needed.\n      throw new Error(`Could not determine the exports of: ${context.fileName}`);\n    }\n    let found: boolean = false;\n    exports.forEach(value => {\n      if (value.node === ref.node) {\n        found = true;\n      }\n    });\n    if (found) {\n      // The module exports the declared class directly, no alias is necessary.\n      return null;\n    }\n    return `ɵngExportɵ${ngModuleName}ɵ${ref.node.name.text}`;\n  }\n\n  /**\n   * A `PrivateExportAliasingHost` only generates re-exports and does not direct the compiler to\n   * directly consume the aliases it creates.\n   *\n   * Instead, they're consumed indirectly: `AbsoluteModuleStrategy` `ReferenceEmitterStrategy` will\n   * select these alias exports automatically when looking for an export of the directive/pipe from\n   * the same path as the NgModule was imported.\n   *\n   * Thus, `getAliasIn` always returns `null`.\n   */\n  getAliasIn(): null { return null; }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will consume the alias attached to a particular `Reference` to a\n * directive or pipe, if it exists.\n */\nexport class AliasStrategy implements ReferenceEmitStrategy {\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile, importMode: ImportFlags): Expression|null {\n    if (importMode & ImportFlags.NoAliasing) {\n      return null;\n    }\n\n    return ref.alias;\n  }\n}\n"]}

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

@@ -8,17 +8,38 @@
  */
 import { Expression } from '@angular/compiler';
 import * as ts from 'typescript';
+import { UnifiedModulesHost } from '../../core/api';
 import { LogicalFileSystem } from '../../file_system';
 import { ReflectionHost } from '../../reflection';
-import { ImportMode, Reference } from './references';
+import { Reference } from './references';
+import { ModuleResolver } from './resolver';
 /**
- * A host which supports an operation to convert a file name into a module name.
- *
- * This operation is typically implemented as part of the compiler host passed to ngtsc when running
- * under a build tool like Bazel or Blaze.
+ * Flags which alter the imports generated by the `ReferenceEmitter`.
  */
-export interface FileToModuleHost {
-    fileNameToModuleName(importedFilePath: string, containingFilePath: string): string;
+export declare enum ImportFlags {
+    None = 0,
+    /**
+     * Force the generation of a new import when generating a reference, even if an identifier already
+     * exists in the target file which could be used instead.
+     *
+     * This is sometimes required if there's a risk TypeScript might remove imports during emit.
+     */
+    ForceNewImport = 1,
+    /**
+     * Don't make use of any aliasing information when emitting a reference.
+     *
+     * This is sometimes required if emitting into a context where generated references will be fed
+     * into TypeScript and type-checked (such as in template type-checking).
+     */
+    NoAliasing = 2,
+    /**
+     * Indicates that an import to a type-only declaration is allowed.
+     *
+     * For references that occur in type-positions, the referred declaration may be a type-only
+     * declaration that is not retained during emit. Including this flag allows to emit references to
+     * type-only declarations as used in e.g. template type-checking.
+     */
+    AllowTypeImports = 4
 }
 /**
  * A particular strategy for generating an expression which refers to a `Reference`.
@@ -39,10 +60,10 @@ export interface ReferenceEmitStrategy {
      *
      * @param ref the `Reference` for which to generate an expression
      * @param context the source file in which the `Expression` must be valid
-     * @param importMode a flag which controls whether imports should be generated or not
+     * @param importFlags a flag which controls whether imports should be generated or not
      * @returns an `Expression` which refers to the `Reference`, or `null` if none can be generated
      */
-    emit(ref: Reference, context: ts.SourceFile, importMode: ImportMode): Expression | null;
+    emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): Expression | null;
 }
 /**
  * Generates `Expression`s which refer to `Reference`s in a given context.
@@ -53,14 +74,14 @@ export interface ReferenceEmitStrategy {
 export declare class ReferenceEmitter {
     private strategies;
     constructor(strategies: ReferenceEmitStrategy[]);
-    emit(ref: Reference, context: ts.SourceFile, importMode?: ImportMode): Expression;
+    emit(ref: Reference, context: ts.SourceFile, importFlags?: ImportFlags): Expression;
 }
 /**
  * A `ReferenceEmitStrategy` which will refer to declarations by any local `ts.Identifier`s, if
  * such identifiers are available.
  */
 export declare class LocalIdentifierStrategy implements ReferenceEmitStrategy {
-    emit(ref: Reference<ts.Node>, context: ts.SourceFile, importMode: ImportMode): Expression | null;
+    emit(ref: Reference<ts.Node>, context: ts.SourceFile, importFlags: ImportFlags): Expression | null;
 }
 /**
  * A `ReferenceEmitStrategy` which will refer to declarations that come from `node_modules` using
@@ -74,16 +95,15 @@ export declare class LocalIdentifierStrategy implements ReferenceEmitStrategy {
 export declare class AbsoluteModuleStrategy implements ReferenceEmitStrategy {
     protected program: ts.Program;
     protected checker: ts.TypeChecker;
-    protected options: ts.CompilerOptions;
-    protected host: ts.CompilerHost;
+    protected moduleResolver: ModuleResolver;
     private reflectionHost;
     /**
      * A cache of the exports of specific modules, because resolving a module to its exports is a
      * costly operation.
      */
     private moduleExportsCache;
-    constructor(program: ts.Program, checker: ts.TypeChecker, options: ts.CompilerOptions, host: ts.CompilerHost, reflectionHost: ReflectionHost);
-    emit(ref: Reference<ts.Node>, context: ts.SourceFile, importMode: ImportMode): Expression | null;
+    constructor(program: ts.Program, checker: ts.TypeChecker, moduleResolver: ModuleResolver, reflectionHost: ReflectionHost);
+    emit(ref: Reference<ts.Node>, context: ts.SourceFile, importFlags: ImportFlags): Expression | null;
     private resolveImportName;
     private getExportsOfModule;
     protected enumerateExportsOfModule(specifier: string, fromFile: string): Map<ts.Declaration, string> | null;
@@ -114,11 +134,12 @@ export declare class RelativePathStrategy implements ReferenceEmitStrategy {
     emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression | null;
 }
 /**
- * A `ReferenceEmitStrategy` which uses a `FileToModuleHost` to generate absolute import references.
+ * A `ReferenceEmitStrategy` which uses a `UnifiedModulesHost` to generate absolute import
+ * references.
  */
-export declare class FileToModuleStrategy implements ReferenceEmitStrategy {
+export declare class UnifiedModulesStrategy implements ReferenceEmitStrategy {
     private reflector;
-    private fileToModuleHost;
-    constructor(reflector: ReflectionHost, fileToModuleHost: FileToModuleHost);
+    private unifiedModulesHost;
+    constructor(reflector: ReflectionHost, unifiedModulesHost: UnifiedModulesHost);
     emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression | null;
 }

package/src/ngtsc/imports/src/emitter.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define("@angular/compiler-cli/src/ngtsc/imports/src/emitter", ["require", "exports", "tslib", "@angular/compiler", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/ngtsc/file_system/src/util", "@angular/compiler-cli/src/ngtsc/util/src/typescript", "@angular/compiler-cli/src/ngtsc/imports/src/find_export", "@angular/compiler-cli/src/ngtsc/imports/src/references"], factory);
+        define("@angular/compiler-cli/src/ngtsc/imports/src/emitter", ["require", "exports", "tslib", "@angular/compiler", "typescript", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/ngtsc/file_system/src/util", "@angular/compiler-cli/src/ngtsc/util/src/typescript", "@angular/compiler-cli/src/ngtsc/imports/src/find_export"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -18,11 +18,40 @@
      * found in the LICENSE file at https://angular.io/license
      */
     var compiler_1 = require("@angular/compiler");
+    var ts = require("typescript");
     var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
     var util_1 = require("@angular/compiler-cli/src/ngtsc/file_system/src/util");
     var typescript_1 = require("@angular/compiler-cli/src/ngtsc/util/src/typescript");
     var find_export_1 = require("@angular/compiler-cli/src/ngtsc/imports/src/find_export");
-    var references_1 = require("@angular/compiler-cli/src/ngtsc/imports/src/references");
+    /**
+     * Flags which alter the imports generated by the `ReferenceEmitter`.
+     */
+    var ImportFlags;
+    (function (ImportFlags) {
+        ImportFlags[ImportFlags["None"] = 0] = "None";
+        /**
+         * Force the generation of a new import when generating a reference, even if an identifier already
+         * exists in the target file which could be used instead.
+         *
+         * This is sometimes required if there's a risk TypeScript might remove imports during emit.
+         */
+        ImportFlags[ImportFlags["ForceNewImport"] = 1] = "ForceNewImport";
+        /**
+         * Don't make use of any aliasing information when emitting a reference.
+         *
+         * This is sometimes required if emitting into a context where generated references will be fed
+         * into TypeScript and type-checked (such as in template type-checking).
+         */
+        ImportFlags[ImportFlags["NoAliasing"] = 2] = "NoAliasing";
+        /**
+         * Indicates that an import to a type-only declaration is allowed.
+         *
+         * For references that occur in type-positions, the referred declaration may be a type-only
+         * declaration that is not retained during emit. Including this flag allows to emit references to
+         * type-only declarations as used in e.g. template type-checking.
+         */
+        ImportFlags[ImportFlags["AllowTypeImports"] = 4] = "AllowTypeImports";
+    })(ImportFlags = exports.ImportFlags || (exports.ImportFlags = {}));
     /**
      * Generates `Expression`s which refer to `Reference`s in a given context.
      *
@@ -33,13 +62,13 @@
         function ReferenceEmitter(strategies) {
             this.strategies = strategies;
         }
-        ReferenceEmitter.prototype.emit = function (ref, context, importMode) {
+        ReferenceEmitter.prototype.emit = function (ref, context, importFlags) {
             var e_1, _a;
-            if (importMode === void 0) { importMode = references_1.ImportMode.UseExistingImport; }
+            if (importFlags === void 0) { importFlags = ImportFlags.None; }
             try {
                 for (var _b = tslib_1.__values(this.strategies), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var strategy = _c.value;
-                    var emitted = strategy.emit(ref, context, importMode);
+                    var emitted = strategy.emit(ref, context, importFlags);
                     if (emitted !== null) {
                         return emitted;
                     }
@@ -64,10 +93,10 @@
     var LocalIdentifierStrategy = /** @class */ (function () {
         function LocalIdentifierStrategy() {
         }
-        LocalIdentifierStrategy.prototype.emit = function (ref, context, importMode) {
+        LocalIdentifierStrategy.prototype.emit = function (ref, context, importFlags) {
             // If the emitter has specified ForceNewImport, then LocalIdentifierStrategy should not use a
             // local identifier at all, *except* in the source file where the node is actually declared.
-            if (importMode === references_1.ImportMode.ForceNewImport &&
+            if (importFlags & ImportFlags.ForceNewImport &&
                 typescript_1.getSourceFile(ref.node) !== typescript_1.getSourceFile(context)) {
                 return null;
             }
@@ -94,11 +123,10 @@
      * which maps back to the original directive, an error is thrown.
      */
     var AbsoluteModuleStrategy = /** @class */ (function () {
-        function AbsoluteModuleStrategy(program, checker, options, host, reflectionHost) {
+        function AbsoluteModuleStrategy(program, checker, moduleResolver, reflectionHost) {
             this.program = program;
             this.checker = checker;
-            this.options = options;
-            this.host = host;
+            this.moduleResolver = moduleResolver;
             this.reflectionHost = reflectionHost;
             /**
              * A cache of the exports of specific modules, because resolving a module to its exports is a
@@ -106,7 +134,7 @@
              */
             this.moduleExportsCache = new Map();
         }
-        AbsoluteModuleStrategy.prototype.emit = function (ref, context, importMode) {
+        AbsoluteModuleStrategy.prototype.emit = function (ref, context, importFlags) {
             if (ref.bestGuessOwningModule === null) {
                 // There is no module name available for this Reference, meaning it was arrived at via a
                 // relative path.
@@ -114,7 +142,10 @@
             }
             else if (!typescript_1.isDeclaration(ref.node)) {
                 // It's not possible to import something which isn't a declaration.
-                throw new Error('Debug assert: importing a Reference to non-declaration?');
+                throw new Error("Debug assert: unable to import a Reference to non-declaration of type " + ts.SyntaxKind[ref.node.kind] + ".");
+            }
+            else if ((importFlags & ImportFlags.AllowTypeImports) === 0 && typescript_1.isTypeDeclaration(ref.node)) {
+                throw new Error("Importing a type-only declaration of type " + ts.SyntaxKind[ref.node.kind] + " in a value position is not allowed.");
             }
             // Try to find the exported name of the declaration, if one is available.
             var _a = ref.bestGuessOwningModule, specifier = _a.specifier, resolutionContext = _a.resolutionContext;
@@ -143,11 +174,7 @@
         };
         AbsoluteModuleStrategy.prototype.enumerateExportsOfModule = function (specifier, fromFile) {
             // First, resolve the module specifier to its entry point, and get the ts.Symbol for it.
-            var resolvedModule = typescript_1.resolveModuleName(specifier, fromFile, this.options, this.host);
-            if (resolvedModule === undefined) {
-                return null;
-            }
-            var entryPointFile = typescript_1.getSourceFileOrNull(this.program, file_system_1.absoluteFrom(resolvedModule.resolvedFileName));
+            var entryPointFile = this.moduleResolver.resolveModule(specifier, fromFile);
             if (entryPointFile === null) {
                 return null;
             }
@@ -234,24 +261,25 @@
     }());
     exports.RelativePathStrategy = RelativePathStrategy;
     /**
-     * A `ReferenceEmitStrategy` which uses a `FileToModuleHost` to generate absolute import references.
+     * A `ReferenceEmitStrategy` which uses a `UnifiedModulesHost` to generate absolute import
+     * references.
      */
-    var FileToModuleStrategy = /** @class */ (function () {
-        function FileToModuleStrategy(reflector, fileToModuleHost) {
+    var UnifiedModulesStrategy = /** @class */ (function () {
+        function UnifiedModulesStrategy(reflector, unifiedModulesHost) {
             this.reflector = reflector;
-            this.fileToModuleHost = fileToModuleHost;
+            this.unifiedModulesHost = unifiedModulesHost;
         }
-        FileToModuleStrategy.prototype.emit = function (ref, context) {
+        UnifiedModulesStrategy.prototype.emit = function (ref, context) {
             var destSf = typescript_1.getSourceFile(ref.node);
             var name = find_export_1.findExportedNameOfNode(ref.node, destSf, this.reflector);
             if (name === null) {
                 return null;
             }
-            var moduleName = this.fileToModuleHost.fileNameToModuleName(destSf.fileName, context.fileName);
+            var moduleName = this.unifiedModulesHost.fileNameToModuleName(destSf.fileName, context.fileName);
             return new compiler_1.ExternalExpr({ moduleName: moduleName, name: name });
         };
-        return FileToModuleStrategy;
+        return UnifiedModulesStrategy;
     }());
-    exports.FileToModuleStrategy = FileToModuleStrategy;
+    exports.UnifiedModulesStrategy = UnifiedModulesStrategy;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/imports/src/emitter.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 {Expression, ExternalExpr, ExternalReference, WrappedNodeExpr} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {LogicalFileSystem, LogicalProjectPath, PathSegment, absoluteFrom, absoluteFromSourceFile, basename, dirname, relative, resolve} from '../../file_system';\nimport {stripExtension} from '../../file_system/src/util';\nimport {ReflectionHost} from '../../reflection';\nimport {getSourceFile, getSourceFileOrNull, isDeclaration, nodeNameForError, resolveModuleName} from '../../util/src/typescript';\n\nimport {findExportedNameOfNode} from './find_export';\nimport {ImportMode, Reference} from './references';\n\n\n\n/**\n * A host which supports an operation to convert a file name into a module name.\n *\n * This operation is typically implemented as part of the compiler host passed to ngtsc when running\n * under a build tool like Bazel or Blaze.\n */\nexport interface FileToModuleHost {\n  fileNameToModuleName(importedFilePath: string, containingFilePath: string): string;\n}\n\n/**\n * A particular strategy for generating an expression which refers to a `Reference`.\n *\n * There are many potential ways a given `Reference` could be referred to in the context of a given\n * file. A local declaration could be available, the `Reference` could be importable via a relative\n * import within the project, or an absolute import into `node_modules` might be necessary.\n *\n * Different `ReferenceEmitStrategy` implementations implement specific logic for generating such\n * references. A single strategy (such as using a local declaration) may not always be able to\n * generate an expression for every `Reference` (for example, if no local identifier is available),\n * and may return `null` in such a case.\n */\nexport interface ReferenceEmitStrategy {\n  /**\n   * Emit an `Expression` which refers to the given `Reference` in the context of a particular\n   * source file, if possible.\n   *\n   * @param ref the `Reference` for which to generate an expression\n   * @param context the source file in which the `Expression` must be valid\n   * @param importMode a flag which controls whether imports should be generated or not\n   * @returns an `Expression` which refers to the `Reference`, or `null` if none can be generated\n   */\n  emit(ref: Reference, context: ts.SourceFile, importMode: ImportMode): Expression|null;\n}\n\n/**\n * Generates `Expression`s which refer to `Reference`s in a given context.\n *\n * A `ReferenceEmitter` uses one or more `ReferenceEmitStrategy` implementations to produce an\n * `Expression` which refers to a `Reference` in the context of a particular file.\n */\nexport class ReferenceEmitter {\n  constructor(private strategies: ReferenceEmitStrategy[]) {}\n\n  emit(\n      ref: Reference, context: ts.SourceFile,\n      importMode: ImportMode = ImportMode.UseExistingImport): Expression {\n    for (const strategy of this.strategies) {\n      const emitted = strategy.emit(ref, context, importMode);\n      if (emitted !== null) {\n        return emitted;\n      }\n    }\n    throw new Error(\n        `Unable to write a reference to ${nodeNameForError(ref.node)} in ${ref.node.getSourceFile().fileName} from ${context.fileName}`);\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations by any local `ts.Identifier`s, if\n * such identifiers are available.\n */\nexport class LocalIdentifierStrategy implements ReferenceEmitStrategy {\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile, importMode: ImportMode): Expression|null {\n    // If the emitter has specified ForceNewImport, then LocalIdentifierStrategy should not use a\n    // local identifier at all, *except* in the source file where the node is actually declared.\n    if (importMode === ImportMode.ForceNewImport &&\n        getSourceFile(ref.node) !== getSourceFile(context)) {\n      return null;\n    }\n\n    // A Reference can have multiple identities in different files, so it may already have an\n    // Identifier in the requested context file.\n    const identifier = ref.getIdentityIn(context);\n    if (identifier !== null) {\n      return new WrappedNodeExpr(identifier);\n    } else {\n      return null;\n    }\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations that come from `node_modules` using\n * an absolute import.\n *\n * Part of this strategy involves looking at the target entry point and identifying the exported\n * name of the targeted declaration, as it might be different from the declared name (e.g. a\n * directive might be declared as FooDirImpl, but exported as FooDir). If no export can be found\n * which maps back to the original directive, an error is thrown.\n */\nexport class AbsoluteModuleStrategy implements ReferenceEmitStrategy {\n  /**\n   * A cache of the exports of specific modules, because resolving a module to its exports is a\n   * costly operation.\n   */\n  private moduleExportsCache = new Map<string, Map<ts.Declaration, string>|null>();\n\n  constructor(\n      protected program: ts.Program, protected checker: ts.TypeChecker,\n      protected options: ts.CompilerOptions, protected host: ts.CompilerHost,\n      private reflectionHost: ReflectionHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile, importMode: ImportMode): Expression|null {\n    if (ref.bestGuessOwningModule === null) {\n      // There is no module name available for this Reference, meaning it was arrived at via a\n      // relative path.\n      return null;\n    } else if (!isDeclaration(ref.node)) {\n      // It's not possible to import something which isn't a declaration.\n      throw new Error('Debug assert: importing a Reference to non-declaration?');\n    }\n\n    // Try to find the exported name of the declaration, if one is available.\n    const {specifier, resolutionContext} = ref.bestGuessOwningModule;\n    const symbolName = this.resolveImportName(specifier, ref.node, resolutionContext);\n    if (symbolName === null) {\n      // TODO(alxhub): make this error a ts.Diagnostic pointing at whatever caused this import to be\n      // triggered.\n      throw new Error(\n          `Symbol ${ref.debugName} declared in ${getSourceFile(ref.node).fileName} is not exported from ${specifier} (import into ${context.fileName})`);\n    }\n\n    return new ExternalExpr(new ExternalReference(specifier, symbolName));\n  }\n\n  private resolveImportName(moduleName: string, target: ts.Declaration, fromFile: string): string\n      |null {\n    const exports = this.getExportsOfModule(moduleName, fromFile);\n    if (exports !== null && exports.has(target)) {\n      return exports.get(target) !;\n    } else {\n      return null;\n    }\n  }\n\n  private getExportsOfModule(moduleName: string, fromFile: string):\n      Map<ts.Declaration, string>|null {\n    if (!this.moduleExportsCache.has(moduleName)) {\n      this.moduleExportsCache.set(moduleName, this.enumerateExportsOfModule(moduleName, fromFile));\n    }\n    return this.moduleExportsCache.get(moduleName) !;\n  }\n\n  protected enumerateExportsOfModule(specifier: string, fromFile: string):\n      Map<ts.Declaration, string>|null {\n    // First, resolve the module specifier to its entry point, and get the ts.Symbol for it.\n    const resolvedModule = resolveModuleName(specifier, fromFile, this.options, this.host);\n    if (resolvedModule === undefined) {\n      return null;\n    }\n\n    const entryPointFile =\n        getSourceFileOrNull(this.program, absoluteFrom(resolvedModule.resolvedFileName));\n    if (entryPointFile === null) {\n      return null;\n    }\n\n    const exports = this.reflectionHost.getExportsOfModule(entryPointFile);\n    if (exports === null) {\n      return null;\n    }\n    const exportMap = new Map<ts.Declaration, string>();\n    exports.forEach((declaration, name) => {\n      // It's okay to skip inline declarations, since by definition they're not target-able with a\n      // ts.Declaration anyway.\n      if (declaration.node !== null) {\n        exportMap.set(declaration.node, name);\n      }\n    });\n    return exportMap;\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations via relative paths, provided they're\n * both in the logical project \"space\" of paths.\n *\n * This is trickier than it sounds, as the two files may be in different root directories in the\n * project. Simply calculating a file system relative path between the two is not sufficient.\n * Instead, `LogicalProjectPath`s are used.\n */\nexport class LogicalProjectStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost, private logicalFs: LogicalFileSystem) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n\n    // Compute the relative path from the importing file to the file being imported. This is done\n    // as a logical path computation, because the two files might be in different rootDirs.\n    const destPath = this.logicalFs.logicalPathOfSf(destSf);\n    if (destPath === null) {\n      // The imported file is not within the logical project filesystem.\n      return null;\n    }\n\n    const originPath = this.logicalFs.logicalPathOfSf(context);\n    if (originPath === null) {\n      throw new Error(\n          `Debug assert: attempt to import from ${context.fileName} but it's outside the program?`);\n    }\n\n    // There's no way to emit a relative reference from a file to itself.\n    if (destPath === originPath) {\n      return null;\n    }\n\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    if (name === null) {\n      // The target declaration isn't exported from the file it's declared in. This is an issue!\n      return null;\n    }\n\n    // With both files expressed as LogicalProjectPaths, getting the module specifier as a relative\n    // path is now straightforward.\n    const moduleName = LogicalProjectPath.relativePathBetween(originPath, destPath);\n    return new ExternalExpr({moduleName, name});\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which constructs relatives paths between `ts.SourceFile`s.\n *\n * This strategy can be used if there is no `rootDir`/`rootDirs` structure for the project which\n * necessitates the stronger logic of `LogicalProjectStrategy`.\n */\nexport class RelativePathStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n    let moduleName = stripExtension(\n        relative(dirname(absoluteFromSourceFile(context)), absoluteFromSourceFile(destSf)));\n    if (!moduleName.startsWith('../')) {\n      moduleName = ('./' + moduleName) as PathSegment;\n    }\n\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    return new ExternalExpr({moduleName, name});\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which uses a `FileToModuleHost` to generate absolute import references.\n */\nexport class FileToModuleStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost, private fileToModuleHost: FileToModuleHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    if (name === null) {\n      return null;\n    }\n\n    const moduleName =\n        this.fileToModuleHost.fileNameToModuleName(destSf.fileName, context.fileName);\n\n    return new ExternalExpr({moduleName, name});\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/imports/src/emitter.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,8CAA+F;IAC/F,+BAAiC;IAGjC,2EAAgI;IAChI,6EAA0D;IAE1D,kFAA4G;IAE5G,uFAAqD;IAKrD;;OAEG;IACH,IAAY,WA2BX;IA3BD,WAAY,WAAW;QACrB,6CAAW,CAAA;QAEX;;;;;WAKG;QACH,iEAAqB,CAAA;QAErB;;;;;WAKG;QACH,yDAAiB,CAAA;QAEjB;;;;;;WAMG;QACH,qEAAuB,CAAA;IACzB,CAAC,EA3BW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QA2BtB;IA2BD;;;;;OAKG;IACH;QACE,0BAAoB,UAAmC;YAAnC,eAAU,GAAV,UAAU,CAAyB;QAAG,CAAC;QAE3D,+BAAI,GAAJ,UAAK,GAAc,EAAE,OAAsB,EAAE,WAA2C;;YAA3C,4BAAA,EAAA,cAA2B,WAAW,CAAC,IAAI;;gBAEtF,KAAuB,IAAA,KAAA,iBAAA,IAAI,CAAC,UAAU,CAAA,gBAAA,4BAAE;oBAAnC,IAAM,QAAQ,WAAA;oBACjB,IAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;oBACzD,IAAI,OAAO,KAAK,IAAI,EAAE;wBACpB,OAAO,OAAO,CAAC;qBAChB;iBACF;;;;;;;;;YACD,MAAM,IAAI,KAAK,CACX,oCAAkC,6BAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,YAAO,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,cAAS,OAAO,CAAC,QAAU,CAAC,CAAC;QACvI,CAAC;QACH,uBAAC;IAAD,CAAC,AAdD,IAcC;IAdY,4CAAgB;IAgB7B;;;OAGG;IACH;QAAA;QAkBA,CAAC;QAjBC,sCAAI,GAAJ,UAAK,GAAuB,EAAE,OAAsB,EAAE,WAAwB;YAC5E,6FAA6F;YAC7F,4FAA4F;YAC5F,IAAI,WAAW,GAAG,WAAW,CAAC,cAAc;gBACxC,0BAAa,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,0BAAa,CAAC,OAAO,CAAC,EAAE;gBACtD,OAAO,IAAI,CAAC;aACb;YAED,yFAAyF;YACzF,4CAA4C;YAC5C,IAAM,UAAU,GAAG,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YAC9C,IAAI,UAAU,KAAK,IAAI,EAAE;gBACvB,OAAO,IAAI,0BAAe,CAAC,UAAU,CAAC,CAAC;aACxC;iBAAM;gBACL,OAAO,IAAI,CAAC;aACb;QACH,CAAC;QACH,8BAAC;IAAD,CAAC,AAlBD,IAkBC;IAlBY,0DAAuB;IAoBpC;;;;;;;;OAQG;IACH;QAOE,gCACc,OAAmB,EAAY,OAAuB,EACtD,cAA8B,EAAU,cAA8B;YADtE,YAAO,GAAP,OAAO,CAAY;YAAY,YAAO,GAAP,OAAO,CAAgB;YACtD,mBAAc,GAAd,cAAc,CAAgB;YAAU,mBAAc,GAAd,cAAc,CAAgB;YARpF;;;eAGG;YACK,uBAAkB,GAAG,IAAI,GAAG,EAA4C,CAAC;QAIM,CAAC;QAExF,qCAAI,GAAJ,UAAK,GAAuB,EAAE,OAAsB,EAAE,WAAwB;YAC5E,IAAI,GAAG,CAAC,qBAAqB,KAAK,IAAI,EAAE;gBACtC,wFAAwF;gBACxF,iBAAiB;gBACjB,OAAO,IAAI,CAAC;aACb;iBAAM,IAAI,CAAC,0BAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;gBACnC,mEAAmE;gBACnE,MAAM,IAAI,KAAK,CACX,2EAAyE,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,MAAG,CAAC,CAAC;aAC/G;iBAAM,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,8BAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;gBAC5F,MAAM,IAAI,KAAK,CACX,+CAA6C,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,yCAAsC,CAAC,CAAC;aACtH;YAED,yEAAyE;YACnE,IAAA,8BAA0D,EAAzD,wBAAS,EAAE,wCAA8C,CAAC;YACjE,IAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,GAAG,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAC;YAClF,IAAI,UAAU,KAAK,IAAI,EAAE;gBACvB,8FAA8F;gBAC9F,aAAa;gBACb,MAAM,IAAI,KAAK,CACX,YAAU,GAAG,CAAC,SAAS,qBAAgB,0BAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,8BAAyB,SAAS,sBAAiB,OAAO,CAAC,QAAQ,MAAG,CAAC,CAAC;aACpJ;YAED,OAAO,IAAI,uBAAY,CAAC,IAAI,4BAAiB,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;QACxE,CAAC;QAEO,kDAAiB,GAAzB,UAA0B,UAAkB,EAAE,MAAsB,EAAE,QAAgB;YAEpF,IAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YAC9D,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;gBAC3C,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,CAAG,CAAC;aAC9B;iBAAM;gBACL,OAAO,IAAI,CAAC;aACb;QACH,CAAC;QAEO,mDAAkB,GAA1B,UAA2B,UAAkB,EAAE,QAAgB;YAE7D,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;gBAC5C,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC;aAC9F;YACD,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAG,CAAC;QACnD,CAAC;QAES,yDAAwB,GAAlC,UAAmC,SAAiB,EAAE,QAAgB;YAEpE,wFAAwF;YACxF,IAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC9E,IAAI,cAAc,KAAK,IAAI,EAAE;gBAC3B,OAAO,IAAI,CAAC;aACb;YAED,IAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC;YACvE,IAAI,OAAO,KAAK,IAAI,EAAE;gBACpB,OAAO,IAAI,CAAC;aACb;YACD,IAAM,SAAS,GAAG,IAAI,GAAG,EAA0B,CAAC;YACpD,OAAO,CAAC,OAAO,CAAC,UAAC,WAAW,EAAE,IAAI;gBAChC,4FAA4F;gBAC5F,yBAAyB;gBACzB,IAAI,WAAW,CAAC,IAAI,KAAK,IAAI,EAAE;oBAC7B,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;iBACvC;YACH,CAAC,CAAC,CAAC;YACH,OAAO,SAAS,CAAC;QACnB,CAAC;QACH,6BAAC;IAAD,CAAC,AA9ED,IA8EC;IA9EY,wDAAsB;IAgFnC;;;;;;;OAOG;IACH;QACE,gCAAoB,SAAyB,EAAU,SAA4B;YAA/D,cAAS,GAAT,SAAS,CAAgB;YAAU,cAAS,GAAT,SAAS,CAAmB;QAAG,CAAC;QAEvF,qCAAI,GAAJ,UAAK,GAAuB,EAAE,OAAsB;YAClD,IAAM,MAAM,GAAG,0BAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAEvC,6FAA6F;YAC7F,uFAAuF;YACvF,IAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;YACxD,IAAI,QAAQ,KAAK,IAAI,EAAE;gBACrB,kEAAkE;gBAClE,OAAO,IAAI,CAAC;aACb;YAED,IAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YAC3D,IAAI,UAAU,KAAK,IAAI,EAAE;gBACvB,MAAM,IAAI,KAAK,CACX,0CAAwC,OAAO,CAAC,QAAQ,mCAAgC,CAAC,CAAC;aAC/F;YAED,qEAAqE;YACrE,IAAI,QAAQ,KAAK,UAAU,EAAE;gBAC3B,OAAO,IAAI,CAAC;aACb;YAED,IAAM,IAAI,GAAG,oCAAsB,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YACtE,IAAI,IAAI,KAAK,IAAI,EAAE;gBACjB,0FAA0F;gBAC1F,OAAO,IAAI,CAAC;aACb;YAED,+FAA+F;YAC/F,+BAA+B;YAC/B,IAAM,UAAU,GAAG,gCAAkB,CAAC,mBAAmB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YAChF,OAAO,IAAI,uBAAY,CAAC,EAAC,UAAU,YAAA,EAAE,IAAI,MAAA,EAAC,CAAC,CAAC;QAC9C,CAAC;QACH,6BAAC;IAAD,CAAC,AApCD,IAoCC;IApCY,wDAAsB;IAsCnC;;;;;OAKG;IACH;QACE,8BAAoB,SAAyB;YAAzB,cAAS,GAAT,SAAS,CAAgB;QAAG,CAAC;QAEjD,mCAAI,GAAJ,UAAK,GAAuB,EAAE,OAAsB;YAClD,IAAM,MAAM,GAAG,0BAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACvC,IAAI,UAAU,GAAG,qBAAc,CAC3B,sBAAQ,CAAC,qBAAO,CAAC,oCAAsB,CAAC,OAAO,CAAC,CAAC,EAAE,oCAAsB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YACxF,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE;gBACjC,UAAU,GAAG,CAAC,IAAI,GAAG,UAAU,CAAgB,CAAC;aACjD;YAED,IAAM,IAAI,GAAG,oCAAsB,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YACtE,OAAO,IAAI,uBAAY,CAAC,EAAC,UAAU,YAAA,EAAE,IAAI,MAAA,EAAC,CAAC,CAAC;QAC9C,CAAC;QACH,2BAAC;IAAD,CAAC,AAdD,IAcC;IAdY,oDAAoB;IAgBjC;;;OAGG;IACH;QACE,gCAAoB,SAAyB,EAAU,kBAAsC;YAAzE,cAAS,GAAT,SAAS,CAAgB;YAAU,uBAAkB,GAAlB,kBAAkB,CAAoB;QAAG,CAAC;QAEjG,qCAAI,GAAJ,UAAK,GAAuB,EAAE,OAAsB;YAClD,IAAM,MAAM,GAAG,0BAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACvC,IAAM,IAAI,GAAG,oCAAsB,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;YACtE,IAAI,IAAI,KAAK,IAAI,EAAE;gBACjB,OAAO,IAAI,CAAC;aACb;YAED,IAAM,UAAU,GACZ,IAAI,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;YAEpF,OAAO,IAAI,uBAAY,CAAC,EAAC,UAAU,YAAA,EAAE,IAAI,MAAA,EAAC,CAAC,CAAC;QAC9C,CAAC;QACH,6BAAC;IAAD,CAAC,AAfD,IAeC;IAfY,wDAAsB","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 {Expression, ExternalExpr, ExternalReference, WrappedNodeExpr} from '@angular/compiler';\nimport * as ts from 'typescript';\n\nimport {UnifiedModulesHost} from '../../core/api';\nimport {LogicalFileSystem, LogicalProjectPath, PathSegment, absoluteFromSourceFile, dirname, relative} from '../../file_system';\nimport {stripExtension} from '../../file_system/src/util';\nimport {ReflectionHost} from '../../reflection';\nimport {getSourceFile, isDeclaration, isTypeDeclaration, nodeNameForError} from '../../util/src/typescript';\n\nimport {findExportedNameOfNode} from './find_export';\nimport {Reference} from './references';\nimport {ModuleResolver} from './resolver';\n\n\n/**\n * Flags which alter the imports generated by the `ReferenceEmitter`.\n */\nexport enum ImportFlags {\n  None = 0x00,\n\n  /**\n   * Force the generation of a new import when generating a reference, even if an identifier already\n   * exists in the target file which could be used instead.\n   *\n   * This is sometimes required if there's a risk TypeScript might remove imports during emit.\n   */\n  ForceNewImport = 0x01,\n\n  /**\n   * Don't make use of any aliasing information when emitting a reference.\n   *\n   * This is sometimes required if emitting into a context where generated references will be fed\n   * into TypeScript and type-checked (such as in template type-checking).\n   */\n  NoAliasing = 0x02,\n\n  /**\n   * Indicates that an import to a type-only declaration is allowed.\n   *\n   * For references that occur in type-positions, the referred declaration may be a type-only\n   * declaration that is not retained during emit. Including this flag allows to emit references to\n   * type-only declarations as used in e.g. template type-checking.\n   */\n  AllowTypeImports = 0x04,\n}\n\n/**\n * A particular strategy for generating an expression which refers to a `Reference`.\n *\n * There are many potential ways a given `Reference` could be referred to in the context of a given\n * file. A local declaration could be available, the `Reference` could be importable via a relative\n * import within the project, or an absolute import into `node_modules` might be necessary.\n *\n * Different `ReferenceEmitStrategy` implementations implement specific logic for generating such\n * references. A single strategy (such as using a local declaration) may not always be able to\n * generate an expression for every `Reference` (for example, if no local identifier is available),\n * and may return `null` in such a case.\n */\nexport interface ReferenceEmitStrategy {\n  /**\n   * Emit an `Expression` which refers to the given `Reference` in the context of a particular\n   * source file, if possible.\n   *\n   * @param ref the `Reference` for which to generate an expression\n   * @param context the source file in which the `Expression` must be valid\n   * @param importFlags a flag which controls whether imports should be generated or not\n   * @returns an `Expression` which refers to the `Reference`, or `null` if none can be generated\n   */\n  emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags): Expression|null;\n}\n\n/**\n * Generates `Expression`s which refer to `Reference`s in a given context.\n *\n * A `ReferenceEmitter` uses one or more `ReferenceEmitStrategy` implementations to produce an\n * `Expression` which refers to a `Reference` in the context of a particular file.\n */\nexport class ReferenceEmitter {\n  constructor(private strategies: ReferenceEmitStrategy[]) {}\n\n  emit(ref: Reference, context: ts.SourceFile, importFlags: ImportFlags = ImportFlags.None):\n      Expression {\n    for (const strategy of this.strategies) {\n      const emitted = strategy.emit(ref, context, importFlags);\n      if (emitted !== null) {\n        return emitted;\n      }\n    }\n    throw new Error(\n        `Unable to write a reference to ${nodeNameForError(ref.node)} in ${ref.node.getSourceFile().fileName} from ${context.fileName}`);\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations by any local `ts.Identifier`s, if\n * such identifiers are available.\n */\nexport class LocalIdentifierStrategy implements ReferenceEmitStrategy {\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile, importFlags: ImportFlags): Expression|null {\n    // If the emitter has specified ForceNewImport, then LocalIdentifierStrategy should not use a\n    // local identifier at all, *except* in the source file where the node is actually declared.\n    if (importFlags & ImportFlags.ForceNewImport &&\n        getSourceFile(ref.node) !== getSourceFile(context)) {\n      return null;\n    }\n\n    // A Reference can have multiple identities in different files, so it may already have an\n    // Identifier in the requested context file.\n    const identifier = ref.getIdentityIn(context);\n    if (identifier !== null) {\n      return new WrappedNodeExpr(identifier);\n    } else {\n      return null;\n    }\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations that come from `node_modules` using\n * an absolute import.\n *\n * Part of this strategy involves looking at the target entry point and identifying the exported\n * name of the targeted declaration, as it might be different from the declared name (e.g. a\n * directive might be declared as FooDirImpl, but exported as FooDir). If no export can be found\n * which maps back to the original directive, an error is thrown.\n */\nexport class AbsoluteModuleStrategy implements ReferenceEmitStrategy {\n  /**\n   * A cache of the exports of specific modules, because resolving a module to its exports is a\n   * costly operation.\n   */\n  private moduleExportsCache = new Map<string, Map<ts.Declaration, string>|null>();\n\n  constructor(\n      protected program: ts.Program, protected checker: ts.TypeChecker,\n      protected moduleResolver: ModuleResolver, private reflectionHost: ReflectionHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile, importFlags: ImportFlags): Expression|null {\n    if (ref.bestGuessOwningModule === null) {\n      // There is no module name available for this Reference, meaning it was arrived at via a\n      // relative path.\n      return null;\n    } else if (!isDeclaration(ref.node)) {\n      // It's not possible to import something which isn't a declaration.\n      throw new Error(\n          `Debug assert: unable to import a Reference to non-declaration of type ${ts.SyntaxKind[ref.node.kind]}.`);\n    } else if ((importFlags & ImportFlags.AllowTypeImports) === 0 && isTypeDeclaration(ref.node)) {\n      throw new Error(\n          `Importing a type-only declaration of type ${ts.SyntaxKind[ref.node.kind]} in a value position is not allowed.`);\n    }\n\n    // Try to find the exported name of the declaration, if one is available.\n    const {specifier, resolutionContext} = ref.bestGuessOwningModule;\n    const symbolName = this.resolveImportName(specifier, ref.node, resolutionContext);\n    if (symbolName === null) {\n      // TODO(alxhub): make this error a ts.Diagnostic pointing at whatever caused this import to be\n      // triggered.\n      throw new Error(\n          `Symbol ${ref.debugName} declared in ${getSourceFile(ref.node).fileName} is not exported from ${specifier} (import into ${context.fileName})`);\n    }\n\n    return new ExternalExpr(new ExternalReference(specifier, symbolName));\n  }\n\n  private resolveImportName(moduleName: string, target: ts.Declaration, fromFile: string): string\n      |null {\n    const exports = this.getExportsOfModule(moduleName, fromFile);\n    if (exports !== null && exports.has(target)) {\n      return exports.get(target) !;\n    } else {\n      return null;\n    }\n  }\n\n  private getExportsOfModule(moduleName: string, fromFile: string):\n      Map<ts.Declaration, string>|null {\n    if (!this.moduleExportsCache.has(moduleName)) {\n      this.moduleExportsCache.set(moduleName, this.enumerateExportsOfModule(moduleName, fromFile));\n    }\n    return this.moduleExportsCache.get(moduleName) !;\n  }\n\n  protected enumerateExportsOfModule(specifier: string, fromFile: string):\n      Map<ts.Declaration, string>|null {\n    // First, resolve the module specifier to its entry point, and get the ts.Symbol for it.\n    const entryPointFile = this.moduleResolver.resolveModule(specifier, fromFile);\n    if (entryPointFile === null) {\n      return null;\n    }\n\n    const exports = this.reflectionHost.getExportsOfModule(entryPointFile);\n    if (exports === null) {\n      return null;\n    }\n    const exportMap = new Map<ts.Declaration, string>();\n    exports.forEach((declaration, name) => {\n      // It's okay to skip inline declarations, since by definition they're not target-able with a\n      // ts.Declaration anyway.\n      if (declaration.node !== null) {\n        exportMap.set(declaration.node, name);\n      }\n    });\n    return exportMap;\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which will refer to declarations via relative paths, provided they're\n * both in the logical project \"space\" of paths.\n *\n * This is trickier than it sounds, as the two files may be in different root directories in the\n * project. Simply calculating a file system relative path between the two is not sufficient.\n * Instead, `LogicalProjectPath`s are used.\n */\nexport class LogicalProjectStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost, private logicalFs: LogicalFileSystem) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n\n    // Compute the relative path from the importing file to the file being imported. This is done\n    // as a logical path computation, because the two files might be in different rootDirs.\n    const destPath = this.logicalFs.logicalPathOfSf(destSf);\n    if (destPath === null) {\n      // The imported file is not within the logical project filesystem.\n      return null;\n    }\n\n    const originPath = this.logicalFs.logicalPathOfSf(context);\n    if (originPath === null) {\n      throw new Error(\n          `Debug assert: attempt to import from ${context.fileName} but it's outside the program?`);\n    }\n\n    // There's no way to emit a relative reference from a file to itself.\n    if (destPath === originPath) {\n      return null;\n    }\n\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    if (name === null) {\n      // The target declaration isn't exported from the file it's declared in. This is an issue!\n      return null;\n    }\n\n    // With both files expressed as LogicalProjectPaths, getting the module specifier as a relative\n    // path is now straightforward.\n    const moduleName = LogicalProjectPath.relativePathBetween(originPath, destPath);\n    return new ExternalExpr({moduleName, name});\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which constructs relatives paths between `ts.SourceFile`s.\n *\n * This strategy can be used if there is no `rootDir`/`rootDirs` structure for the project which\n * necessitates the stronger logic of `LogicalProjectStrategy`.\n */\nexport class RelativePathStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n    let moduleName = stripExtension(\n        relative(dirname(absoluteFromSourceFile(context)), absoluteFromSourceFile(destSf)));\n    if (!moduleName.startsWith('../')) {\n      moduleName = ('./' + moduleName) as PathSegment;\n    }\n\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    return new ExternalExpr({moduleName, name});\n  }\n}\n\n/**\n * A `ReferenceEmitStrategy` which uses a `UnifiedModulesHost` to generate absolute import\n * references.\n */\nexport class UnifiedModulesStrategy implements ReferenceEmitStrategy {\n  constructor(private reflector: ReflectionHost, private unifiedModulesHost: UnifiedModulesHost) {}\n\n  emit(ref: Reference<ts.Node>, context: ts.SourceFile): Expression|null {\n    const destSf = getSourceFile(ref.node);\n    const name = findExportedNameOfNode(ref.node, destSf, this.reflector);\n    if (name === null) {\n      return null;\n    }\n\n    const moduleName =\n        this.unifiedModulesHost.fileNameToModuleName(destSf.fileName, context.fileName);\n\n    return new ExternalExpr({moduleName, name});\n  }\n}\n"]}