fix(compiler): allow to use flat modules and summaries

The combination of flat modules, flat module redirects and summaries
lead to errors before.

packages/compiler/src/aot/static_symbol_resolver.ts

@@ -164,10 +164,15 @@ export class StaticSymbolResolver {
    * Converts a file path to a module name that can be used as an `import`.
    */
   fileNameToModuleName(importedFilePath: string, containingFilePath: string): string {
-    return this.knownFileNameToModuleNames.get(importedFilePath) ||
+    return this.summaryResolver.getKnownModuleName(importedFilePath) ||
+        this.knownFileNameToModuleNames.get(importedFilePath) ||
         this.host.fileNameToModuleName(importedFilePath, containingFilePath);
   }
 
+  getKnownModuleName(filePath: string): string|null {
+    return this.knownFileNameToModuleNames.get(filePath) || null;
+  }
+
   recordImportAs(sourceSymbol: StaticSymbol, targetSymbol: StaticSymbol) {
     sourceSymbol.assertNoMembers();
     targetSymbol.assertNoMembers();
@@ -292,7 +297,11 @@ export class StaticSymbolResolver {
     this.resolvedFilePaths.add(filePath);
     const resolvedSymbols: ResolvedStaticSymbol[] = [];
     const metadata = this.getModuleMetadata(filePath);
-
+    if (metadata['importAs']) {
+      // Index bundle indices should use the importAs module name defined
+      // in the bundle.
+      this.knownFileNameToModuleNames.set(filePath, metadata['importAs']);
+    }
     // handle the symbols in one of the re-export location
     if (metadata['exports']) {
       for (const moduleExport of metadata['exports']) {

packages/compiler/src/aot/summary_resolver.ts

@@ -45,6 +45,7 @@ export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
   private loadedFilePaths = new Map<string, boolean>();
   // Note: this will only contain StaticSymbols without members!
   private importAs = new Map<StaticSymbol, StaticSymbol>();
+  private knownFileNameToModuleNames = new Map<string, string>();
 
   constructor(private host: AotSummaryResolverHost, private staticSymbolCache: StaticSymbolCache) {}
 
@@ -85,6 +86,13 @@ export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
     return this.importAs.get(staticSymbol) !;
   }
 
+  /**
+   * Converts a file path to a module name that can be used as an `import`.
+   */
+  getKnownModuleName(importedFilePath: string): string|null {
+    return this.knownFileNameToModuleNames.get(importedFilePath) || null;
+  }
+
   addSummary(summary: Summary<StaticSymbol>) { this.summaryCache.set(summary.symbol, summary); }
 
   private _loadSummaryFile(filePath: string): boolean {
@@ -105,9 +113,12 @@ export class AotSummaryResolver implements SummaryResolver<StaticSymbol> {
     hasSummary = json != null;
     this.loadedFilePaths.set(filePath, hasSummary);
     if (json) {
-      const {summaries, importAs} =
+      const {moduleName, summaries, importAs} =
           deserializeSummaries(this.staticSymbolCache, this, filePath, json);
       summaries.forEach((summary) => this.summaryCache.set(summary.symbol, summary));
+      if (moduleName) {
+        this.knownFileNameToModuleNames.set(filePath, moduleName);
+      }
       importAs.forEach((importAs) => {
         this.importAs.set(
             importAs.symbol,

packages/compiler/src/aot/summary_serializer.ts

@@ -21,7 +21,7 @@ export function serializeSummaries(
       metadata: CompileNgModuleMetadata | CompileDirectiveMetadata | CompilePipeMetadata |
           CompileTypeMetadata
     }[]): {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {
-  const toJsonSerializer = new ToJsonSerializer(symbolResolver, summaryResolver);
+  const toJsonSerializer = new ToJsonSerializer(symbolResolver, summaryResolver, srcFileName);
   const forJitSerializer = new ForJitSerializer(forJitCtx, symbolResolver);
 
   // for symbols, we use everything except for the class metadata itself
@@ -43,15 +43,18 @@ export function serializeSummaries(
     }
   });
 
-  const {json, exportAs} = toJsonSerializer.serialize(srcFileName);
+  const {json, exportAs} = toJsonSerializer.serialize();
   forJitSerializer.serialize(exportAs);
   return {json, exportAs};
 }
 
 export function deserializeSummaries(
     symbolCache: StaticSymbolCache, summaryResolver: SummaryResolver<StaticSymbol>,
-    libraryFileName: string, json: string):
-    {summaries: Summary<StaticSymbol>[], importAs: {symbol: StaticSymbol, importAs: string}[]} {
+    libraryFileName: string, json: string): {
+  moduleName: string | null,
+  summaries: Summary<StaticSymbol>[],
+  importAs: {symbol: StaticSymbol, importAs: string}[]
+} {
   const deserializer = new FromJsonDeserializer(symbolCache, summaryResolver);
   return deserializer.deserialize(libraryFileName, json);
 }
@@ -82,13 +85,15 @@ class ToJsonSerializer extends ValueTransformer {
   // StaticSymbols, but otherwise has the same shape as the original objects.
   private processedSummaryBySymbol = new Map<StaticSymbol, any>();
   private processedSummaries: any[] = [];
+  private moduleName: string|null;
 
   unprocessedSymbolSummariesBySymbol = new Map<StaticSymbol, Summary<StaticSymbol>>();
 
   constructor(
       private symbolResolver: StaticSymbolResolver,
-      private summaryResolver: SummaryResolver<StaticSymbol>) {
+      private summaryResolver: SummaryResolver<StaticSymbol>, private srcFileName: string) {
     super();
+    this.moduleName = symbolResolver.getKnownModuleName(srcFileName);
   }
 
   addSummary(summary: Summary<StaticSymbol>) {
@@ -147,10 +152,10 @@ class ToJsonSerializer extends ValueTransformer {
     }
   }
 
-  serialize(srcFileName: string):
-      {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {
+  serialize(): {json: string, exportAs: {symbol: StaticSymbol, exportAs: string}[]} {
     const exportAs: {symbol: StaticSymbol, exportAs: string}[] = [];
     const json = JSON.stringify({
+      moduleName: this.moduleName,
       summaries: this.processedSummaries,
       symbols: this.symbols.map((symbol, index) => {
         symbol.assertNoMembers();
@@ -165,7 +170,7 @@ class ToJsonSerializer extends ValueTransformer {
         return {
           __symbol: index,
           name: symbol.name,
-          filePath: this.summaryResolver.toSummaryFileName(symbol.filePath, srcFileName),
+          filePath: this.summaryResolver.toSummaryFileName(symbol.filePath, this.srcFileName),
           importAs: importAs
         };
       })
@@ -368,9 +373,12 @@ class FromJsonDeserializer extends ValueTransformer {
     super();
   }
 
-  deserialize(libraryFileName: string, json: string):
-      {summaries: Summary<StaticSymbol>[], importAs: {symbol: StaticSymbol, importAs: string}[]} {
-    const data: {summaries: any[], symbols: any[]} = JSON.parse(json);
+  deserialize(libraryFileName: string, json: string): {
+    moduleName: string | null,
+    summaries: Summary<StaticSymbol>[],
+    importAs: {symbol: StaticSymbol, importAs: string}[]
+  } {
+    const data: {moduleName: string | null, summaries: any[], symbols: any[]} = JSON.parse(json);
     const importAs: {symbol: StaticSymbol, importAs: string}[] = [];
     this.symbols = [];
     data.symbols.forEach((serializedSymbol) => {
@@ -383,7 +391,7 @@ class FromJsonDeserializer extends ValueTransformer {
       }
     });
     const summaries = visitValue(data.summaries, this, null);
-    return {summaries, importAs};
+    return {moduleName: data.moduleName, summaries, importAs};
   }
 
   visitStringMap(map: {[key: string]: any}, context: any): any {

packages/compiler/src/summary_resolver.ts

@@ -21,6 +21,7 @@ export abstract class SummaryResolver<T> {
   abstract resolveSummary(reference: T): Summary<T>|null;
   abstract getSymbolsOf(filePath: string): T[]|null;
   abstract getImportAs(reference: T): T;
+  abstract getKnownModuleName(fileName: string): string|null;
   abstract addSummary(summary: Summary<T>): void;
 }
 
@@ -35,5 +36,6 @@ export class JitSummaryResolver implements SummaryResolver<Type> {
   }
   getSymbolsOf(): Type[] { return []; }
   getImportAs(reference: Type): Type { return reference; }
+  getKnownModuleName(fileName: string) { return null; }
   addSummary(summary: Summary<Type>) { this._summaries.set(summary.symbol, summary); }
 }

packages/compiler/test/aot/static_symbol_resolver_spec.ts

@@ -406,7 +406,7 @@ export class MockSummaryResolver implements SummaryResolver<StaticSymbol> {
     const entry = this.importAs.find(entry => entry.symbol === symbol);
     return entry ? entry.importAs : undefined !;
   }
-
+  getKnownModuleName(fileName: string): string|null { return null; }
   isLibraryFile(filePath: string): boolean { return filePath.endsWith('.d.ts'); }
   toSummaryFileName(filePath: string): string { return filePath.replace(/(\.d)?\.ts$/, '.d.ts'); }
   fromSummaryFileName(filePath: string): string { return filePath; }