dart2js: use named holes in boilerplate of 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 '../../dart2jslib.dart' show Compiler;
 import '../../js/js.dart' as js;
 import '../../js_backend/js_backend.dart' show
     JavaScriptBackend,
@@ skipping 60 matching lines @@
   }
 
   js.Statement emitMainUnit(Program program) {
     MainOutput unit = program.outputs.first;
     List<js.Expression> elements = unit.libraries.map(emitLibrary).toList();
     elements.add(
         emitLazilyInitializedStatics(unit.staticLazilyInitializedFields));
     js.Expression code = new js.ArrayInitializer.from(elements);
     return js.js.statement(
         boilerplate,
-        [emitDeferredInitializerGlobal(program.loadMap),
-         emitHolders(unit.holders),
-         namer.elementAccess(backend.getCyclicThrowHelper()),
-         program.outputContainsConstantList,
-         emitEmbeddedGlobals(program.loadMap),
-         emitConstants(unit.constants),
-         emitStaticNonFinalFields(unit.staticNonFinalFields),
-         emitEagerClassInitializations(unit.libraries),
-         unit.main,
-         code]);
+        {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
+         'holders': emitHolders(unit.holders),
+         'cyclicThrow': namer.elementAccess(backend.getCyclicThrowHelper()),
+         'outputContainsConstantList': program.outputContainsConstantList,
+         'embeddedGlobals': emitEmbeddedGlobals(program.loadMap),
+         'constants': emitConstants(unit.constants),
+         'staticNonFinals': emitStaticNonFinalFields(unit.staticNonFinalFields),
+         'eagerClasses': emitEagerClassInitializations(unit.libraries),
+         'main': unit.main,
+         'code': code});
   }
 
   js.Block emitHolders(List<Holder> holders) {
     // The top-level variables for holders must *not* be renamed by the
     // JavaScript pretty printer because a lot of code already uses the
     // non-renamed names. The generated code looks like this:
     //
     //    var H = {}, ..., G = {};
     //    var holders = [ H, ..., G ];
     //
@@ skipping 254 matching lines @@
     return unparse(compiler, field.code);
   }
 
   js.Expression emitStaticMethod(StaticMethod method) {
     return unparse(compiler, method.code);
   }
 
   static final String boilerplate = """
 {
 // Declare deferred-initializer global.
-#;
+#deferredInitializer;
 
 !function(start, program) {
 
   // Initialize holder objects.
-  #;
+  #holders;
 
   function setupProgram() {
     for (var i = 0; i < program.length - 1; i++) {
       setupLibrary(program[i]);
     }
     setupLazyStatics(program[i]);
   }
 
   function setupLibrary(library) {
     var statics = library[0];
@@ skipping 24 matching lines @@
       var method = compile(name, descriptor);
       holder[name] = method;
       return method.apply(this, arguments);
     };
   }
 
   function setupLazyStatic(name, getterName, holder, descriptor) {
     holder[name] = null;
     holder[getterName] = function() {
       var initializer = compile(name, descriptor);
-      holder[getterName] = function() { #(name) };  // cyclicThrowHelper
+      holder[getterName] = function() { #cyclicThrow(name) };
       var result;
       var sentinelInProgress = descriptor;
       try {
         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
@@ skipping 79 matching lines @@
     return new intermediate();
   }
 
   function compile(__name__, __s__) {
     'use strict';
     // TODO(floitsch): evaluate the performance impact of the string
     // concatenations.
     return eval(__s__ + "\\n//# sourceURL=" + __name__ + ".js");
   }
 
-  if (#) { // outputContainsConstantList
+  if (#outputContainsConstantList) {
     function makeConstList(list) {
       // By assigning a function to the properties they become part of the
       // hidden class. The actual values of the fields don't matter, since we
       // only check if they exist.
       list.immutable\$list = Array;
       list.fixed\$length = Array;
       return list;
     }
   }
 
   setupProgram();
 
   // Initialize globals.
-  #;
+  #embeddedGlobals;
 
   // Initialize constants.
-  #;
+  #constants;
 
   // Initialize static non-final fields.
-  #;
+  #staticNonFinals;
 
   // Initialize eager classes.
-  #;
+  #eagerClasses;
 
   var end = Date.now();
   print('Setup: ' + (end - start) + ' ms.');
 
-  if (true) #();  // Start main.
+  #main();  // Start main.
 
-}(Date.now(), #)
+}(Date.now(), #code)
 }""";
 
 }