dart2js: compile metadata lazily in the lazy 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 '../../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 434 matching lines @@
       return type;
     }''', {"typesAccess": generateEmbeddedGlobalAccess(TYPES)});
   }
 
   js.Template get templateForReadType {
     // TODO(floitsch): make sure that no local variable shadows the access to
     // the readMetadataType function.
     return js.js.expressionTemplateFor('$readMetadataTypeName(#)');
   }
 
+  static final String readMetadataName = "readLazyMetadata";
+  static final String lazyMetadataName = "lazy_$METADATA";
+
+  js.Statement get readMetadataFunction {
+    // Types are non-evaluated and must be compiled at first use.
+    // Compiled strings are guaranteed not to be strings, and it's thus safe
+    // to use a type-test to determine if a type has already been compiled.
+    return js.js.statement('''function $readMetadataName(index) {
+      var lazyMetadata = #lazyMetadataAccess[index];
+      if (typeof lazyMetadata == 'string') {
+        #metadataAccess[index] = expressionCompile(lazyMetadata);
+        #lazyMetadataAccess[index] = null;
+      }
+      return #metadataAccess[index];
+    }''', {
+      "lazyMetadataAccess": generateEmbeddedGlobalAccess(lazyMetadataName),
+      "metadataAccess": generateEmbeddedGlobalAccess(METADATA)
+    });
+  }
+
+  js.Template get templateForReadMetadata {
+    // TODO(floitsch): make sure that no local variable shadows the access to
+    // the readMetadata function.
+    return js.js.expressionTemplateFor('$readMetadataName(#)');
+  }
+
   List<js.Property> emitMetadata(Program program) {
+    // Unparses all given js-expressions (suitable for `expressionCompile`) and
+    // returns the result in a js-array.
+    // If the given [expressions] is null returns the empty js-array.
+    js.ArrayInitializer unparseExpressions(List<js.Expression> expressions) {
+      if (expressions == null) expressions = <js.Expression>[];
+      List<js.LiteralString> unparsedExpressions = expressions
+          .map((expr) => unparse(compiler, expr, protectForEval: false))
+          .toList();
+      return new js.ArrayInitializer(unparsedExpressions);
+    }
+
     List<js.Property> metadataGlobals = <js.Property>[];
-    metadataGlobals.add(new js.Property(
-        js.string(METADATA), new js.ArrayInitializer(program.metadata)));
+
+    js.ArrayInitializer unparsedMetadata = unparseExpressions(program.metadata);
+    metadataGlobals.add(new js.Property(js.string(lazyMetadataName),
+                                        unparsedMetadata));
+    metadataGlobals.add(new js.Property(js.string(METADATA),
+                                        new js.ArrayInitializer([])));
+
     List<js.Expression> types =
         program.metadataTypes[program.fragments.first.outputUnit];
-    if (types == null) types = <js.Expression>[];
-    List<js.LiteralString> unparsedTypes = types
-        .map((type) => unparse(compiler, type, protectForEval: false))
-        .toList();
-    js.ArrayInitializer typesArray = new js.ArrayInitializer(unparsedTypes);
-    metadataGlobals.add(new js.Property(js.string(TYPES), typesArray));
+    metadataGlobals.add(new js.Property(js.string(TYPES),
+                                        unparseExpressions(types)));
+
     return metadataGlobals;
   }
 
   js.Expression emitDeferredFragment(List<js.Expression> types,
                                      DeferredFragment fragment,
                                      List<Holder> holders) {
     // TODO(floitsch): initialize eager classes.
     // TODO(floitsch): the hash must depend on the output.
     int hash = fragment.hashCode;
 
@@ skipping 737 matching lines @@
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }