dart2js: fix deferred loading in the new emitter.

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 '../../dart2jslib.dart' show Compiler;
 import '../../dart_types.dart' show DartType;
 import '../../elements/elements.dart' show ClassElement;
 import '../../js/js.dart' as js;
 import '../../js_backend/js_backend.dart' show
     JavaScriptBackend,
     Namer,
     ConstantEmitter;
 
 import '../js_emitter.dart' show
     NativeEmitter;
 
 import 'package:_internal/compiler/js_lib/shared/embedded_names.dart' show
+    CREATE_NEW_ISOLATE,
     DEFERRED_LIBRARY_URIS,
     DEFERRED_LIBRARY_HASHES,
     GET_TYPE_FROM_NAME,
     INITIALIZE_LOADED_HUNK,
     INTERCEPTORS_BY_TAG,
     IS_HUNK_INITIALIZED,
     IS_HUNK_LOADED,
     LEAF_TAGS,
     MANGLED_GLOBAL_NAMES,
     METADATA,
@@ skipping 24 matching lines @@
             new ConstantEmitter(compiler, namer, makeConstantListTemplate);
 
   js.Expression generateEmbeddedGlobalAccess(String global) {
     // TODO(floitsch): We should not use "init" for globals.
     return js.js("init.$global");
   }
 
   int emitProgram(Program program) {
     List<Fragment> fragments = program.fragments;
     MainFragment mainFragment = fragments.first;
-    js.Statement mainAst = emitMainFragment(program);
-    String mainCode = js.prettyPrint(mainAst, compiler).getText();
-    compiler.outputProvider(mainFragment.outputFileName, 'js')
-        ..add(buildGeneratedBy(compiler))
-        ..add(mainCode)
-        ..close();
-    int totalSize = mainCode.length;
 
+    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, mainFragment.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')
+        ..add(buildGeneratedBy(compiler))
+        ..add(mainCode)
+        ..close();
+    totalSize += mainCode.length;
+
     return totalSize;
   }
 
-  js.LiteralString unparse(Compiler compiler, js.Expression value) {
+  js.LiteralString unparse(Compiler compiler, js.Node value) {
     String text = js.prettyPrint(value, compiler).getText();
     if (value is js.Fun) text = '($text)';
     return js.js.escapedString(text);
   }
 
   String buildGeneratedBy(compiler) {
     var suffix = '';
     if (compiler.hasBuildId) suffix = ' version: ${compiler.buildId}';
     return '// Generated by dart2js, the Dart to JavaScript compiler$suffix.\n';
   }
@@ skipping 98 matching lines @@
   static js.Template get makeConstantListTemplate {
     // TODO(floitsch): remove hard-coded name.
     // TODO(floitsch): there is no harm in caching the template.
     return js.js.uncachedExpressionTemplate('makeConstList(#)');
   }
 
   js.Block emitEmbeddedGlobals(Program program) {
     List<js.Property> globals = <js.Property>[];
 
     if (program.loadMap.isNotEmpty) {
-      globals.addAll(emitLoadUrisAndHashes(program.loadMap));
-      globals.add(emitIsHunkLoadedFunction());
-      globals.add(emitInitializeLoadedHunk());
+      globals.addAll(emitEmbeddedGlobalsForDeferredLoading(program.loadMap));
     }
 
     if (program.typeToInterceptorMap != null) {
       globals.add(new js.Property(js.string(TYPE_TO_INTERCEPTOR_MAP),
                                   program.typeToInterceptorMap));
     }
 
+    if (program.hasIsolateSupport) {
+      String isolateName = namer.currentIsolate;
+      globals.add(
+          new js.Property(js.string(CREATE_NEW_ISOLATE),
+                          js.js('function () { return $isolateName; }')));
+      // TODO(floitsch): add remaining isolate functions.
+    }
+
     globals.add(emitMangledGlobalNames());
 
     globals.add(emitGetTypeFromName());
 
     globals.add(emitMetadata(program));
 
     if (program.outputContainsNativeClasses) {
       globals.add(new js.Property(js.string(INTERCEPTORS_BY_TAG),
                                   js.js('Object.create(null)', [])));
       globals.add(new js.Property(js.string(LEAF_TAGS),
@@ skipping 22 matching lines @@
          compiler.listClass];
     nativeClassesNeedingUnmangledName.forEach((element) {
         names.add(new js.Property(js.string(namer.getNameOfClass(element)),
                                   js.string(element.name)));
     });
 
     return new js.Property(js.string(MANGLED_GLOBAL_NAMES),
                            new js.ObjectInitializer(names));
   }
 
-  List<js.Property> emitLoadUrisAndHashes(Map<String, List<Fragment>> loadMap) {
-    js.ArrayInitializer outputUris(List<Fragment> fragments) {
+  js.Statement emitDeferredInitializerGlobal(Map loadMap) {
+    if (loadMap.isEmpty) return new js.Block.empty();
+
+    return js.js.statement("""
+  if (typeof($deferredInitializersGlobal) === 'undefined')
+    var $deferredInitializersGlobal = Object.create(null);""");
+  }
+
+  Iterable<js.Property> emitEmbeddedGlobalsForDeferredLoading(
+      Map<String, List<Fragment>> loadMap) {
+
+    List<js.Property> globals = <js.Property>[];
+
+    js.ArrayInitializer fragmentUris(List<Fragment> fragments) {
       return js.stringArray(fragments.map((DeferredFragment fragment) =>
-          "${fragment.outputFileName}$deferredExtension"));
+          "${fragment.outputFileName}.$deferredExtension"));
     }
-    js.ArrayInitializer outputHashes(List<Fragment> fragments) {
+    js.ArrayInitializer fragmentHashes(List<Fragment> fragments) {
       // TODO(floitsch): the hash must depend on the generated code.
       return js.numArray(
           fragments.map((DeferredFragment fragment) => fragment.hashCode));
     }
 
     List<js.Property> uris = new List<js.Property>(loadMap.length);
     List<js.Property> hashes = new List<js.Property>(loadMap.length);
     int count = 0;
     loadMap.forEach((String loadId, List<Fragment> fragmentList) {
       uris[count] =
-          new js.Property(js.string(loadId), outputUris(fragmentList));
+          new js.Property(js.string(loadId), fragmentUris(fragmentList));
       hashes[count] =
-          new js.Property(js.string(loadId), outputHashes(fragmentList));
+          new js.Property(js.string(loadId), fragmentHashes(fragmentList));
       count++;
     });
 
-    return <js.Property>[
-         new js.Property(js.string(DEFERRED_LIBRARY_URIS),
-                         new js.ObjectInitializer(uris)),
-         new js.Property(js.string(DEFERRED_LIBRARY_HASHES),
-                         new js.ObjectInitializer(hashes))
-         ];
-  }
+    globals.add(new js.Property(js.string(DEFERRED_LIBRARY_URIS),
+                                new js.ObjectInitializer(uris)));
+    globals.add(new js.Property(js.string(DEFERRED_LIBRARY_HASHES),
+                                new js.ObjectInitializer(hashes)));
 
-  js.Statement emitDeferredInitializerGlobal(Map loadMap) {
-    if (loadMap.isEmpty) return new js.Block.empty();
+    js.Expression isHunkLoadedFunction =
+        js.js("function(hash) { return !!$deferredInitializersGlobal[hash]; }");
+    globals.add(new js.Property(js.string(IS_HUNK_LOADED),
+                                isHunkLoadedFunction));
 
-    return js.js.statement("""
-  if (typeof($deferredInitializersGlobal) === 'undefined')
-    var $deferredInitializersGlobal = Object.create(null);""");
-  }
+    js.Expression isHunkInitializedFunction =
+        js.js("function(hash) { return false; }");
+    globals.add(new js.Property(js.string(IS_HUNK_INITIALIZED),
+                                isHunkInitializedFunction));
 
-  js.Property emitIsHunkLoadedFunction() {
-    js.Expression function =
-        js.js("function(hash) { return !!$deferredInitializersGlobal[hash]; }");
-    return new js.Property(js.string(IS_HUNK_LOADED), function);
-  }
+    /// See [emitEmbeddedGlobalsForDeferredLoading] for the format of the
+    /// deferred hunk.
+    js.Expression initializeLoadedHunkFunction =
+        js.js("""
+          function(hash) {
+            var hunk = $deferredInitializersGlobal[hash];
+            $setupProgramName(hunk[0]);
+            eval(hunk[1]);
+          }""");
 
-  js.Property emitInitializeLoadedHunk() {
-    js.Expression function =
-        js.js("function(hash) { eval($deferredInitializersGlobal[hash]); }");
-    return new js.Property(js.string(INITIALIZE_LOADED_HUNK), function);
+    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);
   }
 
   js.Property emitMetadata(Program program) {
     String metadataList = "[${program.metadata.join(",")}]";
     js.Expression metadata =
         js.js.uncachedExpressionTemplate(metadataList).instantiate([]);
 
     return new js.Property(js.string(METADATA), metadata);
   }
 
   js.Expression emitDeferredFragment(DeferredFragment fragment,
                                      List<Holder> holders) {
     // TODO(floitsch): initialize eager classes.
     // TODO(floitsch): the hash must depend on the output.
-    int hash = this.hashCode;
-    if (fragment.constants.isNotEmpty) {
-      throw new UnimplementedError("constants in deferred units");
-    }
-    js.ArrayInitializer content =
-        new js.ArrayInitializer(fragment.libraries.map(emitLibrary)
-                                                  .toList(growable: false));
-    return js.js("$deferredInitializersGlobal[$hash] = #", content);
+    int hash = fragment.hashCode;
+
+    List<js.Expression> deferredCode =
+        fragment.libraries.map(emitLibrary).toList();
+
+    deferredCode.add(
+        emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
+
+    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 = js.js.statement('''{
+          #constants;
+          #eagerClasses;
+        }''',
+        {'constants': emitConstants(fragment.constants),
+         'eagerClasses': emitEagerClassInitializations(fragment.libraries)});
+
+    js.LiteralString immediateString = unparse(compiler, immediateCode);
+    js.ArrayInitializer hunk =
+        new js.ArrayInitializer([deferredArray, immediateString]);
+
+    return js.js("$deferredInitializersGlobal[$hash] = #", hunk);
   }
 
   js.Block emitConstants(List<Constant> constants) {
     Iterable<js.Statement> statements = constants.map((Constant constant) {
       js.Expression code =
           constantEmitter.initializationExpression(constant.value);
       return js.js.statement("#.# = #;",
                              [constant.holder.name, constant.name, code]);
     });
     return new js.Block(statements.toList());
@@ skipping 309 matching lines @@
         data.addAll(method.parameterStubs.expand(makeNameCallNameCodeTriplet));
         return [js.string(method.name), holderIndex,
                 new js.ArrayInitializer(data)];
       } else {
         method.parameterStubs.forEach(_addMethod);
       }
     }
     return output;
   }
 
+  static final String setupProgramName = "setupProgram";
+
   static final String boilerplate = """
 {
 // Declare deferred-initializer global.
 #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 setupProgram() {
+  function $setupProgramName(program) {
     for (var i = 0; i < program.length - 1; i++) {
       setupLibrary(program[i]);
     }
     setupLazyStatics(program[i]);
   }
 
   function setupLibrary(library) {
     var statics = library[0];
     for (var i = 0; i < statics.length; i += 3) {
       var holderIndex = statics[i + 1];
@@ skipping 212 matching lines @@
   if (#hasNativeClasses) {
     function handleNativeClassInfos() {
       for (var nativeClass in nativeInfos) {
         var constructor = holdersMap[nativeClass][nativeClass].ensureResolved();
         var nativeInfo = nativeInfos[nativeClass];
         #nativeInfoHandler;
       }
     }
   }
 
-  setupProgram();
+  $setupProgramName(program);
 
   // Initialize constants.
   #constants;
 
   // 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 (#hasNativeClasses) 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.');
+  // print('Setup: ' + (end - start) + ' ms.');

[zarah, 2015/02/10 15:05:24]

Why comment it out?

[floitsch, 2015/02/10 15:13:34]

Because it doesn't work in the browser.

 
   #invokeMain;  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }