dart2js: Accept named holes in js-templates.

pkg/compiler/lib/src/js_emitter/old_emitter/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.
 
 part of dart2js.js_emitter;
 
 
 class OldEmitter implements Emitter {
   final Compiler compiler;
   final CodeEmitterTask task;
@@ skipping 369 matching lines @@
     //    constructor.
     // For engines where we have access to the '__proto__' we can manipulate
     // the object literal directly. For other engines we have to create a new
     // object and copy over the members.
 
     String reflectableField = namer.reflectableField;
     jsAst.Expression allClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
     jsAst.Expression metadataAccess =
         generateEmbeddedGlobalAccess(embeddedNames.METADATA);
-    jsAst.Expression finishedClassesAccess =
-        generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
 
     return js('''
       function(collectedClasses, isolateProperties, existingIsolateProperties) {
         var pendingClasses = Object.create(null);
-        var allClasses = #;  // embedded allClasses;
+        var allClasses = #allClasses;
         var constructors;
 
-        if (#)  // DEBUG_FAST_OBJECTS
+        if (#debugFastObjects)
           print("Number of classes: " +
               Object.getOwnPropertyNames(\$\$).length);
 
         var hasOwnProperty = Object.prototype.hasOwnProperty;
 
         if (typeof dart_precompiled == "function") {
           constructors = dart_precompiled(collectedClasses);
         } else {
           var combinedConstructorFunction =
              "function \$reflectable(fn){fn.$reflectableField=1;return fn};\\n"+
              "var \$desc;\\n";
           var constructorsList = [];
         }
 
         for (var cls in collectedClasses) {
           var desc = collectedClasses[cls];
           if (desc instanceof Array) desc = desc[1];
 
           /* The 'fields' are either a constructor function or a
            * string encoding fields, constructor and superclass. Gets the
            * superclass and fields in the format
            *   '[name/]Super;field1,field2'
            * from the CLASS_DESCRIPTOR_PROPERTY property on the descriptor.
            * The 'name/' is optional and contains the name that should be used
            * when printing the runtime type string.  It is used, for example,
            * to print the runtime type JSInt as 'int'.
            */
           var classData = desc["${namer.classDescriptorProperty}"],
               supr, name = cls, fields = classData;
-          if (#)  // backend.hasRetainedMetadata
+          if (#hasRetainedMetadata)
             if (typeof classData == "object" &&
                 classData instanceof Array) {
               classData = fields = classData[0];
             }
           if (typeof classData == "string") {
             var split = classData.split("/");
             if (split.length == 2) {
               name = split[0];
               fields = split[1];
             }
           }
 
           var s = fields.split(";");
           fields = s[1] == "" ? [] : s[1].split(",");
           supr = s[0];
           split = supr.split(":");
           if (split.length == 2) {
             supr = split[0];
             var functionSignature = split[1];
             if (functionSignature)
               desc.\$signature = (function(s) {
-                  return function(){ return #[s]; };  // embedded metadata.
+                  return function(){ return #metadata[s]; };
                 })(functionSignature);
           }
 
-          if (#)  // needsMixinSupport
+          if (#needsMixinSupport)
             if (supr && supr.indexOf("+") > 0) {
               s = supr.split("+");
               supr = s[0];
               var mixin = collectedClasses[s[1]];
               if (mixin instanceof Array) mixin = mixin[1];
               for (var d in mixin) {
                 if (hasOwnProperty.call(mixin, d) &&
                     !hasOwnProperty.call(desc, d))
                   desc[d] = mixin[d];
               }
@@ skipping 17 matching lines @@
 
         for (var i = 0; i < constructors.length; i++) {
           var constructor = constructors[i];
           var cls = constructor.name;
           var desc = collectedClasses[cls];
           var globalObject = isolateProperties;
           if (desc instanceof Array) {
             globalObject = desc[0] || isolateProperties;
             desc = desc[1];
           }
-          if (#) //backend.isTreeShakingDisabled,
+          if (#isTreeShakingDisabled)
             constructor["${namer.metadataField}"] = desc;
           allClasses[cls] = constructor;
           globalObject[cls] = constructor;
         }
 
         constructors = null;
 
-        var finishedClasses = #; // embedded finishedClasses
+        #finishClassFunction;
 
-        #;  // buildFinishClass(),
-
-        #;  // buildTrivialNsmHandlers()
+        #trivialNsmHandlers;
 
         for (var cls in pendingClasses) finishClass(cls);
-      }''', [
-          allClassesAccess,
-          DEBUG_FAST_OBJECTS,
-          backend.hasRetainedMetadata,
-          metadataAccess,
-          needsMixinSupport,
-          backend.isTreeShakingDisabled,
-          finishedClassesAccess,
-          buildFinishClass(),
-          nsmEmitter.buildTrivialNsmHandlers()]);
+      }''', { 'allClasses': allClassesAccess,
+              'debugFastObjects': DEBUG_FAST_OBJECTS,
+              'hasRetainedMetadata': backend.hasRetainedMetadata,
+              'metadata': metadataAccess,
+              'needsMixinSupport': needsMixinSupport,
+              'isTreeShakingDisabled': backend.isTreeShakingDisabled,
+              'finishClassFunction': buildFinishClass(),
+              'trivialNsmHandlers': nsmEmitter.buildTrivialNsmHandlers()});
   }
 
   jsAst.Node optional(bool condition, jsAst.Node node) {
     return condition ? node : new jsAst.EmptyStatement();
   }
 
-  jsAst.FunctionDeclaration buildFinishClass() {
+  jsAst.Statement buildFinishClass() {
     String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
 
+    jsAst.Expression finishedClassesAccess =
+        generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
 
     return js.statement('''
+    {
+      var finishedClasses = #;  // finishedClassesAccess.
+
       function finishClass(cls) {
 
         if (finishedClasses[cls]) return;
         finishedClasses[cls] = true;
 
         var superclass = pendingClasses[cls];
         var constructor = allClasses[cls];
 
         // Process aliased members due to super calls. We have to do this early
         // to ensure that we also hit the object class.
@@ skipping 54 matching lines @@
                   }
                 }
                 for (i = 0; i < tags.length; i++) {
                   #[tags[i]] = constructor;  // embedded interceptorsByTag.
                   #[tags[i]] = false;  // embedded leafTags.
                 }
               }
             }
           }
         }
-      }''', [!nativeClasses.isEmpty,
-             interceptorsByTagAccess,
-             leafTagsAccess,
-             true,
-             interceptorsByTagAccess,
-             leafTagsAccess]);
+      }
+    }''', [finishedClassesAccess,
+           !nativeClasses.isEmpty,
+           interceptorsByTagAccess,
+           leafTagsAccess,
+           true,
+           interceptorsByTagAccess,
+           leafTagsAccess]);
   }
 
   jsAst.Fun get finishIsolateConstructorFunction {
     // We replace the old Isolate function with a new one that initializes
     // all its fields with the initial (and often final) value of all globals.
     //
     // We also copy over old values like the prototype, and the
     // isolateProperties themselves.
     return js('''
       function (oldIsolate) {
@@ skipping 1409 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }