Avoid generating VariableUse nodes with non-identifier names

sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.dart

 // Copyright (c) 2012, 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;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
@@ skipping 529 matching lines @@
           Isolate.$finishClassesProperty = oldIsolate.$finishClassesProperty;
         if (#)
           Isolate.makeConstantList = oldIsolate.makeConstantList;
         return Isolate;
       }''',
         [ needsDefineClass, hasMakeConstantList ]);
   }
 
   jsAst.Fun get lazyInitializerFunction {
     String isolate = namer.currentIsolate;
-    String cyclicThrow = namer.isolateAccess(backend.getCyclicThrowHelper());
+    jsAst.Expression cyclicThrow =
+        namer.elementAccess(backend.getCyclicThrowHelper());
 
     return js('''
       function (prototype, staticName, fieldName, getterName, lazyValue) {
         if (#) {
           if (!init.lazies) init.lazies = {};
           init.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)
                   if ($isolate[fieldName] === sentinelInProgress)
                     $isolate[fieldName] = null;
               }
             } else {
               if (result === sentinelInProgress)
-                $cyclicThrow(staticName);
+                #(staticName);
             }
 
             return result;
           } finally {
             $isolate[getterName] = function() { return this[fieldName]; };
           }
         }
       }
-    ''', [backend.rememberLazies]);
+    ''', [backend.rememberLazies, cyclicThrow]);
   }
 
   List buildDefineClassAndFinishClassFunctionsIfNecessary() {
     if (!needsDefineClass) return [];
     return defineClassFunction
     ..addAll(buildInheritFrom())
     ..addAll([
       js('$finishClassesName = #', finishClassesFunction)
     ]);
   }
@@ skipping 351 matching lines @@
   return list;
 };
 ''');
   }
 
   /// Returns the code equivalent to:
   ///   `function(args) { $.startRootIsolate(X.main$closure(), args); }`
   String buildIsolateSetupClosure(CodeBuffer buffer,
                                   Element appMain,
                                   Element isolateMain) {
-    String mainAccess = "${namer.isolateStaticClosureAccess(appMain)}";
+    jsAst.Expression mainAccess = namer.isolateStaticClosureAccess(appMain);
     // Since we pass the closurized version of the main method to
     // the isolate method, we must make sure that it exists.
-    return "(function(a){${namer.isolateAccess(isolateMain)}($mainAccess,a)})";
+    jsAst.Expression setup = js('function(a){ #(#, a); }',
+            [namer.elementAccess(isolateMain), mainAccess]);
+
+    return jsAst.prettyPrint(setup, compiler).getText();
   }
 
   /**
    * Emits code that sets `init.isolateTag` to a unique string.
    */
   jsAst.Expression generateIsolateAffinityTagInitialization() {
     return js('''
       !function() {
         // On V8, the 'intern' function converts a string to a symbol, which
         // makes property access much faster.
@@ skipping 39 matching lines @@
 
   emitMain(CodeBuffer buffer) {
     if (compiler.isMockCompilation) return;
     Element main = compiler.mainFunction;
     String mainCallClosure = null;
     if (compiler.hasIsolateSupport()) {
       Element isolateMain =
         compiler.isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE);
       mainCallClosure = buildIsolateSetupClosure(buffer, main, isolateMain);
     } else {
+      // TODO(sra): Replace with AST.
       mainCallClosure = '${namer.isolateAccess(main)}';
     }
 
     if (backend.needToInitializeIsolateAffinityTag) {
       buffer.write(
           jsAst.prettyPrint(generateIsolateAffinityTagInitialization(),
                             compiler));
       buffer.write(N);
     }
     if (backend.needToInitializeDispatchProperty) {
@@ skipping 151 matching lines @@
   function MyClass() {};
   MyClass.prototype = properties;
   new MyClass();
 ''');
     if (DEBUG_FAST_OBJECTS) {
       ClassElement primitives =
           compiler.findHelper('Primitives');
       FunctionElement printHelper =
           compiler.lookupElementIn(
               primitives, 'printString');
+      // TODO(sra): Replace with AST.
       String printHelperName = namer.isolateAccess(printHelper);
       mainBuffer.add('''
 // The following only works on V8 when run with option "--allow-natives-syntax".
 if (typeof $printHelperName === "function") {
   $printHelperName("Size of global object: "
                    + String(Object.getOwnPropertyNames(properties).length)
                    + ", fast properties " + %HasFastProperties(properties));
 }
 ''');
     }
@@ skipping 266 matching lines @@
       emitConvertToFastObjectFunction();
       for (String globalObject in Namer.reservedGlobalObjectNames) {
         mainBuffer.add('$globalObject = convertToFastObject($globalObject)$N');
       }
       if (DEBUG_FAST_OBJECTS) {
         ClassElement primitives =
             compiler.findHelper('Primitives');
         FunctionElement printHelper =
             compiler.lookupElementIn(
                 primitives, 'printString');
+        // TODO(sra): Replace with AST.
         String printHelperName = namer.isolateAccess(printHelper);
 
         mainBuffer.add('''
 // The following only works on V8 when run with option "--allow-natives-syntax".
 if (typeof $printHelperName === "function") {
   $printHelperName("Size of global helper object: "
                    + String(Object.getOwnPropertyNames(H).length)
                    + ", fast properties " + %HasFastProperties(H));
   $printHelperName("Size of global platform object: "
                    + String(Object.getOwnPropertyNames(P).length)
@@ skipping 209 matching lines @@
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void registerReadTypeVariable(TypeVariableElement element) {
     readTypeVariables.add(element);
   }
 }