dart2js: create a 'types' table for each deferred unit.

pkg/compiler/lib/src/js_emitter/old_emitter/emitter.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 598 matching lines @@
     } else {
       return js('#(#,#,#,#)',
           [js(lazyInitializerName),
            js.string(namer.globalPropertyName(element)),
            js.string(namer.lazyInitializerName(element)),
            code,
            js.string(element.name)]);
     }
   }
 
-  void emitMetadata(Program program, CodeOutput output) {
+  void emitMetadata(Program program, CodeOutput output, OutputUnit outputUnit) {
 
-   addMetadataGlobal(List<String> list, String global) {
-     String globalAccess = generateEmbeddedGlobalAccessString(global);
-     output.add('$globalAccess$_=$_[');
-     for (String data in list) {
-       if (data is String) {
-         if (data != 'null') {
-           output.add(data);
-         }
-       } else {
-         throw 'Unexpected value in ${global}: ${Error.safeToString(data)}';
-       }
-       output.add(',$n');
-     }
-     output.add('];$n');
-   }
+    jsAst.Expression constructList(List<String> list) {
+      String listAsString = list == null ? '[]' : '[${list.join(",")}]';
+      return js.uncachedExpressionTemplate(listAsString).instantiate([]);
+    }
 
-   addMetadataGlobal(program.metadata, embeddedNames.METADATA);
-   addMetadataGlobal(program.metadataTypes, embeddedNames.TYPES);
+    List<String> types = program.metadataTypes[outputUnit];
+
+    if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
+      jsAst.Expression metadataAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.METADATA);
+      jsAst.Expression typesAccess =
+          generateEmbeddedGlobalAccess(embeddedNames.TYPES);
+
+      output.addBuffer(
+          jsAst.prettyPrint(new jsAst.Block([
+              js.statement('# = #;', [metadataAccess,
+                                      constructList(program.metadata)]),
+              js.statement('# = #;', [typesAccess, constructList(types)])]),
+              compiler, monitor: compiler.dumpInfoTask));
+      output.add(n);
+    } else if (types != null) {
+      output.addBuffer(
+          jsAst.prettyPrint(
+              js.statement('var ${namer.deferredTypesName} = #;',
+                           constructList(types)),
+              compiler, monitor: compiler.dumpInfoTask));
+      output.add(n);
+    }
   }
 
   void emitCompileTimeConstants(CodeOutput output,
                                 List<Constant> constants,
                                 {bool isMainFragment}) {
     assert(isMainFragment != null);
 
     if (constants.isEmpty) return;
     CodeOutput constantOutput = output;
     if (compiler.hasIncrementalSupport && isMainFragment) {
@@ skipping 634 matching lines @@
           buildCspPrecompiledFunctionFor(mainOutputUnit);
       mainOutput.addBuffer(
           jsAst.prettyPrint(
               precompiledFunctionAst,
               compiler,
               monitor: compiler.dumpInfoTask,
               allowVariableMinification: false));
       mainOutput.add(N);
     }
 
-    mainOutput.add('$setupProgramName(dart)$N');
+    mainOutput.add('$setupProgramName(dart, 0)$N');
 
     interceptorEmitter.emitGetInterceptorMethods(mainOutput);
     interceptorEmitter.emitOneShotInterceptors(mainOutput);
 
     if (task.outputContainsConstantList) {
       emitMakeConstantList(mainOutput);
     }
 
     // Constants in checked mode call into RTI code to set type information
     // which may need getInterceptor (and one-shot interceptor) methods, so
@@ skipping 12 matching lines @@
     // constants to be set up.
     emitStaticNonFinalFieldInitializations(mainOutput, mainOutputUnit);
     interceptorEmitter.emitTypeToInterceptorMap(program, mainOutput);
     if (compiler.enableMinification) {
       mainOutput.add(';');
     }
     emitLazilyInitializedStaticFields(mainOutput);
 
     mainOutput.add('\n');
 
-    emitMetadata(program, mainOutput);
+    emitMetadata(program, mainOutput, mainOutputUnit);
 
     isolateProperties = isolatePropertiesName;
     // The following code should not use the short-hand for the
     // initialStatics.
     mainOutput.add('${namer.currentIsolate}$_=${_}null$N');
 
     emitFinishIsolateConstructorInvocation(mainOutput);
     mainOutput.add(
         '${namer.currentIsolate}$_=${_}new ${namer.isolateName}()$N');
 
@@ skipping 384 matching lines @@
         output
             .add('var $globalObject$_=$_'
                      '${globalsHolder}.$globalObject$N');
       }
       output
           ..add('var init$_=$_${globalsHolder}.init$N')
           ..add('var $setupProgramName$_=$_'
                     '$globalsHolder.$setupProgramName$N')
           ..add('var ${namer.isolateName}$_=$_'
                     '${globalsHolder}.${namer.isolateName}$N');
+      String typesAccess =
+          generateEmbeddedGlobalAccessString(embeddedNames.TYPES);
       if (libraryDescriptorBuffer != null) {
         // TODO(ahe): This defines a lot of properties on the
         // Isolate.prototype object.  We know this will turn it into a
         // slow object in V8, so instead we should do something similar
         // to Isolate.$finishIsolateConstructor.
         output
             ..add('var ${namer.currentIsolate}$_=$_$isolatePropertiesName$N')
             // The argument to reflectionDataParser is assigned to a temporary
             // 'dart' so that 'dart.' will appear as the prefix to dart methods
             // in stack traces and profile entries.
             ..add('var dart = [$n ')
             ..addBuffer(libraryDescriptorBuffer)
             ..add(']$N');
 
         if (compiler.useContentSecurityPolicy) {
           jsAst.Statement precompiledFunctionAst =
               buildCspPrecompiledFunctionFor(outputUnit);
 
           output.addBuffer(
               jsAst.prettyPrint(
                   precompiledFunctionAst, compiler,
                   monitor: compiler.dumpInfoTask,
                   allowVariableMinification: false));
           output.add(N);
         }
-        output.add('$setupProgramName(dart)$N');
+        output.add('$setupProgramName(dart, ${typesAccess}.length)$N');
+      }
+
+      if (task.metadataCollector.types[outputUnit] != null) {
+        emitMetadata(program, output, outputUnit);
+        output.add('${typesAccess}.'
+                   'push.apply(${typesAccess},$_${namer.deferredTypesName})$N');
       }
 
       // Set the currentIsolate variable to the current isolate (which is
       // provided as second argument).
       // We need to do this, because we use the same variable for setting up
       // the isolate-properties and for storing the current isolate. During
       // the setup (the code above this lines) we must set the variable to
       // the isolate-properties.
       // After we have done the setup it must point to the current Isolate.
       // Otherwise all methods/functions accessing isolate variables will
@@ skipping 89 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }