Handle constants that mix eager and deferred types.

dart/sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 778 matching lines @@
                           '";\\n")')
         ])
       ]),
 
       js('str += "}\\n"'),
 
       js('var newIsolate = new Function(str)'),
       js('newIsolate.prototype = isolatePrototype'),
       js('isolatePrototype.constructor = newIsolate'),
       js('newIsolate.${namer.isolatePropertiesName} = isolateProperties'),
+      // TODO(ahe): Only copy makeConstantList when it is used.
+      js('newIsolate.makeConstantList = oldIsolate.makeConstantList'),
     ]..addAll(copyFinishClasses)
      ..addAll([
 
       // return newIsolate;
       js.return_('newIsolate')
     ]));
   }
 
   jsAst.Fun get lazyInitializerFunction {
     String isolate = namer.CURRENT_ISOLATE;
@@ skipping 1337 matching lines @@
 
       String name = namer.constantName(constant);
       // 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 (name == null) continue;
       if (!addedMakeConstantList && constant.isList()) {
         addedMakeConstantList = true;
         emitMakeConstantList(eagerBuffer);
       }
-      CodeBuffer buffer =
-          bufferForElement(constant.computeType(compiler).element, eagerBuffer);
+      CodeBuffer buffer = bufferForConstant(constant, eagerBuffer);
       jsAst.Expression init = js('$isolateProperties.$name = #',
           constantInitializerExpression(constant));
       buffer.write(jsAst.prettyPrint(init, compiler));
       buffer.write('$N');
     }
   }
 
   void emitMakeConstantList(CodeBuffer buffer) {
     buffer.write(namer.isolateName);
     buffer.write(r'''.makeConstantList = function(list) {
@@ skipping 850 matching lines @@
     });
     return compiler.assembledCode;
   }
 
   CodeBuffer bufferForElement(Element element, CodeBuffer eagerBuffer) {
     if (!isDeferred(element)) return eagerBuffer;
     emitDeferredPreambleWhenEmpty(deferredBuffer);
     return deferredBuffer;
   }
 
+  bool firstDeferredConstant = true;
+
+  /**
+   * Returns the appropriate buffer for [constant].  If constant is
+   * itself an instance of a deferred type, or built from constants
+   * that are instances of deferred types, attempting to use this
+   * constant before the deferred type has been loaded has will not

[ngeoffray, 2013/05/14 10:08:49]

remove second 'has'.

[ahe, 2013/05/15 08:22:56]

Done.

+   * work.
+   */
+  CodeBuffer bufferForConstant(Constant constant, CodeBuffer eagerBuffer) {
+    var queue = new Queue()..add(constant);
+    while (!queue.isEmpty) {
+      constant = queue.removeFirst();
+      if (isDeferred(constant.computeType(compiler).element)) {
+        emitDeferredPreambleWhenEmpty(deferredBuffer);
+        if (firstDeferredConstant) {
+          deferredBuffer.write(
+              '${namer.CURRENT_ISOLATE}$_=${_}old${namer.CURRENT_ISOLATE}$N');
+          deferredBuffer.write(
+              'old${namer.CURRENT_ISOLATE}$_=${_}${namer.CURRENT_ISOLATE}$N');
+        }
+        firstDeferredConstant = false;
+        return deferredBuffer;
+      }
+      queue.addAll(constant.getDependencies());
+    }
+    return eagerBuffer;
+  }
+
   void emitDeferredCode(CodeBuffer buffer) {
     if (buffer.isEmpty) return;
 
     buffer.write(n);
 
     buffer.write(
         '${namer.CURRENT_ISOLATE}$_=${_}old${namer.CURRENT_ISOLATE}$N');
 
     String code = buffer.getText();
     compiler.outputProvider('part', 'js')
@@ skipping 51 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;