dart2js: Use the correct hashes for deferred code in the startup-emitter.

pkg/compiler/lib/src/js_emitter/startup_emitter/fragment_emitter.dart

 // Copyright (c) 2015, 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.startup_emitter.model_emitter;
 
 /// The fast startup emitter's goal is to minimize the amount of work that the
 /// JavaScript engine has to do before it can start running user code.
 ///
 /// Whenever possible, the emitter uses object literals instead of updating
@@ skipping 245 matching lines @@
 #invokeMain;
 })();
 }''';
 
 /// Deferred fragments (aka 'hunks') are built similarly to the main fragment.
 ///
 /// However, at specific moments they need to contribute their data.
 /// For example, once the holders have been created, they are included into
 /// the main holders.
 const String deferredBoilerplate = '''
-{
-#deferredInitializers.current =
 function(inherit, mixin, lazy, makeConstList, installTearOff,
           updateHolder, updateTypes,
           setOrUpdateInterceptorsByTag, setOrUpdateLeafTags,
           #embeddedGlobalsObject, holdersList, #staticState) {
 
 // Builds the holders. They only contain the data for new holders.
 #holders;
 // Updates the holders of the main-fragment. Uses the provided holdersList to
 // access the main holders.
 // The local holders are replaced by the combined holders. This is necessary
@@ skipping 14 matching lines @@
 #constants;
 // Initializes the static non-final fields (with their constant values).
 #staticNonFinalFields;
 // Creates lazy getters for statics that must run initializers on first access.
 #lazyStatics;
 
 updateTypes(#types);
 
 // Native-support uses setOrUpdateInterceptorsByTag and setOrUpdateLeafTags.
 #nativeSupport;
-};
-// TODO(floitsch): this last line should be outside the AST, since it
-// requires to know the hash of the part of the code above this comment.
-#deferredInitializers[#hash] = #deferredInitializers.current;
 }''';
 
 /**
  * This class builds a JavaScript tree for a given fragment.
  *
  * A fragment is generally written into a separate file so that it can be
  * loaded dynamically when a deferred library is loaded.
  *
  * This class is stateless and can be reused for different fragments.
  */
@@ skipping 10 matching lines @@
   js.Expression generateEmbeddedGlobalAccess(String global) =>
       modelEmitter.generateEmbeddedGlobalAccess(global);
 
   js.Expression generateConstantReference(ConstantValue value) =>
       modelEmitter.generateConstantReference(value);
 
   js.Expression classReference(Class cls) {
     return js.js('#.#', [cls.holder.name, cls.name]);
   }
 
-  js.Statement emitMainFragment(Program program) {
+  js.Statement emitMainFragment(
+      Program program,
+      Map<DeferredFragment, _DeferredFragmentHash> deferredLoadHashes) {
     MainFragment fragment = program.fragments.first;
 
     return js.js.statement(mainBoilerplate,
         {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
          'typeNameProperty': js.string(ModelEmitter.typeNameProperty),
          'cyclicThrow': backend.emitter.staticFunctionAccess(
                  backend.getCyclicThrowHelper()),
          'operatorIsPrefix': js.string(namer.operatorIsPrefix),
          'tearOffCode': new js.Block(buildTearOffCode(backend)),
          'embeddedTypes': generateEmbeddedGlobalAccess(TYPES),
@@ skipping 11 matching lines @@
          'callName': js.string(namer.callNameField),
          'argumentCount': js.string(namer.requiredParameterField),
          'defaultArgumentValues': js.string(namer.defaultValuesField),
          'prototypes': emitPrototypes(fragment),
          'inheritance': emitInheritance(fragment),
          'aliases': emitInstanceMethodAliases(fragment),
          'tearOffs': emitInstallTearOffs(fragment),
          'constants': emitConstants(fragment),
          'staticNonFinalFields': emitStaticNonFinalFields(fragment),
          'lazyStatics': emitLazilyInitializedStatics(fragment),
-         'embeddedGlobals': emitEmbeddedGlobals(program),
+         'embeddedGlobals': emitEmbeddedGlobals(program, deferredLoadHashes),
          'nativeSupport': program.needsNativeSupport
               ? emitNativeSupport(fragment)
               : new js.EmptyStatement(),
          'invokeMain': fragment.invokeMain,
          });
   }
 
-  js.Statement emitDeferredFragment(DeferredFragment fragment,
+  js.Expression emitDeferredFragment(DeferredFragment fragment,
                                     js.Expression deferredTypes,
                                     List<Holder> holders) {
     List<js.Statement> updateHolderAssignments = <js.Statement>[];
     for (int i = 0; i < holders.length; i++) {
       Holder holder = holders[i];
       if (holder.isStaticStateHolder) continue;
       updateHolderAssignments.add(js.js.statement(
           '#holder = updateHolder(holdersList[#index], #holder)',
           {'index': js.number(i),
             'holder': new js.VariableUse(holder.name)}));
     }
 
     // TODO(floitsch): if name is not set, run through all functions and set the
     // name for IE.
     // TODO(floitsch): don't just reference 'init'.
-    return js.js.statement(deferredBoilerplate,
-    {'deferredInitializers':
-          js.js('#', ModelEmitter.deferredInitializersGlobal),
-      'embeddedGlobalsObject': new js.Parameter('init'),
-      'staticState': new js.Parameter(namer.staticStateHolder),
-      'holders': emitHolders(holders, fragment),
-      'updateHolders': new js.Block(updateHolderAssignments),
-      'prototypes': emitPrototypes(fragment),
-      'inheritance': emitInheritance(fragment),
-      'aliases': emitInstanceMethodAliases(fragment),
-      'tearOffs': emitInstallTearOffs(fragment),
-      'constants': emitConstants(fragment),
-      'staticNonFinalFields': emitStaticNonFinalFields(fragment),
-      'lazyStatics': emitLazilyInitializedStatics(fragment),
-      'types': deferredTypes,
-      // TODO(floitsch): only call emitNativeSupport if we need native.
-      'nativeSupport': emitNativeSupport(fragment),
-      'hash': js.number(fragment.hashCode),
+    return js.js(deferredBoilerplate,
+    {'embeddedGlobalsObject': new js.Parameter('init'),
+     'staticState': new js.Parameter(namer.staticStateHolder),
+     'holders': emitHolders(holders, fragment),
+     'updateHolders': new js.Block(updateHolderAssignments),
+     'prototypes': emitPrototypes(fragment),
+     'inheritance': emitInheritance(fragment),
+     'aliases': emitInstanceMethodAliases(fragment),
+     'tearOffs': emitInstallTearOffs(fragment),
+     'constants': emitConstants(fragment),
+     'staticNonFinalFields': emitStaticNonFinalFields(fragment),
+     'lazyStatics': emitLazilyInitializedStatics(fragment),
+     'types': deferredTypes,
+     // TODO(floitsch): only call emitNativeSupport if we need native.
+     'nativeSupport': emitNativeSupport(fragment),
     });
   }
 
   js.Statement emitDeferredInitializerGlobal(Map loadMap) {
     if (loadMap.isEmpty) return new js.Block.empty();
 
     return js.js.statement("""
     if (typeof(${ModelEmitter.deferredInitializersGlobal}) === 'undefined')
       var ${ModelEmitter.deferredInitializersGlobal} = Object.create(null);""");
   }
@@ skipping 443 matching lines @@
   }
 
   /// Emits the embedded globals that are needed for deferred loading.
   ///
   /// This function is only invoked for the main fragment.
   ///
   /// The [loadMap] contains a map from load-ids (for each deferred library)
   /// to the list of generated fragments that must be installed when the
   /// deferred library is loaded.
   Iterable<js.Property> emitEmbeddedGlobalsForDeferredLoading(
-      Map<String, List<Fragment>> loadMap) {
+      Map<String, List<Fragment>> loadMap,
+      Map<DeferredFragment, _DeferredFragmentHash> deferredLoadHashes) {
     if (loadMap.isEmpty) return [];
 
     List<js.Property> globals = <js.Property>[];
 
     js.ArrayInitializer fragmentUris(List<Fragment> fragments) {
       return js.stringArray(fragments.map((DeferredFragment fragment) =>
           "${fragment.outputFileName}.${ModelEmitter.deferredExtension}"));
     }
     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));
+      return new js.ArrayInitializer(
+          fragments
+              .map((fragment) => deferredLoadHashes[fragment])
+              .toList(growable: false));
     }
 
     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), fragmentUris(fragmentList));
       hashes[count] =
           new js.Property(js.string(loadId), fragmentHashes(fragmentList));
@@ skipping 93 matching lines @@
 
     metadataGlobals.add(createGlobal(program.metadata, METADATA));
     js.Expression types =
         program.metadataTypesForOutputUnit(program.mainFragment.outputUnit);
     metadataGlobals.add(createGlobal(types, TYPES));
 
     return metadataGlobals;
   }
 
   /// Emits all embedded globals.
-  js.Block emitEmbeddedGlobals(Program program) {
+  js.Block emitEmbeddedGlobals(
+      Program program,
+      Map<DeferredFragment, _DeferredFragmentHash> deferredLoadHashes) {
     List<js.Property> globals = <js.Property>[];
 
     if (program.loadMap.isNotEmpty) {
-      globals.addAll(emitEmbeddedGlobalsForDeferredLoading(program.loadMap));
+      globals.addAll(emitEmbeddedGlobalsForDeferredLoading(
+          program.loadMap, deferredLoadHashes));
     }
 
     if (program.typeToInterceptorMap != null) {
       globals.add(new js.Property(js.string(TYPE_TO_INTERCEPTOR_MAP),
       program.typeToInterceptorMap));
     }
 
     if (program.hasIsolateSupport) {
       String staticStateName = namer.staticStateHolder;
       // TODO(floitsch): this doesn't create a new isolate, but just reuses
@@ skipping 83 matching lines @@
     }
     statements.add(js.js.statement("setOrUpdateInterceptorsByTag(#);",
         js.objectLiteral(interceptorsByTag)));
     statements.add(js.js.statement("setOrUpdateLeafTags(#);",
         js.objectLiteral(leafTags)));
     statements.add(subclassAssignment);
 
     return new js.Block(statements);
   }
 }