dart2js: build metadata-types lazily 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 '../../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 142 matching lines @@
     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.Node value) {
+  /// Unparses the given [value].
+  ///
+  /// Pretty-prints the given [value] and, if [protectForEval] is
+  /// true, wraps the resulting string in parenthesis. The result is escaped
+  /// and returned.
+  js.LiteralString unparse(Compiler compiler, js.Node value,
+                           {bool protectForEval: true}) {
     String text = js.prettyPrint(value, compiler).getText();
-    if (value is js.Fun) text = '($text)';
-    if (value is js.LiteralExpression &&
-        (value.template.startsWith("function ") ||
-         value.template.startsWith("{"))) {
-      text = '($text)';
+    if (protectForEval) {
+      if (value is js.Fun) text = '($text)';
+      if (value is js.LiteralExpression &&
+      (value.template.startsWith("function ") ||
+      value.template.startsWith("{"))) {
+        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 14 matching lines @@
        'parseFunctionDescriptor':
            js.js.statement(parseFunctionDescriptorBoilerplate,
                {'argumentCount': js.string(namer.requiredParameterField),
                 'defaultArgumentValues': js.string(namer.defaultValuesField),
                 'callName': js.string(namer.callNameField)}),
 
        'cyclicThrow':
            backend.emitter.staticFunctionAccess(backend.getCyclicThrowHelper()),
        'outputContainsConstantList': program.outputContainsConstantList,
        'embeddedGlobals': emitEmbeddedGlobals(program),
+       'readMetadataTypeFunction': readMetadataTypeFunction,
        'staticNonFinals':
             emitStaticNonFinalFields(fragment.staticNonFinalFields),
        'operatorIsPrefix': js.string(namer.operatorIsPrefix),
        'callName': js.string(namer.callNameField),
        'argumentCount': js.string(namer.requiredParameterField),
        'defaultArgumentValues': js.string(namer.defaultValuesField),
        'eagerClasses': emitEagerClassInitializations(fragment.libraries),
        'invokeMain': fragment.invokeMain,
        'code': code};
 
@@ skipping 200 matching lines @@
   }
 
   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);
   }
 
+  static final String readMetadataTypeName = "readMetadataType";
+
+  js.Statement get readMetadataTypeFunction {
+    // 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 $readMetadataTypeName(index) {
+      var type = #typesAccess[index];
+      if (typeof type == 'string') {
+        type = expressionCompile(type);
+        #typesAccess[index] = type;
+      }
+      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(#)');
+  }
+
   List<js.Property> emitMetadata(Program program) {
     List<js.Property> metadataGlobals = <js.Property>[];
     metadataGlobals.add(new js.Property(
         js.string(METADATA), new js.ArrayInitializer(program.metadata)));
     List<js.Expression> types =
         program.metadataTypes[program.fragments.first.outputUnit];
     if (types == null) types = <js.Expression>[];
-    metadataGlobals.add(new js.Property(
-        js.string(TYPES), new js.ArrayInitializer(types)));
-
+    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));
     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;
 
     List<js.Expression> deferredCode =
         fragment.libraries.map(emitLibrary).toList();
 
     deferredCode.add(
         emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
 
     deferredCode.add(emitConstants(fragment.constants));
 
     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 =
         emitEagerClassInitializations(fragment.libraries);
 
     js.LiteralString immediateString = unparse(compiler, immediateCode);
 
-    js.Expression deferredTypes = types == null
+    js.Expression deferredTypes = (types == null)
         ? js.string("[]")
         : unparse(compiler, new js.ArrayInitializer(types));
 
     js.ArrayInitializer hunk =
         new js.ArrayInitializer([deferredArray, immediateString,
                                  deferredTypes]);
 
     return js.js("$deferredInitializersGlobal[$hash] = #", hunk);
   }
 
@@ skipping 677 matching lines @@
         #nativeInfoHandler;
       }
     }
   }
 
   $setupProgramName(program, 0);
 
   // Initialize globals.
   #embeddedGlobals;
 
+  function expressionCompile(__s__) {
+    'use strict';
+    return eval('(' + __s__ + ')');
+  }
+
+  #readMetadataTypeFunction;
+
   // 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 (#needsNativeSupport) 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.');
 
   #invokeMain;  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }