dart2js OldEmitter: Change to named holes in js output strings plus some extra clean-ups.

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 439 matching lines @@
         generateEmbeddedGlobalAccess(embeddedNames.ALL_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
     jsAst.Expression leafTagsAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LEAF_TAGS);
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
 
     return js('''
         (function(){
-         # = Object.create(null);  // embedded allClasses.
-         # = Object.create(null);  // embedded interceptorsByTag.
-         # = Object.create(null);  // embedded leafTags.
-         # = Object.create(null);  // embedded finishedClasses
+         #allClasses = Object.create(null);

[floitsch, 2014/12/29 18:09:12]

Ok with change, but we could have just removed the comments too.
This one was really simple to read (since the order didn't even matter).

However, I would still like to inline this JS snippet, and then it makes more
sense (probably).

[zarah, 2014/12/30 10:29:25]

Done, in another cl.

+         #interceptorsByTag = Object.create(null);
+         #leafTags = Object.create(null);
+         #finishedClasses = Object.create(null);
         })()
-      ''', [allClassesAccess,
-            interceptorsByTagAccess,
-            leafTagsAccess,
-            finishedClassesAccess]);
+      ''', {'allClasses': allClassesAccess,
+            'interceptorsByTag': interceptorsByTagAccess,
+            'leafTags': leafTagsAccess,
+            'finishedClasses': finishedClassesAccess});
   }
 
   jsAst.Fun get finishClassesFunction {
     // Class descriptions are collected in a JS object.
     // 'finishClasses' takes all collected descriptions and sets up
     // the prototype.
     // Once set up, the constructors prototype field satisfy:
     //  - it contains all (local) members.
     //  - its internal prototype (__proto__) points to the superclass'
     //    prototype field.
@@ skipping 107 matching lines @@
               'debugFastObjects': DEBUG_FAST_OBJECTS,
               'hasRetainedMetadata': backend.hasRetainedMetadata,
               'metadata': metadataAccess,
               'isTreeShakingDisabled': backend.isTreeShakingDisabled,
               'finishClassFunction': buildFinishClass(),
               'trivialNsmHandlers': nsmEmitter.buildTrivialNsmHandlers(),
               'inCspMode': compiler.useContentSecurityPolicy,
               'notInCspMode': !compiler.useContentSecurityPolicy});
   }
 
   jsAst.Node optional(bool condition, jsAst.Node node) {

[floitsch, 2014/12/29 18:09:12]

Since you are doing cleanups: I believe this function is unused.

[zarah, 2014/12/30 10:29:26]

Done.

     return condition ? node : new jsAst.EmptyStatement();
   }
 
   jsAst.Statement buildFinishClass() {
     String specProperty = '"${namer.nativeSpecProperty}"';  // "%"
 
     jsAst.Expression finishedClassesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.FINISHED_CLASSES);
     jsAst.Expression interceptorsByTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.INTERCEPTORS_BY_TAG);
@@ skipping 172 matching lines @@
 
   jsAst.Fun get lazyInitializerFunction {
     String isolate = namer.currentIsolate;
     jsAst.Expression cyclicThrow =
         staticFunctionAccess(backend.getCyclicThrowHelper());
     jsAst.Expression laziesAccess =
         generateEmbeddedGlobalAccess(embeddedNames.LAZIES);
 
     return js('''
       function (prototype, staticName, fieldName, getterName, lazyValue) {
-        if (!#) # = Object.create(null);
-        #[fieldName] = getterName;
+        if (!#lazies) #lazies = Object.create(null);
+        #lazies[fieldName] = getterName;
 
         var sentinelUndefined = {};
         var sentinelInProgress = {};
         prototype[fieldName] = sentinelUndefined;
 
         prototype[getterName] = function () {
           var result = $isolate[fieldName];
           try {
             if (result === sentinelUndefined) {
               $isolate[fieldName] = sentinelInProgress;
 
               try {
                 result = $isolate[fieldName] = lazyValue();
               } finally {
                 // Use try-finally, not try-catch/throw as it destroys the
                 // stack trace.
                 if (result === sentinelUndefined)
                   $isolate[fieldName] = null;
               }
             } else {
               if (result === sentinelInProgress)
-                #(staticName);
+                #cyclicThrow(staticName);
             }
 
             return result;
           } finally {
             $isolate[getterName] = function() { return this[fieldName]; };
           }
         }
       }
-    ''', [laziesAccess, laziesAccess,
-          laziesAccess,
-          cyclicThrow]);
+    ''', {'lazies': laziesAccess, 'cyclicThrow': cyclicThrow});
   }
 
   List buildDefineClassAndFinishClassFunctionsIfNecessary() {
     if (!needsDefineClass) return [];
     return defineClassFunction
         ..add(buildInheritFrom())
         ..add(js('$finishClassesName = #', finishClassesFunction))
         ..add(initFinishClasses);
   }
 
@@ skipping 384 matching lines @@
     return js('''
       !function() {
         // On V8, the 'intern' function converts a string to a symbol, which
         // makes property access much faster.
         function intern(s) {
           var o = {};
           o[s] = 1;
           return Object.keys(convertToFastObject(o))[0];
         }
 
-        # = function(name) {  // embedded getIsolateTag
-          return intern("___dart_" + name + #);  // embedded isolateTag
+        #getIsolateTag = function(name) {
+          return intern("___dart_" + name + #isolateTag);
         };
 
         // To ensure that different programs loaded into the same context (page)
         // use distinct dispatch properies, we place an object on `Object` to
         // contain the names already in use.
         var tableProperty = "___dart_isolate_tags_";
         var usedProperties = Object[tableProperty] ||
             (Object[tableProperty] = Object.create(null));
 
         var rootProperty = "_${generateIsolateTagRoot()}";
         for (var i = 0; ; i++) {
           var property = intern(rootProperty + "_" + i + "_");
           if (!(property in usedProperties)) {
             usedProperties[property] = 1;
-            # = property;  // embedded isolateTag
+            #isolateTag = property;
             break;
           }
         }
       }()
-    ''', [getIsolateTagAccess,
-          isolateTagAccess,
-          isolateTagAccess]);
+    ''',
+    {'getIsolateTag': getIsolateTagAccess, 'isolateTag': isolateTagAccess});
   }
 
   jsAst.Expression generateDispatchPropertyNameInitialization() {
     jsAst.Expression dispatchPropertyNameAccess =
         generateEmbeddedGlobalAccess(embeddedNames.DISPATCH_PROPERTY_NAME);
     jsAst.Expression getIsolateTagAccess =
         generateEmbeddedGlobalAccess(embeddedNames.GET_ISOLATE_TAG);
     return js('# = #("dispatch_record")',
         [dispatchPropertyNameAccess,
          getIsolateTagAccess]);
@@ skipping 57 matching lines @@
   function onLoad(event) {
     for (var i = 0; i < scripts.length; ++i) {
       scripts[i].removeEventListener("load", onLoad, false);
     }
     callback(event.target);
   }
   for (var i = 0; i < scripts.length; ++i) {
     scripts[i].addEventListener("load", onLoad, false);
   }
 })(function(currentScript) {
-  # = currentScript;  // embedded currentScript.
+  #currentScript = currentScript;
 
   if (typeof dartMainRunner === "function") {
-    dartMainRunner(#, []);  // mainCallClosure.
+    dartMainRunner(#mainCallClosure, []);
   } else {
-    #([]);  // mainCallClosure.
+    #mainCallClosure([]);
   }
-})$N''', [currentScriptAccess,
-          mainCallClosure,
-          mainCallClosure]);
+})$N''', {'currentScript': currentScriptAccess,

[floitsch, 2014/12/29 18:09:12]

I could be wrong, but I believe that the "$N" here is completely useless: the
string is already run through the parser and then pretty-printed.

[zarah, 2014/12/30 10:29:26]

I agree.

+          'mainCallClosure': mainCallClosure});
 
     buffer.write(';');
     buffer.write(jsAst.prettyPrint(invokeMain,
                  compiler, monitor: compiler.dumpInfoTask));
     buffer.write(N);
     addComment('END invoke [main].', buffer);
   }
 
   void emitInitFunction(CodeBuffer buffer) {
     jsAst.FunctionDeclaration decl = js.statement('''
@@ skipping 329 matching lines @@
     if (needsDefineClass ||
         !(nativeClasses.isEmpty &&
           compiler.codegenWorld.staticFunctionsNeedingGetter.isEmpty &&
           outputClassLists.values.every((classList) => classList.isEmpty) &&
           typedefsNeededForReflection.isEmpty)) {
       // Shorten the code by using "$$" as temporary.
       classesCollector = r"$$";
       mainBuffer.add('var $classesCollector$_=${_}Object.create(null)$N$n');
     }
 
-    if (!nativeClasses.isEmpty) {
-      addComment('Native classes', mainBuffer);
-    }
-
     List<ClassElement> classes = task.outputClassLists[mainOutputUnit];
     if (classes != null) {
       for (ClassElement element in classes) {
         generateClass(element, getElementDescriptor(element));
       }
     }
 
     if (compiler.enableMinification) {
       mainBuffer.write(';');
     }
@@ skipping 586 matching lines @@
     for (Element element in compiler.enqueuer.codegen.newlyEnqueuedElements) {
       if (element.isInstanceMember) {
         cachedClassBuilders.remove(element.enclosingClass);
 
         nativeEmitter.cachedBuilders.remove(element.enclosingClass);
 
       }
     }
   }
 }