Make dart2js deferred loading work in cps mode.

sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.dart

 // Copyright (c) 2012, 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;
 
 const USE_NEW_EMITTER = const bool.fromEnvironment("dart2js.use.new.emitter");
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
@@ skipping 69 matching lines @@
 
   /**
    * List of expressions and statements that will be included in the
    * precompiled function.
    *
    * To save space, dart2js normally generates constructors and accessors
    * dynamically. This doesn't work in CSP mode, and may impact startup time
    * negatively. So dart2js will emit these functions to a separate file that
    * can be optionally included to support CSP mode or for faster startup.
    */
-  List<jsAst.Node> precompiledFunction = <jsAst.Node>[];
+  Map<OutputUnit, List<jsAst.Node>> _precompiledFunctions =
+      new Map<OutputUnit, List<jsAst.Node>>();
 
-  List<jsAst.Expression> precompiledConstructorNames = <jsAst.Expression>[];
+  Map<OutputUnit, List<jsAst.Expression>> _precompiledConstructorNames =
+      new Map<OutputUnit, List<jsAst.Expression>>();
 
   // True if Isolate.makeConstantList is needed.
   bool hasMakeConstantList = false;
 
   /**
    * Accumulate properties for classes and libraries, describing their
    * static/top-level members.
    * Later, these members are emitted when the class or library is emitted.
    *
    * For supporting deferred loading we keep one list per output unit.
@@ skipping 19 matching lines @@
     classEmitter.task = this;
     nsmEmitter.task = this;
     typeTestEmitter.task = this;
     interceptorEmitter.task = this;
     metadataEmitter.task = this;
     // TODO(18886): Remove this call (and the show in the import) once the
     // memory-leak in the VM is fixed.
     templateManager.clear();
   }
 
+  List<jsAst.Node> precompiledFunction(OutputUnit outputUnit) {

[floitsch, 2014/09/12 17:00:18]

precompiledFunctionsFor

[sigurdm, 2014/09/15 13:10:48]

Done.

+    return _precompiledFunctions
+        .putIfAbsent(outputUnit, () => new List<jsAst.Node>());
+  }
+
+  List<jsAst.Expression> precompiledConstructorNames(OutputUnit outputUnit) {

[floitsch, 2014/09/12 17:00:17]

precompiledConstructorNamesFor

[sigurdm, 2014/09/15 13:10:48]

Done.

+    return _precompiledConstructorNames
+        .putIfAbsent(outputUnit, () => new List<jsAst.Expression>());
+  }
+
   void addComment(String comment, CodeBuffer buffer) {
     buffer.write(jsAst.prettyPrint(js.comment(comment), compiler));
   }
 
   jsAst.Expression constantReference(Constant value) {
     return constantEmitter.reference(value);
   }
 
   jsAst.Expression constantInitializerExpression(Constant value) {
     return constantEmitter.initializationExpression(value);
@@ skipping 674 matching lines @@
     throw compiler.internalError(element,
         'Do not know how to reflect on this $element.');
   }
 
   String namedParametersAsReflectionNames(Selector selector) {
     if (selector.getOrderedNamedArguments().isEmpty) return '';
     String names = selector.getOrderedNamedArguments().join(':');
     return ':$names';
   }
 
-  jsAst.FunctionDeclaration buildPrecompiledFunction() {
+  jsAst.FunctionDeclaration buildPrecompiledFunction(OutputUnit outputUnit) {
     // TODO(ahe): Compute a hash code.
     return js.statement('''
       function dart_precompiled(\$collectedClasses) {
         var \$desc;
         #;
         return #;
       }''', [
-          precompiledFunction,
-          new jsAst.ArrayInitializer.from(precompiledConstructorNames)]);
+          precompiledFunction(outputUnit),
+          new jsAst.ArrayInitializer.from(
+              precompiledConstructorNames(outputUnit))]);
   }
 
   void generateClass(ClassElement classElement, ClassBuilder properties) {
     compiler.withCurrentElement(classElement, () {
       if (compiler.hasIncrementalSupport) {
         ClassBuilder builder =
             cachedClassBuilders.putIfAbsent(classElement, () {
               ClassBuilder builder = new ClassBuilder(classElement, namer);
               classEmitter.generateClass(
                   classElement, builder, additionalProperties[classElement]);
@@ skipping 580 matching lines @@
           ..write(namer.globalObjectFor(library))
           ..write(',$_')
           ..write(jsAst.prettyPrint(initializers,
                                     compiler,
                                     monitor: compiler.dumpInfoTask))
           ..write(library == compiler.mainApp ? ',${n}1' : "")
           ..write('],$n');
     }
   }
 
-  void emitPrecompiledConstructor(String constructorName,
+  void emitPrecompiledConstructor(OutputUnit outputUnit,
+                                  String constructorName,
                                   jsAst.Expression constructorAst) {
-    precompiledFunction.add(
+    precompiledFunction(outputUnit).add(
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration(constructorName), constructorAst));
-    precompiledFunction.add(
-   js.statement(r'''{
+    precompiledFunction(outputUnit).add(
+    js.statement(r'''{
           #.builtin$cls = #;
           if (!"name" in #)
               #.name = #;
           $desc=$collectedClasses.#;
           if ($desc instanceof Array) $desc = $desc[1];
           #.prototype = $desc;
         }''',
         [   constructorName, js.string(constructorName),
             constructorName,
             constructorName, js.string(constructorName),
             constructorName,
             constructorName
          ]));
 
-    precompiledConstructorNames.add(js('#', constructorName));
+    precompiledConstructorNames(outputUnit).add(js('#', constructorName));
   }
 
   void assembleProgram() {
     measure(() {
       invalidateCaches();
 
       // Compute the required type checks to know which classes need a
       // 'is$' method.
       typeTestEmitter.computeRequiredTypeChecks();
 
@@ skipping 146 matching lines @@
               js.string(typeReference));
           jsAst.Node declaration = new jsAst.ObjectInitializer([descriptor]);
           String mangledName = namer.getNameX(typedef);
           String reflectionName = getReflectionName(typedef, mangledName);
           getElementDescriptorForOutputUnit(library, mainUnit)
               ..addProperty(mangledName, declaration)
               ..addProperty("+$reflectionName", js.string(''));
           // Also emit a trivial constructor for CSP mode.
           String constructorName = mangledName;
           jsAst.Expression constructorAst = js('function() {}');
-          emitPrecompiledConstructor(constructorName, constructorAst);
+          emitPrecompiledConstructor(mainOutputUnit,
+                                     constructorName,
+                                     constructorAst);
         }
 
         if (!mangledFieldNames.isEmpty) {
           var keys = mangledFieldNames.keys.toList();
           keys.sort();
           var properties = [];
           for (String key in keys) {
             var value = js.string('${mangledFieldNames[key]}');
             properties.add(new jsAst.Property(js.string(key), value));
           }
@@ skipping 148 matching lines @@
           if (typeof print === "function") {
              print("Size of $object: "
                    + String(Object.getOwnPropertyNames($object).length)
                    + ", fast properties " + HasFastProperties($object));
 }
 ''');
         }
       }
 
       jsAst.FunctionDeclaration precompiledFunctionAst =
-          buildPrecompiledFunction();
+          buildPrecompiledFunction(mainOutputUnit);
       emitInitFunction(mainBuffer);
       emitMain(mainBuffer);
       mainBuffer.add('})()\n');
 
       if (compiler.useContentSecurityPolicy) {
         mainBuffer.write(
             jsAst.prettyPrint(
                 precompiledFunctionAst, compiler,
                 monitor: compiler.dumpInfoTask,
                 allowVariableMinification: false).getText());
@@ skipping 216 matching lines @@
 
       typeTestEmitter.emitRuntimeTypeSupport(outputBuffer, outputUnit);
 
       emitCompileTimeConstants(outputBuffer, outputUnit);
       outputBuffer.write('}$N');
       String code = outputBuffer.getText();
 
       // Make a unique hash of the code (before the sourcemaps are added)
       // This will be used to retrieve the initializing function from the global
       // variable.
       String hash = hashOfString(code);

[floitsch, 2014/09/12 17:00:17]

Can't you do the hash after the cspcode?

[sigurdm, 2014/09/15 13:10:48]

My thinking was that the csp-code follows deterministically from the other code
- therefore it has no utility in the hash - but I can see how it makes the code
more confusing

Done.

 
+      CodeBuffer cspCode = new CodeBuffer();
+      if (compiler.useContentSecurityPolicy) {
+        jsAst.FunctionDeclaration precompiledFunctionAst =
+            buildPrecompiledFunction(outputUnit);
+
+        cspCode.write(
+            jsAst.prettyPrint(
+                precompiledFunctionAst, compiler,
+                monitor: compiler.dumpInfoTask,
+                allowVariableMinification: false).getText());
+      }
+
       outputBuffers[outputUnit] = outputBuffer;
       compiler.outputProvider(outputUnit.partFileName(compiler), 'part.js')
         ..add(code)
         ..add('${deferredInitializers}["$hash"]$_=$_'
-                '${deferredInitializers}.current')
+                '${deferredInitializers}.current$N')
+        ..add(cspCode.getText())
         ..close();
 
       hunkHashes[outputUnit] = hash;
       // TODO(johnniwinther): Support source maps for deferred code.
     }
     return hunkHashes;
   }
 
   String buildGeneratedBy() {
     var suffix = '';
@@ skipping 26 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }