dart2js: create constants 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 99 matching lines @@
     if (value.isFunction) {
       FunctionConstantValue functionConstant = value;
       return generateStaticClosureAccess(functionConstant.element);
     }
 
     // We are only interested in the "isInlined" part, but it does not hurt to
     // test for the other predicates.
     if (isConstantInlinedOrAlreadyEmitted(value)) {
       return constantEmitter.generate(value);
     }
-    return js.js('#.#', [namer.globalObjectForConstant(value),
-                         namer.constantName(value)]);
+    return js.js('#.#()', [namer.globalObjectForConstant(value),
+                           namer.constantName(value)]);
   }
 
   int emitProgram(Program program) {
     List<Fragment> fragments = program.fragments;
     MainFragment mainFragment = fragments.first;
 
     int totalSize = 0;
 
     // We have to emit the deferred fragments first, since we need their
     // deferred hash (which depends on the output) when emitting the main
@@ skipping 14 matching lines @@
         ..add(mainCode)
         ..close();
     totalSize += mainCode.length;
 
     return totalSize;
   }
 
   js.LiteralString unparse(Compiler compiler, js.Node value) {
     String text = js.prettyPrint(value, compiler).getText();
     if (value is js.Fun) text = '($text)';
+    if (value is js.LiteralExpression &&

[floitsch, 2015/03/06 19:30:26]

This captures the JS_CONST cases that had a literal expression starting with
"function" in it.

+        (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';
   }
 
   js.Statement emitMainFragment(Program program) {
     MainFragment fragment = program.fragments.first;
     List<js.Expression> elements = fragment.libraries.map(emitLibrary).toList();
     elements.add(
         emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
+    elements.add(emitConstants(fragment.constants));
+
 
     js.Expression code = new js.ArrayInitializer(elements);
 
     Map<String, dynamic> holes =
       {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
        'holders': emitHolders(program.holders),
        'tearOff': buildTearOffCode(backend),
        '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),
-       'constants': emitConstants(fragment.constants),
        '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 216 matching lines @@
     // 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));

[floitsch, 2015/03/06 19:30:26]

This line was missing.

+
     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 = js.js.statement('''{
-          #constants;
-          #eagerClasses;
-        }''',
-        {'constants': emitConstants(fragment.constants),
-         'eagerClasses': emitEagerClassInitializations(fragment.libraries)});
+    js.Statement immediateCode =
+        emitEagerClassInitializations(fragment.libraries);
 
     js.LiteralString immediateString = unparse(compiler, immediateCode);
     js.ArrayInitializer hunk =
         new js.ArrayInitializer([deferredArray, immediateString]);
 
     return js.js("$deferredInitializersGlobal[$hash] = #", hunk);
   }
 
-  js.Block emitConstants(List<Constant> constants) {
-    Iterable<js.Statement> statements = constants.map((Constant constant) {
-      js.Expression code = constantEmitter.generate(constant.value);
-      return js.js.statement("#.# = #;",
-                             [constant.holder.name, constant.name, code]);
-    });
-    return new js.Block(statements.toList());
+  // This string should be referenced wherever JavaScript code makes assumptions
+  // on the constants format.
+  static final String constantsDescription =
+      "The constants are encoded as a follows:"
+      "   [constantsHolderIndex, name, code, name2, code2, ...]."
+      "The array is completely empty if there is no constant at all.";
+
+  js.ArrayInitializer emitConstants(List<Constant> constants) {
+    List<js.Expression> data = <js.Expression>[];
+    if (constants.isNotEmpty) {
+      int holderIndex = constants.first.holder.index;
+      data.add(js.number(holderIndex));
+      data.addAll(constants.expand((Constant constant) {
+        assert(constant.holder.index == holderIndex);
+        js.Expression code = constantEmitter.generate(constant.value);
+        return [js.string(constant.name), unparse(compiler, code)];
+      }));
+    }
+    return new js.ArrayInitializer(data);
   }
 
   js.Block emitStaticNonFinalFields(List<StaticField> fields) {
     Iterable<js.Statement> statements = fields.map((StaticField field) {
       return js.js.statement("#.# = #;",
                              [field.holder.name, field.name, field.code]);
     });
     return new js.Block(statements.toList());
   }
 
@@ skipping 348 matching lines @@
 
 !function(start, program) {
   // Initialize holder objects.
   #holders;
   var nativeInfos = Object.create(null);
 
   // Counter to generate unique names for tear offs.
   var functionCounter = 0;
 
   function $setupProgramName(program) {
-    for (var i = 0; i < program.length - 1; i++) {
+    for (var i = 0; i < program.length - 2; i++) {
       setupLibrary(program[i]);
     }
     setupLazyStatics(program[i]);
+    setupConstants(program[i + 1]);
   }
 
   function setupLibrary(library) {
     var statics = library[0];
     for (var i = 0; i < statics.length; i += 3) {
       var holderIndex = statics[i + 1];
       setupStatic(statics[i], holders[holderIndex], statics[i + 2]);
     }
 
     var classes = library[1];
@@ skipping 25 matching lines @@
   function setupLazyStatics(statics) {
     for (var i = 0; i < statics.length; i += 4) {
       var name = statics[i];
       var getterName = statics[i + 1];
       var holderIndex = statics[i + 2];
       var initializer = statics[i + 3];
       setupLazyStatic(name, getterName, holders[holderIndex], initializer);
     }
   }
 
+  function setupConstants(constants) {
+    // $constantsDescription.
+    if (constants.length == 0) return;
+    // We assume that all constants are in the same holder.
+    var holder = holders[constants[0]];
+    for (var i = 1; i < constants.length; i += 2) {
+      var name = constants[i];
+      var initializer = constants[i + 1];
+      setupConstant(name, holder, initializer);
+    }
+  }
+
   function setupStatic(name, holder, descriptor) {
     if (typeof descriptor == 'string') {
       holder[name] = function() {
         var method = compile(name, descriptor);
         holder[name] = method;
         return method.apply(this, arguments);
       };
     } else {
       // Parse the tear off information and generate compile handlers.
       // TODO(herhut): Share parser with instance methods.      
@@ skipping 52 matching lines @@
         result = holder[name] = sentinelInProgress;
         result = holder[name] = initializer();
       } finally {
         // Use try-finally, not try-catch/throw as it destroys the stack trace.
         if (result === sentinelInProgress) {
           // The lazy static (holder[name]) might have been set to a different
           // value. According to spec we still have to reset it to null, if the
           // initialization failed.
           holder[name] = null;
         }
+        // TODO(floitsch): the function should probably be unique for each
+        // static.
         holder[getterName] = function() { return this[name]; };
       }
       return result;
     };
   }
 
+  function setupConstant(name, holder, descriptor) {
+    var c;
+    holder[name] = function() {
+      if (descriptor !== null) {
+        c = compile(name, descriptor);
+        name = null;
+        descriptor = null;
+      }
+      return c;
+    };
+  }
+
   function setupClass(name, holder, descriptor) {
     var patch = function() {
       var constructor = compileConstructor(name, descriptor);
       holder[name] = constructor;
       constructor.ensureResolved = function() { return this; };
       if (this === patch) return constructor;  // Was used as "ensureResolved".
       var object = new constructor();
       constructor.apply(object, arguments);
       return object;
     };
@@ skipping 90 matching lines @@
       for (var nativeClass in nativeInfos) {
         var constructor = holdersMap[nativeClass][nativeClass].ensureResolved();
         var nativeInfo = nativeInfos[nativeClass];
         #nativeInfoHandler;
       }
     }
   }
 
   $setupProgramName(program);
 
-  // Initialize constants.
-  #constants;
-
   // Initialize globals.
   #embeddedGlobals;
 
   // 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)
 }""";
 
 }