refactor(compiler): bump metadata version to 4 (#19338)

Also adds auto upgrade from lower version based
on the .d.ts file (e.g. from version 3 to 4).

This is needed as we are now also capturing type aliases
in metadata files (and we rely on this),
see 6e3498ca8e.

packages/compiler-cli/src/compiler_host.ts

@@ -11,7 +11,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';
 
-import {CollectorOptions, MetadataCollector, ModuleMetadata} from './metadata/index';
+import {CollectorOptions, METADATA_VERSION, MetadataCollector, ModuleMetadata} from './metadata/index';
 import {CompilerOptions} from './transformers/api';
 
 const EXT = /(\.ts|\.d\.ts|\.js|\.jsx|\.tsx)$/;
@@ -76,9 +76,9 @@ export abstract class BaseAotCompilerHost<C extends BaseAotCompilerHostContext>
       let metadatas = this.readMetadata(filePath);
       if (!metadatas) {
         // If there is a .d.ts file but no metadata file we need to produce a
-        // v3 metadata from the .d.ts file as v3 includes the exports we need
-        // to resolve symbols.
-        metadatas = [this.upgradeVersion1Metadata(
+        // metadata from the .d.ts file as metadata files capture reexports
+        // (starting with v3).
+        metadatas = [this.upgradeMetadataWithDtsData(
             {'__symbolic': 'module', 'version': 1, 'metadata': {}}, filePath)];
       }
       return metadatas;
@@ -104,10 +104,11 @@ export abstract class BaseAotCompilerHost<C extends BaseAotCompilerHostContext>
       const metadatas: ModuleMetadata[] = metadataOrMetadatas ?
           (Array.isArray(metadataOrMetadatas) ? metadataOrMetadatas : [metadataOrMetadatas]) :
           [];
-      const v1Metadata = metadatas.find(m => m.version === 1);
-      let v3Metadata = metadatas.find(m => m.version === 3);
-      if (!v3Metadata && v1Metadata) {
-        metadatas.push(this.upgradeVersion1Metadata(v1Metadata, dtsFilePath));
+      if (metadatas.length) {
+        let maxMetadata = metadatas.reduce((p, c) => p.version > c.version ? p : c);
+        if (maxMetadata.version < METADATA_VERSION) {
+          metadatas.push(this.upgradeMetadataWithDtsData(maxMetadata, dtsFilePath));
+        }
       }
       this.resolverCache.set(dtsFilePath, metadatas);
       return metadatas;
@@ -117,30 +118,44 @@ export abstract class BaseAotCompilerHost<C extends BaseAotCompilerHostContext>
     }
   }
 
-  private upgradeVersion1Metadata(v1Metadata: ModuleMetadata, dtsFilePath: string): ModuleMetadata {
-    // patch up v1 to v3 by merging the metadata with metadata collected from the d.ts file
-    // as the only difference between the versions is whether all exports are contained in
-    // the metadata and the `extends` clause.
-    let v3Metadata: ModuleMetadata = {'__symbolic': 'module', 'version': 3, 'metadata': {}};
-    if (v1Metadata.exports) {
-      v3Metadata.exports = v1Metadata.exports;
+  private upgradeMetadataWithDtsData(oldMetadata: ModuleMetadata, dtsFilePath: string):
+      ModuleMetadata {
+    // patch v1 to v3 by adding exports and the `extends` clause.
+    // patch v3 to v4 by adding `interface` symbols for TypeAlias
+    let newMetadata: ModuleMetadata = {
+      '__symbolic': 'module',
+      'version': METADATA_VERSION,
+      'metadata': {...oldMetadata.metadata},
+    };
+    if (oldMetadata.exports) {
+      newMetadata.exports = oldMetadata.exports;
     }
-    for (let prop in v1Metadata.metadata) {
-      v3Metadata.metadata[prop] = v1Metadata.metadata[prop];
+    if (oldMetadata.importAs) {
+      newMetadata.importAs = oldMetadata.importAs;
     }
-
-    const exports = this.getMetadataForSourceFile(dtsFilePath);
-    if (exports) {
-      for (let prop in exports.metadata) {
-        if (!v3Metadata.metadata[prop]) {
-          v3Metadata.metadata[prop] = exports.metadata[prop];
+    if (oldMetadata.origins) {
+      newMetadata.origins = oldMetadata.origins;
+    }
+    const dtsMetadata = this.getMetadataForSourceFile(dtsFilePath);
+    if (dtsMetadata) {
+      for (let prop in dtsMetadata.metadata) {
+        if (!newMetadata.metadata[prop]) {
+          newMetadata.metadata[prop] = dtsMetadata.metadata[prop];
         }
       }
-      if (exports.exports) {
-        v3Metadata.exports = exports.exports;
+
+      // Only copy exports from exports from metadata prior to version 3.
+      // Starting with version 3 the collector began collecting exports and
+      // this should be redundant. Also, with bundler will rewrite the exports
+      // which will hoist the exports from modules referenced indirectly causing
+      // the imports to be different than the .d.ts files and using the .d.ts file
+      // exports would cause the StaticSymbolResolver to redirect symbols to the
+      // incorrect location.
+      if ((!oldMetadata.version || oldMetadata.version < 3) && dtsMetadata.exports) {
+        newMetadata.exports = dtsMetadata.exports;
       }
     }
-    return v3Metadata;
+    return newMetadata;
   }
 
   loadResource(filePath: string): Promise<string>|string {

packages/compiler-cli/src/metadata/bundler.ts

@@ -9,7 +9,7 @@ import * as path from 'path';
 import * as ts from 'typescript';
 
 import {MetadataCollector} from '../metadata/collector';
-import {ClassMetadata, ConstructorMetadata, FunctionMetadata, MemberMetadata, MetadataEntry, MetadataError, MetadataImportedSymbolReferenceExpression, MetadataMap, MetadataObject, MetadataSymbolicExpression, MetadataSymbolicReferenceExpression, MetadataValue, MethodMetadata, ModuleExportMetadata, ModuleMetadata, VERSION, isClassMetadata, isConstructorMetadata, isFunctionMetadata, isInterfaceMetadata, isMetadataError, isMetadataGlobalReferenceExpression, isMetadataImportedSymbolReferenceExpression, isMetadataModuleReferenceExpression, isMetadataSymbolicExpression, isMethodMetadata} from '../metadata/schema';
+import {ClassMetadata, ConstructorMetadata, FunctionMetadata, METADATA_VERSION, MemberMetadata, MetadataEntry, MetadataError, MetadataImportedSymbolReferenceExpression, MetadataMap, MetadataObject, MetadataSymbolicExpression, MetadataSymbolicReferenceExpression, MetadataValue, MethodMetadata, ModuleExportMetadata, ModuleMetadata, isClassMetadata, isConstructorMetadata, isFunctionMetadata, isInterfaceMetadata, isMetadataError, isMetadataGlobalReferenceExpression, isMetadataImportedSymbolReferenceExpression, isMetadataModuleReferenceExpression, isMetadataSymbolicExpression, isMethodMetadata} from '../metadata/schema';
 
 
 
@@ -114,7 +114,7 @@ export class MetadataBundler {
     return {
       metadata: {
         __symbolic: 'module',
-        version: VERSION,
+        version: METADATA_VERSION,
         exports: exports.length ? exports : undefined, metadata, origins,
         importAs: this.importAs !
       },

packages/compiler-cli/src/metadata/collector.ts

@@ -9,7 +9,7 @@
 import * as ts from 'typescript';
 
 import {Evaluator, errorSymbol} from './evaluator';
-import {ClassMetadata, ConstructorMetadata, FunctionMetadata, InterfaceMetadata, MemberMetadata, MetadataEntry, MetadataError, MetadataMap, MetadataSymbolicBinaryExpression, MetadataSymbolicCallExpression, MetadataSymbolicExpression, MetadataSymbolicIfExpression, MetadataSymbolicIndexExpression, MetadataSymbolicPrefixExpression, MetadataSymbolicReferenceExpression, MetadataSymbolicSelectExpression, MetadataSymbolicSpreadExpression, MetadataValue, MethodMetadata, ModuleExportMetadata, ModuleMetadata, VERSION, isClassMetadata, isConstructorMetadata, isFunctionMetadata, isMetadataError, isMetadataGlobalReferenceExpression, isMetadataSymbolicExpression, isMetadataSymbolicReferenceExpression, isMetadataSymbolicSelectExpression, isMethodMetadata} from './schema';
+import {ClassMetadata, ConstructorMetadata, FunctionMetadata, InterfaceMetadata, METADATA_VERSION, MemberMetadata, MetadataEntry, MetadataError, MetadataMap, MetadataSymbolicBinaryExpression, MetadataSymbolicCallExpression, MetadataSymbolicExpression, MetadataSymbolicIfExpression, MetadataSymbolicIndexExpression, MetadataSymbolicPrefixExpression, MetadataSymbolicReferenceExpression, MetadataSymbolicSelectExpression, MetadataSymbolicSpreadExpression, MetadataValue, MethodMetadata, ModuleExportMetadata, ModuleMetadata, isClassMetadata, isConstructorMetadata, isFunctionMetadata, isMetadataError, isMetadataGlobalReferenceExpression, isMetadataSymbolicExpression, isMetadataSymbolicReferenceExpression, isMetadataSymbolicSelectExpression, isMethodMetadata} from './schema';
 import {Symbols} from './symbols';
 
 const isStatic = (node: ts.Node) => ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Static;
@@ -549,7 +549,7 @@ export class MetadataCollector {
       }
       const result: ModuleMetadata = {
         __symbolic: 'module',
-        version: this.options.version || VERSION, metadata
+        version: this.options.version || METADATA_VERSION, metadata
       };
       if (exports) result.exports = exports;
       return result;

packages/compiler-cli/src/metadata/schema.ts

@@ -8,14 +8,15 @@
 
 // Metadata Schema
 
-// If you make a backwards incompatible change to the schema, increment the VERSION number.
+// If you make a backwards incompatible change to the schema, increment the METADTA_VERSION number.
 
 // If you make a backwards compatible change to the metadata (such as adding an option field) then
-// leave VERSION the same. If possible, as many versions of the metadata that can represent the
-// semantics of the file in an array. For example, when generating a version 2 file, if version 1
-// can accurately represent the metadata, generate both version 1 and version 2 in an array.
+// leave METADATA_VERSION the same. If possible, supply as many versions of the metadata that can
+// represent the semantics of the file in an array. For example, when generating a version 2 file,
+// if version 1 can accurately represent the metadata, generate both version 1 and version 2 in
+// an array.
 
-export const VERSION = 3;
+export const METADATA_VERSION = 4;
 
 export type MetadataEntry = ClassMetadata | InterfaceMetadata | FunctionMetadata | MetadataValue;