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

pkg/compiler/lib/src/js_emitter/new_emitter/model_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.
 
 library dart2js.new_js_emitter.model_emitter;
 
 import '../../constants/values.dart' show ConstantValue, FunctionConstantValue;
 import '../../dart2jslib.dart' show Compiler;
 import '../../dart_types.dart' show DartType;
 import '../../elements/elements.dart' show ClassElement, FunctionElement;
@@ skipping 50 matching lines @@
     this.constantEmitter = new ConstantEmitter(
         compiler, namer, this.generateConstantReference,
         makeConstantListTemplate);
   }
 
   js.Expression generateEmbeddedGlobalAccess(String global) {
     // TODO(floitsch): We should not use "init" for globals.
     return js.js("init.$global");
   }
 
+  String generateEmbeddedGlobalAccessString(String global) {
+    // TODO(floitsch): We should not use "init" for globals.
+    return "init.$global";
+  }
+
   bool isConstantInlinedOrAlreadyEmitted(ConstantValue constant) {
     if (constant.isFunction) return true;    // Already emitted.
     if (constant.isPrimitive) return true;   // Inlined.
     if (constant.isDummy) return true;       // Inlined.
     // The name is null when the constant is already a JS constant.
     // TODO(floitsch): every constant should be registered, so that we can
     // share the ones that take up too much space (like some strings).
     if (namer.constantName(constant) == null) return true;
     return false;
   }
@@ skipping 44 matching lines @@
   int emitProgram(Program program) {
     List<Fragment> fragments = program.fragments;
     MainFragment mainFragment = fragments.first;
 
     int totalSize = 0;
 
     // We have to emit the deferred fragments first, since we need their
     // deferred hash (which depends on the output) when emitting the main
     // fragment.
     fragments.skip(1).forEach((DeferredFragment deferredUnit) {
-      js.Expression ast = emitDeferredFragment(deferredUnit, program.holders);
+      List<String> types = program.metadataTypes[deferredUnit.outputUnit];
+      js.Expression ast = emitDeferredFragment(types, deferredUnit,
+                                               program.holders);
       String code = js.prettyPrint(ast, compiler).getText();
       totalSize += code.length;
       compiler.outputProvider(deferredUnit.outputFileName, deferredExtension)
           ..add(code)
           ..close();
     });
 
     js.Statement mainAst = emitMainFragment(program);
     String mainCode = js.prettyPrint(mainAst, compiler).getText();
     compiler.outputProvider(mainFragment.outputFileName, 'js')
@@ skipping 231 matching lines @@
     js.Expression isHunkLoadedFunction =
         js.js("function(hash) { return !!$deferredInitializersGlobal[hash]; }");
     globals.add(new js.Property(js.string(IS_HUNK_LOADED),
                                 isHunkLoadedFunction));
 
     js.Expression isHunkInitializedFunction =
         js.js("function(hash) { return false; }");
     globals.add(new js.Property(js.string(IS_HUNK_INITIALIZED),
                                 isHunkInitializedFunction));
 
+    String typesAccess = generateEmbeddedGlobalAccessString(TYPES);
+
     /// See [emitEmbeddedGlobalsForDeferredLoading] for the format of the
     /// deferred hunk.
     js.Expression initializeLoadedHunkFunction =
         js.js("""
           function(hash) {
             var hunk = $deferredInitializersGlobal[hash];
-            $setupProgramName(hunk[0]);
+            $setupProgramName(hunk[0], ${typesAccess}.length);

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

Why not 

  $setupProgramName(hunk[0], #typesAccess.length);

and then let typesAccess be a js_ast expression?
That would eliminate the need for `generateEmbeddedGlobalAccessString`

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

Done.

             eval(hunk[1]);
+            var deferredTypes = eval(hunk[2]);
+            ${typesAccess}.push.apply(${typesAccess}, deferredTypes);
           }""");
 
     globals.add(new js.Property(js.string(INITIALIZE_LOADED_HUNK),
                                 initializeLoadedHunkFunction));
 
     return globals;
   }
 
   js.Property emitGetTypeFromName() {
     js.Expression function =
         js.js( """function(name) {
                     return holdersMap[name][name].ensureResolved();
                   }""");
     return new js.Property(js.string(GET_TYPE_FROM_NAME), function);
   }
 
   List<js.Property> emitMetadata(Program program) {
 
     List<js.Property> metadataGlobals = <js.Property>[];
 
     js.Property createGlobal(List<String> list, String global) {
       String listAsString = "[${list.join(",")}]";
       js.Expression metadata =
                 js.js.uncachedExpressionTemplate(listAsString).instantiate([]);
       return new js.Property(js.string(global), metadata);
     }
 
     metadataGlobals.add(createGlobal(program.metadata, METADATA));
-    metadataGlobals.add(createGlobal(program.metadataTypes, TYPES));
+    List<String> types =
+        program.metadataTypes[program.fragments.first.outputUnit];
+    if (types == null) types = <String>[];
+    metadataGlobals.add(createGlobal(types, TYPES));
 
     return metadataGlobals;
   }
 
-  js.Expression emitDeferredFragment(DeferredFragment fragment,
+  js.Expression emitDeferredFragment(List<String> types,
+                                     DeferredFragment fragment,
                                      List<Holder> holders) {
     // TODO(floitsch): initialize eager classes.
     // TODO(floitsch): the hash must depend on the output.
     int hash = fragment.hashCode;
 
     List<js.Expression> deferredCode =
         fragment.libraries.map(emitLibrary).toList();
 
     deferredCode.add(
         emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
 
     deferredCode.add(emitConstants(fragment.constants));
 
     js.ArrayInitializer deferredArray = new js.ArrayInitializer(deferredCode);
 
     // This is the code that must be evaluated after all deferred classes have
     // been setup.
     js.Statement immediateCode =
         emitEagerClassInitializations(fragment.libraries);
 
     js.LiteralString immediateString = unparse(compiler, immediateCode);
+
+    js.Expression deferredTypes = types == null
+        ? js.string("[]")
+        : js.string("[${types.join(",")}]");
+
     js.ArrayInitializer hunk =
-        new js.ArrayInitializer([deferredArray, immediateString]);
+        new js.ArrayInitializer([deferredArray, immediateString,
+                                 deferredTypes]);
 
     return js.js("$deferredInitializersGlobal[$hash] = #", hunk);
   }
 
   // This string should be referenced wherever JavaScript code makes assumptions
   // on the constants format.
   static final String constantsDescription =
       "The constants are encoded as a follows:"
       "   [constantsHolderIndex, name, code, name2, code2, ...]."
       "The array is completely empty if there is no constant at all.";
@@ skipping 194 matching lines @@
   ///
   /// for each stub in [DartMethod.parameterStubs].
   ///
   /// If the closure could be used in `Function.apply` (i.e.
   /// [DartMethod.canBeApplied] is true) then the following fields are appended:
   ///
   /// * [DartMethod.requiredParameterCount]
   /// * [DartMethod.optionalParameterDefaultValues]
 
   static final String parseFunctionDescriptorBoilerplate = r"""
-function parseFunctionDescriptor(proto, name, descriptor) {
+function parseFunctionDescriptor(proto, name, descriptor, typesOffset) {
   if (descriptor instanceof Array) {
     // 'pos' points to the last read entry.
     var f, pos = -1;
     var aliasOrFunction = descriptor[++pos];
     if (typeof aliasOrFunction == "string") {
       // Install the alias for super calls on the prototype chain.
       proto[aliasOrFunction] = f = descriptor[++pos];
     } else {
       f = aliasOrFunction;
     }
 
     proto[name] = f;
     var funs = [f];
     f[#callName] = descriptor[++pos];
 
     var isInterceptedOrParameterStubName = descriptor[pos + 1];
     var isIntercepted, tearOffName, reflectionInfo;
     if (typeof isInterceptedOrParameterStubName == "boolean") {
       isIntercepted = descriptor[++pos];
       tearOffName = descriptor[++pos];
       reflectionInfo = descriptor[++pos];
+      if (typeof reflectionInfo == "number") {
+        reflectionInfo = reflectionInfo + typesOffset;
+      }
     }
 
     // We iterate in blocks of 3 but have to stop before we reach the (optional)
     // two trailing items. To accomplish this, we only iterate until we reach
     // length - 2.
     for (++pos; pos < descriptor.length - 2; pos += 3) {
       var stub = descriptor[pos + 2];
       stub[#callName] = descriptor[pos + 1];
       proto[descriptor[pos]] = stub;
       funs.push(stub);
@@ skipping 134 matching lines @@
 #deferredInitializer;
 
 !function(start, program) {
   // Initialize holder objects.
   #holders;
   var nativeInfos = Object.create(null);
 
   // Counter to generate unique names for tear offs.
   var functionCounter = 0;
 
-  function $setupProgramName(program) {
+  function $setupProgramName(program, typesOffset) {
     for (var i = 0; i < program.length - 2; i++) {
-      setupLibrary(program[i]);
+      setupLibrary(program[i], typesOffset);
     }
     setupLazyStatics(program[i]);
     setupConstants(program[i + 1]);
   }
 
-  function setupLibrary(library) {
+  function setupLibrary(library, typesOffset) {
     var statics = library[0];
     for (var i = 0; i < statics.length; i += 3) {
       var holderIndex = statics[i + 1];
-      setupStatic(statics[i], holders[holderIndex], statics[i + 2]);
+      setupStatic(statics[i], holders[holderIndex], statics[i + 2],
+                  typesOffset);
     }
 
     var classes = library[1];
     for (var i = 0; i < classes.length; i += 3) {
       var name = classes[i];
       var cls = classes[i + 1];
 
       if (#needsNativeSupport) {
         // $nativeInfoDescription.
         var indexOrNativeInfo = classes[i + 2];
         if (typeof indexOrNativeInfo == "number") {
           var holderIndex = classes[i + 2];
         } else {
           nativeInfos[name] = indexOrNativeInfo;
           holderIndex = classes[i + 3];
           i++;
         }
       }
 
       if (#needsNoNativeSupport) {
         var holderIndex = classes[i + 2];
       }
 
       holdersMap[name] = holders[holderIndex];
-      setupClass(name, holders[holderIndex], cls);
+      setupClass(name, holders[holderIndex], cls, typesOffset);
     }
   }
 
   function setupLazyStatics(statics) {
     for (var i = 0; i < statics.length; i += 4) {
       var name = statics[i];
       var getterName = statics[i + 1];
       var holderIndex = statics[i + 2];
       var initializer = statics[i + 3];
       setupLazyStatic(name, getterName, holders[holderIndex], initializer);
     }
   }
 
   function setupConstants(constants) {
     // $constantsDescription.
     if (constants.length == 0) return;
     // We assume that all constants are in the same holder.
     var holder = holders[constants[0]];
     for (var i = 1; i < constants.length; i += 2) {
       var name = constants[i];
       var initializer = constants[i + 1];
       setupConstant(name, holder, initializer);
     }
   }
 
-  function setupStatic(name, holder, descriptor) {
+  function setupStatic(name, holder, descriptor, typesOffset) {
     if (typeof descriptor == 'string') {
       holder[name] = function() {
         if (descriptor == null) {
           // Already compiled. This happens when we have calls to the static as
           // arguments to the static: `foo(foo(499))`;
           return holder[name].apply(this, arguments);
         }
         var method = compile(name, descriptor);
         holder[name] = method;
         descriptor = null;  // GC the descriptor.
         return method.apply(this, arguments);
       };
     } else {
       // Parse the tear off information and generate compile handlers.
       // TODO(herhut): Share parser with instance methods.      
-      function compileAllStubs() {
+      function compileAllStubs(typesOffset) {
         var funs;
         var fun = compile(name, descriptor[0]);
         fun[#callName] = descriptor[1];
         holder[name] = fun;
         funs = [fun];
         // We iterate in blocks of 3 but have to stop before we reach the
         // (optional) two trailing items. To accomplish this, we only iterate
         // until we reach length - 2.
         for (var pos = 4; pos < descriptor.length - 2; pos += 3) {
           var stubName = descriptor[pos];
           fun = compile(stubName, descriptor[pos + 2]);
           fun[#callName] = descriptor[pos + 1];
           holder[stubName] = fun;
           funs.push(fun);
         }
         if (descriptor[2] != null) {  // tear-off name.
           // functions, reflectionInfo, isStatic, name, isIntercepted.
+          var reflectionInfo = descriptor[3];
+          if (typeof reflectionInfo == "number") {
+            reflectionInfo = reflectionInfo + typesOffset;
+          }
           holder[descriptor[2]] = 
-              tearOff(funs, descriptor[3], true, name, false);
+              tearOff(funs, reflectionInfo, true, name, false);
         }
         if (pos < descriptor.length) {
           fun[#argumentCount] = descriptor[pos];
           fun[#defaultArgumentValues] = descriptor[pos + 1];
         }
       }
 
-      function setupCompileAllAndDelegateStub(name) {
+      function setupCompileAllAndDelegateStub(name, typesOffset) {
         holder[name] = function() {
           // The descriptor is null if we already compiled this function. This
           // happens when we have calls to the static as arguments to the
           // static: `foo(foo(499))`;
           if (descriptor != null) {
-            compileAllStubs();
+            compileAllStubs(typesOffset);
             descriptor = null;  // GC the descriptor.
           }
           return holder[name].apply(this, arguments);
         };
       }
 
-      setupCompileAllAndDelegateStub(name);
+      setupCompileAllAndDelegateStub(name, typesOffset);
       for (var pos = 4; pos < descriptor.length; pos += 3) {
-        setupCompileAllAndDelegateStub(descriptor[pos]);
+        setupCompileAllAndDelegateStub(descriptor[pos], typesOffset);
       }
       if (descriptor[2] != null) {  // tear-off name.
-        setupCompileAllAndDelegateStub(descriptor[2])
+        setupCompileAllAndDelegateStub(descriptor[2], typesOffset)
       }
     }
   }
 
   function setupLazyStatic(name, getterName, holder, descriptor) {
     holder[name] = null;
     holder[getterName] = function() {
       var initializer = compile(name, descriptor);
       holder[getterName] = function() { #cyclicThrow(name) };
       var result;
@@ skipping 22 matching lines @@
     holder[name] = function() {
       if (descriptor !== null) {
         c = compile(name, descriptor);
         name = null;
         descriptor = null;
       }
       return c;
     };
   }
 
-  function setupClass(name, holder, descriptor) {
+  function setupClass(name, holder, descriptor, typesOffset) {
     var patch = function() {
       if (patch.ensureResolved == patch) {
         // We have not yet been compiled.
-        var constructor = compileConstructor(name, descriptor);
+        var constructor = compileConstructor(name, descriptor, typesOffset);
         holder[name] = constructor;
         name = holder = descriptor = null;  // GC the captured arguments.
         // Make sure we can invoke 'ensureResolved' multiple times on the patch
         // function.
         patch.ensureResolved = function() { return constructor; };
         constructor.ensureResolved = function() { return this; };
       } else {
         // This can happen when arguments to the constructor are of the same
         // class, like in `new A(new A(null))`.
         constructor = patch.ensureResolved();
       }
       // If the patch has been called as "ensureResolved" return.
       if (this === patch) return constructor;
       var object = new constructor();
       constructor.apply(object, arguments);
       return object;
     };
 
     // We store the patch function on itself to make it
     // possible to resolve superclass references without constructing instances.
     patch.ensureResolved = patch;
     holder[name] = patch;
   }
 
   #tearOff;
 
   #parseFunctionDescriptor;
 
-  function compileConstructor(name, descriptor) {
+  function compileConstructor(name, descriptor, typesOffset) {
     descriptor = compile(name, descriptor);
     var prototype = determinePrototype(descriptor);
     var constructor;
     var functionsIndex;
     // $mixinFormatDescription.
     if (typeof descriptor[2] !== 'function') {
       fillPrototypeWithMixedIn(descriptor[2], descriptor[3], prototype);
       // descriptor[4] contains the constructor if the mixin application is
       // directly instantiated.
       if (typeof descriptor[4] === 'function') {
         constructor = descriptor[4];
         functionsIndex = 5;
       } else {
         constructor = function() {};
         functionsIndex = 4;
       }
     } else {
       constructor = descriptor[2];
       functionsIndex = 3;
     }
 
     for (var i = functionsIndex; i < descriptor.length; i += 2) {
-      parseFunctionDescriptor(prototype, descriptor[i], descriptor[i + 1]);
+      parseFunctionDescriptor(prototype, descriptor[i], descriptor[i + 1],
+                              typesOffset);
     }
 
     constructor.builtin\$cls = name;  // Needed for RTI.
     constructor.prototype = prototype;
     prototype[#operatorIsPrefix + name] = constructor;
     prototype.constructor = constructor;
     return constructor;
   }
 
   function fillPrototypeWithMixedIn(mixinName, mixinHolderIndex, prototype) {
@@ skipping 43 matching lines @@
   if (#needsNativeSupport) {
     function handleNativeClassInfos() {
       for (var nativeClass in nativeInfos) {
         var constructor = holdersMap[nativeClass][nativeClass].ensureResolved();
         var nativeInfo = nativeInfos[nativeClass];
         #nativeInfoHandler;
       }
     }
   }
 
-  $setupProgramName(program);
+  $setupProgramName(program, 0);
 
   // Initialize globals.
   #embeddedGlobals;
 
   // TODO(floitsch): this order means that native classes may not be
   // referenced from constants. I'm mostly afraid of things like using them as
   // generic arguments (which should be fine, but maybe there are other
   // similar things).
   // Initialize natives.
   if (#needsNativeSupport) handleNativeClassInfos();
 
   // Initialize static non-final fields.
   #staticNonFinals;
 
   // Add native boilerplate code.
   #nativeIsolateAffinityTagInitialization;
 
   // Initialize eager classes.
   #eagerClasses;
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }