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 553 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');
-   }
+    addMetadata(List<String> list, String listAccess) {
+      output.add('$listAccess$_=$_[');
+      if (list != null) {
+        for (String data in list) {
+          if (data is String) {
+            if (data != 'null') {
+              output.add(data);
+            }
+          } else {
+            throw 'Unexpected value in ${listAccess}: '

[sigurdm, 2015/04/09 13:00:15]

Make this an assert

[zarah, 2015/04/10 10:56:03]

Changed the code. See below.

+                  '${Error.safeToString(data)}';
+          }
+          output.add(',$n');
+        }
+      }
+      output.add('];$n');

[sigurdm, 2015/04/09 13:00:15]

Again here you could let listaccess be a js-expression and then first build the
list and then do something like:
output.add(js.prettyPrint(js.js.statement("# = #;", listAccess, list),
compiler));

[zarah, 2015/04/10 10:56:03]

Done.

+    }
 
-   addMetadataGlobal(program.metadata, embeddedNames.METADATA);
-   addMetadataGlobal(program.metadataTypes, embeddedNames.TYPES);
+    List<String> types = program.metadataTypes[outputUnit];
+    List<String> metadata = program.metadata;
+
+    if (outputUnit == compiler.deferredLoadTask.mainOutputUnit) {
+      addMetadata(metadata,
+                  generateEmbeddedGlobalAccessString(embeddedNames.METADATA));
+      addMetadata(types,
+                  generateEmbeddedGlobalAccessString(embeddedNames.TYPES));
+    } else {
+      if (types != null) {
+       addMetadata(types, 'var ${namer.deferredTypesName}');
+      }
+    }
   }
 
   void emitCompileTimeConstants(CodeOutput output,
                                 List<Constant> constants,
                                 {bool isMainFragment}) {
     assert(isMainFragment != null);
 
     if (constants.isEmpty) return;
     CodeOutput constantOutput = output;
     if (compiler.hasIncrementalSupport && isMainFragment) {
@@ skipping 648 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
     // we have to make sure that [emitGetInterceptorMethods] and
     // [emitOneShotInterceptors] have been called.
     emitCompileTimeConstants(
         mainOutput, mainFragment.constants, isMainFragment: true);
 
     emitDeferredBoilerPlate(mainOutput, deferredLoadHashes);
 
     if (compiler.deferredMapUri != null) {
       outputDeferredMap();
     }
 
     // Static field initializations require the classes and compile-time
     // constants to be set up.
     emitStaticNonFinalFieldInitializations(mainOutput, mainOutputUnit);
     interceptorEmitter.emitTypeToInterceptorMap(program, mainOutput);
     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 385 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);
 
       }
     }
   }
 }