dart2js: Use js('source') instead of js['source'] to invoke JS mini-parser

sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 19 matching lines @@
 typedef void DefineStubFunction(String invocationName, jsAst.Expression value);
 
 /**
  * A data structure for collecting fragments of a class definition.
  */
 class ClassBuilder {
   final List<jsAst.Property> properties = <jsAst.Property>[];
 
   // Has the same signature as [DefineStubFunction].
   void addProperty(String name, jsAst.Expression value) {
-    properties.add(new jsAst.Property(js.string(name), value));
+    properties.add(new jsAst.Property(jsBuilder.string(name), value));
   }
 
   jsAst.Expression toObjectInitializer() {
     return new jsAst.ObjectInitializer(properties);
   }
 }
 
 /**
  * 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 78 matching lines @@
       : mainBuffer = new CodeBuffer(),
         this.namer = namer,
         boundClosureCache = new Map<int, String>(),
         interceptorClosureCache = new Map<int, String>(),
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void addComment(String comment, CodeBuffer buffer) {
-    buffer.write(jsAst.prettyPrint(js.comment(comment), compiler));
+    buffer.write(jsAst.prettyPrint(jsBuilder.comment(comment), compiler));
   }
 
   void computeRequiredTypeChecks() {
     assert(checkedClasses == null && checkedTypedefs == null);
 
     compiler.codegenWorld.addImplicitChecks(classesUsingTypeVariableTests);
 
     checkedClasses = new Set<ClassElement>();
     checkedTypedefs = new Set<TypedefElement>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
@@ skipping 60 matching lines @@
     const RANGE2_SIZE = RANGE2_LAST - RANGE2_FIRST + 1;
     const RANGE1_ADJUST = - (FIRST_FIELD_CODE - RANGE1_FIRST);
     const RANGE2_ADJUST = - (FIRST_FIELD_CODE + RANGE1_SIZE - RANGE2_FIRST);
     const RANGE3_ADJUST =
         - (FIRST_FIELD_CODE + RANGE1_SIZE + RANGE2_SIZE - RANGE3_FIRST);
 
     String receiverParamName = compiler.enableMinification ? "r" : "receiver";
     String valueParamName = compiler.enableMinification ? "v" : "value";
 
     // function generateAccessor(field, prototype) {
-    jsAst.Fun fun = js.fun(['field', 'prototype'], [
-      js['var len = field.length'],
-      js['var code = field.charCodeAt(len - 1)'],
-      js['code = ((code >= $RANGE1_FIRST) && (code <= $RANGE1_LAST))'
+    jsAst.Fun fun = jsBuilder.fun(['field', 'prototype'], [
+      js('var len = field.length'),
+      js('var code = field.charCodeAt(len - 1)'),
+      js('code = ((code >= $RANGE1_FIRST) && (code <= $RANGE1_LAST))'
           '    ? code - $RANGE1_ADJUST'
           '    : ((code >= $RANGE2_FIRST) && (code <= $RANGE2_LAST))'
           '      ? code - $RANGE2_ADJUST'
           '      : ((code >= $RANGE3_FIRST) && (code <= $RANGE3_LAST))'
           '        ? code - $RANGE3_ADJUST'
-          '        : $NO_FIELD_CODE'],
+          '        : $NO_FIELD_CODE'),
 
       // if (needsAccessor) {
-      js.if_('code', [
-        js['var getterCode = code & 3'],
-        js['var setterCode = code >> 2'],
-        js['var accessorName = field = field.substring(0, len - 1)'],
+      jsBuilder.if_('code', [
+        js('var getterCode = code & 3'),
+        js('var setterCode = code >> 2'),
+        js('var accessorName = field = field.substring(0, len - 1)'),
 
-        js['var divider = field.indexOf(":")'],
-        js.if_('divider > 0', [  // Colon never in first position.
-          js['accessorName = field.substring(0, divider)'],
-          js['field = field.substring(divider + 1)']
+        js('var divider = field.indexOf(":")'),
+        jsBuilder.if_('divider > 0', [  // Colon never in first position.
+          js('accessorName = field.substring(0, divider)'),
+          js('field = field.substring(divider + 1)')
         ]),
 
         // if (needsGetter) {
-        js.if_('getterCode', [
-          js['var args = (getterCode & 2) ? "$receiverParamName" : ""'],
-          js['var receiver = (getterCode & 1) ? "this" : "$receiverParamName"'],
-          js['var body = "return " + receiver + "." + field'],
-          js['prototype["${namer.getterPrefix}" + accessorName] = '
-                 'new Function(args, body)']
+        jsBuilder.if_('getterCode', [
+          js('var args = (getterCode & 2) ? "$receiverParamName" : ""'),
+          js('var receiver = (getterCode & 1) ? "this" : "$receiverParamName"'),
+          js('var body = "return " + receiver + "." + field'),
+          js('prototype["${namer.getterPrefix}" + accessorName] = '
+                 'new Function(args, body)')
         ]),
 
         // if (needsSetter) {
-        js.if_('setterCode', [
-          js['var args = (setterCode & 2)'
+        jsBuilder.if_('setterCode', [
+          js('var args = (setterCode & 2)'
               '  ? "$receiverParamName,${_}$valueParamName"'
-              '  : "$valueParamName"'],
-          js['var receiver = (setterCode & 1) ? "this" : "$receiverParamName"'],
-          js['var body = receiver + "." + field + "$_=$_$valueParamName"'],
-          js['prototype["${namer.setterPrefix}" + accessorName] = '
-                 'new Function(args, body)']
+              '  : "$valueParamName"'),
+          js('var receiver = (setterCode & 1) ? "this" : "$receiverParamName"'),
+          js('var body = receiver + "." + field + "$_=$_$valueParamName"'),
+          js('prototype["${namer.setterPrefix}" + accessorName] = '
+                 'new Function(args, body)')
         ]),
 
       ]),
 
       // return field;
-      js.return_('field')
+      jsBuilder.return_('field')
     ]);
 
     return new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('generateAccessor'),
         fun);
   }
 
   List get defineClassFunction {
     // First the class name, then the field names in an array and the members
     // (inside an Object literal).
     // The caller can also pass in the constructor as a function if needed.
     //
     // Example:
     // defineClass("A", ["x", "y"], {
     //  foo$1: function(y) {
     //   print(this.x + y);
     //  },
     //  bar$2: function(t, v) {
     //   this.x = t - v;
     //  },
     // });
 
     // function(cls, fields, prototype) {
-    var defineClass = js.fun(['cls', 'fields', 'prototype'], [
-      js['var constructor'],
+    var defineClass = jsBuilder.fun(['cls', 'fields', 'prototype'], [
+      js('var constructor'),
 
       // if (typeof fields == "function") {
-      js.if_(js['typeof fields == "function"'], [
-        js['constructor = fields']
+      jsBuilder.if_(js('typeof fields == "function"'), [
+        js('constructor = fields')
       ], /* else */ [
-        js['var str = "function " + cls + "("'],
-        js['var body = ""'],
+        js('var str = "function " + cls + "("'),
+        js('var body = ""'),
 
         // for (var i = 0; i < fields.length; i++) {
-        js.for_('var i = 0', 'i < fields.length', 'i++', [
+        jsBuilder.for_('var i = 0', 'i < fields.length', 'i++', [
           // if (i != 0) str += ", ";
-          js.if_('i != 0', js['str += ", "']),
+          jsBuilder.if_('i != 0', js('str += ", "')),
 
-          js['var field = fields[i]'],
-          js['field = generateAccessor(field, prototype)'],
-          js['str += field'],
-          js['body += ("this." + field + " = " + field + ";\\n")']
+          js('var field = fields[i]'),
+          js('field = generateAccessor(field, prototype)'),
+          js('str += field'),
+          js('body += ("this." + field + " = " + field + ";\\n")')
         ]),
 
-        js['str += (") {" + body + "}\\nreturn " + cls)'],
+        js('str += (") {" + body + "}\\nreturn " + cls)'),
 
-        js['constructor = (new Function(str))()']
+        js('constructor = (new Function(str))()')
       ]),
 
-      js['constructor.prototype = prototype'],
-      js['constructor.builtin\$cls = cls'],
+      js('constructor.prototype = prototype'),
+      js('constructor.builtin\$cls = cls'),
 
       // return constructor;
-      js.return_('constructor')
+      jsBuilder.return_('constructor')
     ]);
     // Declare a function called "generateAccessor".  This is used in
     // defineClassFunction (it's a local declaration in init()).
     return [
         generateAccessorFunction,
-        js['$generateAccessorHolder = generateAccessor'],
+        js('$generateAccessorHolder = generateAccessor'),
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
   }
 
   /** Needs defineClass to be defined. */
   List buildProtoSupportCheck() {
     // On Firefox and Webkit browsers we can manipulate the __proto__
     // directly. Opera claims to have __proto__ support, but it is buggy.
     // So we have to do more checks.
     // Opera bug was filed as DSK-370158, and fixed as CORE-47615
     // (http://my.opera.com/desktopteam/blog/2012/07/20/more-12-01-fixes).
     // If the browser does not support __proto__ we need to instantiate an
     // object with the correct (internal) prototype set up correctly, and then
     // copy the members.
     // TODO(8541): Remove this work around.
 
     return [
-      js['var $supportsProtoName = false'],
-      js['var tmp = (defineClass("c", ["f?"], {})).prototype'],
+      js('var $supportsProtoName = false'),
+      js('var tmp = (defineClass("c", ["f?"], {})).prototype'),
 
-      js.if_(js['tmp.__proto__'], [
-        js['tmp.__proto__ = {}'],
-        js.if_(js[r'typeof tmp.get$f != "undefined"'],
-               js['$supportsProtoName = true'])
+      jsBuilder.if_(js('tmp.__proto__'), [
+        js('tmp.__proto__ = {}'),
+        jsBuilder.if_(js(r'typeof tmp.get$f != "undefined"'),
+                      js('$supportsProtoName = true'))
 
       ])
     ];
   }
 
   const MAX_MINIFIED_LENGTH_FOR_DIFF_ENCODING = 4;
 
   // If we need fewer than this many noSuchMethod handlers we can save space by
   // just emitting them in JS, rather than emitting the JS needed to generate
   // them at run time.
@@ skipping 130 matching lines @@
     // Startup code that loops over the method names and puts handlers on the
     // Object class to catch noSuchMethod invocations.
     ClassElement objectClass = compiler.objectClass;
     String createInvocationMirror = namer.getName(
         compiler.createInvocationMirrorElement);
     String noSuchMethodName = namer.publicInstanceMethodNameByArity(
         Compiler.NO_SUCH_METHOD, Compiler.NO_SUCH_METHOD_ARG_COUNT);
     var type = 0;
     if (useDiffEncoding) {
       statements.addAll([
-        js['var objectClassObject = '
+        js('var objectClassObject = '
            '        collectedClasses["${namer.getName(objectClass)}"],'
            '    shortNames = "$diffEncoding".split(","),'
            '    nameNumber = 0,'
            '    diffEncodedString = shortNames[0],'
-           '    calculatedShortNames = [0, 1]'],  // 0, 1 are args for splice.
-        js.for_('var i = 0', 'i < diffEncodedString.length', 'i++', [
-          js['var codes = [],'
+           '    calculatedShortNames = [0, 1]'),  // 0, 1 are args for splice.
+        jsBuilder.for_('var i = 0', 'i < diffEncodedString.length', 'i++', [
+          js('var codes = [],'
              '    diff = 0,'
-             '    digit = diffEncodedString.charCodeAt(i)'],
-          js.if_('digit == ${$PERIOD}', [
-            js['nameNumber = 0'],
-            js['digit = diffEncodedString.charCodeAt(++i)']
+             '    digit = diffEncodedString.charCodeAt(i)'),
+          jsBuilder.if_('digit == ${$PERIOD}', [
+            js('nameNumber = 0'),
+            js('digit = diffEncodedString.charCodeAt(++i)')
           ]),
-          js.while_('digit <= ${$Z}', [
-            js['diff *= 26'],
-            js['diff += (digit - ${$A})'],
-            js['digit = diffEncodedString.charCodeAt(++i)']
+          jsBuilder.while_('digit <= ${$Z}', [
+            js('diff *= 26'),
+            js('diff += (digit - ${$A})'),
+            js('digit = diffEncodedString.charCodeAt(++i)')
           ]),
-          js['diff *= 26'],
-          js['diff += (digit - ${$a})'],
-          js['nameNumber += diff'],
-          js.for_('var remaining = nameNumber',
+          js('diff *= 26'),
+          js('diff += (digit - ${$a})'),
+          js('nameNumber += diff'),
+          jsBuilder.for_('var remaining = nameNumber',
                   'remaining > 0',
                   'remaining = ((remaining / 88) | 0)', [
-            js['codes.unshift(${$HASH} + (remaining % 88))']
+            js('codes.unshift(${$HASH} + (remaining % 88))')
           ]),
-          js['calculatedShortNames.push('
-             '    String.fromCharCode.apply(String, codes))']
+          js('calculatedShortNames.push('
+             '    String.fromCharCode.apply(String, codes))')
         ]),
-        js['shortNames.splice.apply(shortNames, calculatedShortNames)']
+        js('shortNames.splice.apply(shortNames, calculatedShortNames)')
       ]);
     } else {
       // No useDiffEncoding version.
       Iterable<String> longs = trivialNsmHandlers.map((selector) =>
              selector.invocationMirrorMemberName);
       String longNamesConstant = minify ? "" :
           ',longNames = "${longs.join(",")}".split(",")';
       statements.add(
-        js['var objectClassObject = '
+        js('var objectClassObject = '
            '        collectedClasses["${namer.getName(objectClass)}"],'
            '    shortNames = "$diffEncoding".split(",")'
-           '    $longNamesConstant']);
+           '    $longNamesConstant'));
     }
 
     String sliceOffset = '," + (j < $firstNormalSelector ? 1 : 0)';
     if (firstNormalSelector == 0) sliceOffset = '"';
     if (firstNormalSelector == shorts.length) sliceOffset = ', 1"';
 
     String whatToPatch = nativeEmitter.handleNoSuchMethod ?
                          "Object.prototype" :
                          "objectClassObject";
 
     statements.addAll([
-      js.for_('var j = 0', 'j < shortNames.length', 'j++', [
-        js['var type = 0'],
-        js['var short = shortNames[j]'],
-        js.if_('short[0] == "${namer.getterPrefix[0]}"', js['type = 1']),
-        js.if_('short[0] == "${namer.setterPrefix[0]}"', js['type = 2']),
-        js['$whatToPatch[short] = Function("'
+      jsBuilder.for_('var j = 0', 'j < shortNames.length', 'j++', [
+        js('var type = 0'),
+        js('var short = shortNames[j]'),
+        jsBuilder.if_('short[0] == "${namer.getterPrefix[0]}"', js('type = 1')),
+        jsBuilder.if_('short[0] == "${namer.setterPrefix[0]}"', js('type = 2')),
+        js('$whatToPatch[short] = Function("'
                'return this.$noSuchMethodName('
                    'this,'
                    '${namer.CURRENT_ISOLATE}.$createInvocationMirror(\'"'
                        ' + ${minify ? "shortNames" : "longNames"}[j]'
                        ' + "\',\'" + short + "\',"'
                        ' + type'
                        ' + ",Array.prototype.slice.call(arguments'
                        '$sliceOffset'
-                       ' + "),[]))")']
+                       ' + "),[]))")')
       ])
     ]);
   }
 
   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.
     //  - the prototype's constructor field points to the JavaScript
     //    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.
 
     List<jsAst.Node> statements = [
-      js['var pendingClasses = {}'],
+      js('var pendingClasses = {}'),
 
-      js['var hasOwnProperty = Object.prototype.hasOwnProperty'],
+      js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
 
       // for (var cls in collectedClasses) {
-      js.forIn('cls', 'collectedClasses', [
+      jsBuilder.forIn('cls', 'collectedClasses', [
         // if (hasOwnProperty.call(collectedClasses, cls)) {
-        js.if_('hasOwnProperty.call(collectedClasses, cls)', [
-          js['var desc = collectedClasses[cls]'],
+        jsBuilder.if_('hasOwnProperty.call(collectedClasses, cls)', [
+          js('var desc = collectedClasses[cls]'),
 
           /* The 'fields' are either a constructor function or a
            * string encoding fields, constructor and superclass.  Get
            * the superclass and the fields in the format
            * Super;field1,field2 from the null-string property on the
            * descriptor.
            */
           // var fields = desc[""], supr;
-          js['var fields = desc[""], supr'],
+          js('var fields = desc[""], supr'),
 
-          js.if_('typeof fields == "string"', [
-            js['var s = fields.split(";")'],
-            js['supr = s[0]'],
-            js['fields = s[1] == "" ? [] : s[1].split(",")'],
+          jsBuilder.if_('typeof fields == "string"', [
+            js('var s = fields.split(";")'),
+            js('supr = s[0]'),
+            js('fields = s[1] == "" ? [] : s[1].split(",")'),
           ], /* else */ [
-            js['supr = desc.super']
+            js('supr = desc.super')
           ]),
 
-          js['isolateProperties[cls] = defineClass(cls, fields, desc)'],
+          js('isolateProperties[cls] = defineClass(cls, fields, desc)'),
 
           // if (supr) pendingClasses[cls] = supr;
-          js.if_('supr', js['pendingClasses[cls] = supr'])
+          jsBuilder.if_('supr', js('pendingClasses[cls] = supr'))
         ])
       ]),
 
-      js['var finishedClasses = {}'],
+      js('var finishedClasses = {}'),
 
       // function finishClass(cls) { ... }
       buildFinishClass(),
     ];
 
     addTrivialNsmHandlers(statements);
 
     statements.add(
       // for (var cls in pendingClasses) finishClass(cls);
-      js.forIn('cls', 'pendingClasses', js['finishClass(cls)'])
+      jsBuilder.forIn('cls', 'pendingClasses', js('finishClass(cls)'))
     );
     // function(collectedClasses,
     //          isolateProperties,
     //          existingIsolateProperties) {
-    return js.fun(['collectedClasses', 'isolateProperties',
-                   'existingIsolateProperties'], statements);
+    return jsBuilder.fun(['collectedClasses', 'isolateProperties',
+                          'existingIsolateProperties'], statements);
   }
 
   jsAst.FunctionDeclaration buildFinishClass() {
     // function finishClass(cls) {
-    jsAst.Fun fun = js.fun(['cls'], [
+    jsAst.Fun fun = jsBuilder.fun(['cls'], [
 
       // TODO(8540): Remove this work around.
       /* Opera does not support 'getOwnPropertyNames'. Therefore we use
          hasOwnProperty instead. */
-      js['var hasOwnProperty = Object.prototype.hasOwnProperty'],
+      js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
 
       // if (hasOwnProperty.call(finishedClasses, cls)) return;
-      js.if_('hasOwnProperty.call(finishedClasses, cls)',
-             js.return_()),
+      jsBuilder.if_('hasOwnProperty.call(finishedClasses, cls)',
+                    jsBuilder.return_()),
 
-      js['finishedClasses[cls] = true'],
+      js('finishedClasses[cls] = true'),
 
-      js['var superclass = pendingClasses[cls]'],
+      js('var superclass = pendingClasses[cls]'),
 
       // The superclass is only false (empty string) for Dart's Object class.
       // The minifier together with noSuchMethod can put methods on the
       // Object.prototype object, and they show through here, so we check that
       // we have a string.
-      js.if_('!superclass || typeof superclass != "string"', js.return_()),
-      js['finishClass(superclass)'],
-      js['var constructor = isolateProperties[cls]'],
-      js['var superConstructor = isolateProperties[superclass]'],
+      jsBuilder.if_('!superclass || typeof superclass != "string"',
+                    jsBuilder.return_()),
+      js('finishClass(superclass)'),
+      js('var constructor = isolateProperties[cls]'),
+      js('var superConstructor = isolateProperties[superclass]'),
 
       // if (!superConstructor)
       //   superConstructor = existingIsolateProperties[superclass];
-      js.if_(js['superConstructor'].not,
-             js['superConstructor'].assign(
-                 js['existingIsolateProperties'][js['superclass']])),
+      jsBuilder.if_(js('superConstructor').not,
+                    js('superConstructor').assign(
+                        js('existingIsolateProperties')[js('superclass')])),
 
-      js['var prototype = constructor.prototype'],
+      js('var prototype = constructor.prototype'),
 
       // if ($supportsProtoName) {
-      js.if_(supportsProtoName, [
-        js['prototype.__proto__ = superConstructor.prototype'],
-        js['prototype.constructor = constructor'],
+      jsBuilder.if_(supportsProtoName, [
+        js('prototype.__proto__ = superConstructor.prototype'),
+        js('prototype.constructor = constructor'),
 
       ], /* else */ [
         // function tmp() {};
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('tmp'),
-            js.fun([], [])),
+            jsBuilder.fun([], [])),
 
-        js['tmp.prototype = superConstructor.prototype'],
-        js['var newPrototype = new tmp()'],
+        js('tmp.prototype = superConstructor.prototype'),
+        js('var newPrototype = new tmp()'),
 
-        js['constructor.prototype = newPrototype'],
-        js['newPrototype.constructor = constructor'],
+        js('constructor.prototype = newPrototype'),
+        js('newPrototype.constructor = constructor'),
 
         // for (var member in prototype) {
-        js.forIn('member', 'prototype', [
+        jsBuilder.forIn('member', 'prototype', [
           /* Short version of: if (member == '') */
           // if (!member) continue;
-          js.if_('!member', new jsAst.Continue(null)),
+          jsBuilder.if_('!member', new jsAst.Continue(null)),
 
           // if (hasOwnProperty.call(prototype, member)) {
-          js.if_('hasOwnProperty.call(prototype, member)', [
-            js['newPrototype[member] = prototype[member]']
+          jsBuilder.if_('hasOwnProperty.call(prototype, member)', [
+            js('newPrototype[member] = prototype[member]')
           ])
         ])
 
       ])
     ]);
 
     return new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('finishClass'),
         fun);
   }
@@ skipping 18 matching lines @@
     // which is then dynamically evaluated:
     //   var newIsolate = new Function(str);
     //
     // We also copy over old values like the prototype, and the
     // isolateProperties themselves.
 
     List copyFinishClasses = [];
     if (needsDefineClass) {
       copyFinishClasses.add(
           // newIsolate.$finishClasses = oldIsolate.$finishClasses;
-          js['newIsolate'][finishClassesProperty].assign(
-              js['oldIsolate'][finishClassesProperty]));
+          js('newIsolate')[finishClassesProperty].assign(
+              js('oldIsolate')[finishClassesProperty]));
     }
 
     // function(oldIsolate) {
-    return js.fun('oldIsolate', [
-      js['var isolateProperties = oldIsolate.${namer.isolatePropertiesName}'],
+    return jsBuilder.fun('oldIsolate', [
+      js('var isolateProperties = oldIsolate.${namer.isolatePropertiesName}'),
 
-      js[r'isolateProperties.$currentScript ='
+      js(r'isolateProperties.$currentScript ='
               'typeof document == "object" ?'
               '(document.currentScript ||'
                      'document.scripts[document.scripts.length - 1]) :'
-              'null'],
+              'null'),
 
-      js['var isolatePrototype = oldIsolate.prototype'],
-      js['var str = "{\\n"'],
-      js['str += '
-             '"var properties = $isolate.${namer.isolatePropertiesName};\\n"'],
-      js['var hasOwnProperty = Object.prototype.hasOwnProperty'],
+      js('var isolatePrototype = oldIsolate.prototype'),
+      js('var str = "{\\n"'),
+      js('str += '
+             '"var properties = $isolate.${namer.isolatePropertiesName};\\n"'),
+      js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
 
       // for (var staticName in isolateProperties) {
-      js.forIn('staticName', 'isolateProperties', [
-        js.if_('hasOwnProperty.call(isolateProperties, staticName)', [
-          js['str += ("this." + staticName + "= properties." + staticName + '
-                          '";\\n")']
+      jsBuilder.forIn('staticName', 'isolateProperties', [
+        jsBuilder.if_('hasOwnProperty.call(isolateProperties, staticName)', [
+          js('str += ("this." + staticName + "= properties." + staticName + '
+                          '";\\n")')
         ])
       ]),
 
-      js['str += "}\\n"'],
+      js('str += "}\\n"'),
 
-      js['var newIsolate = new Function(str)'],
-      js['newIsolate.prototype = isolatePrototype'],
-      js['isolatePrototype.constructor = newIsolate'],
-      js['newIsolate.${namer.isolatePropertiesName} = isolateProperties'],
+      js('var newIsolate = new Function(str)'),
+      js('newIsolate.prototype = isolatePrototype'),
+      js('isolatePrototype.constructor = newIsolate'),
+      js('newIsolate.${namer.isolatePropertiesName} = isolateProperties'),
     ]..addAll(copyFinishClasses)
      ..addAll([
 
       // return newIsolate;
-      js.return_('newIsolate')
+      jsBuilder.return_('newIsolate')
     ]));
   }
 
   jsAst.Fun get lazyInitializerFunction {
     String isolate = namer.CURRENT_ISOLATE;
 
     // function(prototype, staticName, fieldName, getterName, lazyValue) {
     var parameters = <String>['prototype', 'staticName', 'fieldName',
                               'getterName', 'lazyValue'];
-    return js.fun(parameters, [
-      js['var getter = new Function("{ return $isolate." + fieldName + ";}")'],
+    return jsBuilder.fun(parameters, [
+      js('var getter = new Function("{ return $isolate." + fieldName + ";}")'),
     ]..addAll(addLazyInitializerLogic())
     );
   }
 
   List addLazyInitializerLogic() {
     String isolate = namer.CURRENT_ISOLATE;
     String cyclicThrow = namer.isolateAccess(backend.getCyclicThrowHelper());
 
     return [
-      js['var sentinelUndefined = {}'],
-      js['var sentinelInProgress = {}'],
-      js['prototype[fieldName] = sentinelUndefined'],
+      js('var sentinelUndefined = {}'),
+      js('var sentinelInProgress = {}'),
+      js('prototype[fieldName] = sentinelUndefined'),
 
       // prototype[getterName] = function() {
-      js['prototype'][js['getterName']].assign(js.fun([], [
-        js['var result = $isolate[fieldName]'],
+      js('prototype')[js('getterName')].assign(jsBuilder.fun([], [
+        js('var result = $isolate[fieldName]'),
 
         // try {
-        js.try_([
-          js.if_('result === sentinelUndefined', [
-            js['$isolate[fieldName] = sentinelInProgress'],
+        jsBuilder.try_([
+          jsBuilder.if_('result === sentinelUndefined', [
+            js('$isolate[fieldName] = sentinelInProgress'),
 
             // try {
-            js.try_([
-              js['result = $isolate[fieldName] = lazyValue()'],
+            jsBuilder.try_([
+              js('result = $isolate[fieldName] = lazyValue()'),
 
             ], finallyPart: [
               // Use try-finally, not try-catch/throw as it destroys the
               // stack trace.
 
               // if (result === sentinelUndefined) {
-              js.if_('result === sentinelUndefined', [
+              jsBuilder.if_('result === sentinelUndefined', [
                 // if ($isolate[fieldName] === sentinelInProgress) {
-                js.if_('$isolate[fieldName] === sentinelInProgress', [
-                  js['$isolate[fieldName] = null'],
+                jsBuilder.if_('$isolate[fieldName] === sentinelInProgress', [
+                  js('$isolate[fieldName] = null'),
                 ])
               ])
             ])
           ], /* else */ [
-            js.if_('result === sentinelInProgress',
-              js['$cyclicThrow(staticName)']
+            jsBuilder.if_('result === sentinelInProgress',
+              js('$cyclicThrow(staticName)')
             )
           ]),
 
           // return result;
-          js.return_('result')
+          jsBuilder.return_('result')
 
         ], finallyPart: [
-          js['$isolate[getterName] = getter']
+          js('$isolate[getterName] = getter')
         ])
       ]))
     ];
   }
 
   List buildDefineClassAndFinishClassFunctionsIfNecessary() {
     if (!needsDefineClass) return [];
     return defineClassFunction
     ..addAll(buildProtoSupportCheck())
     ..addAll([
-      js[finishClassesName].assign(finishClassesFunction)
+      js(finishClassesName).assign(finishClassesFunction)
     ]);
   }
 
   List buildLazyInitializerFunctionIfNecessary() {
     if (!needsLazyInitializer) return [];
 
     // $lazyInitializerName = $lazyInitializerFunction
-    return [js[lazyInitializerName].assign(lazyInitializerFunction)];
+    return [js(lazyInitializerName).assign(lazyInitializerFunction)];
   }
 
   List buildFinishIsolateConstructor() {
     return [
       // $finishIsolateConstructorName = $finishIsolateConstructorFunction
-      js[finishIsolateConstructorName].assign(finishIsolateConstructorFunction)
+      js(finishIsolateConstructorName).assign(finishIsolateConstructorFunction)
     ];
   }
 
   void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
     String isolate = namer.isolateName;
     buffer.write("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
 
   /**
    * Generate stubs to handle invocation of methods with optional
@@ skipping 41 matching lines @@
         new List<jsAst.Parameter>(selector.argumentCount + extraArgumentCount);
     // The arguments that will be passed to the real method.
     List<jsAst.Expression> argumentsBuffer =
         new List<jsAst.Expression>(
             parameters.parameterCount + extraArgumentCount);
 
     int count = 0;
     if (isInterceptedMethod) {
       count++;
       parametersBuffer[0] = new jsAst.Parameter(receiverArgumentName);
-      argumentsBuffer[0] = js[receiverArgumentName];
+      argumentsBuffer[0] = js(receiverArgumentName);
     }
 
     int optionalParameterStart = positionalArgumentCount + extraArgumentCount;
     // Includes extra receiver argument when using interceptor convention
     int indexOfLastOptionalArgumentInParameters = optionalParameterStart - 1;
 
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(member);
 
     parameters.orderedForEachParameter((Element element) {
       String jsName = backend.namer.safeName(element.name.slowToString());
       assert(jsName != receiverArgumentName);
       if (count < optionalParameterStart) {
         parametersBuffer[count] = new jsAst.Parameter(jsName);
-        argumentsBuffer[count] = js[jsName];
+        argumentsBuffer[count] = js(jsName);
       } else {
         int index = names.indexOf(element.name);
         if (index != -1) {
           indexOfLastOptionalArgumentInParameters = count;
           // The order of the named arguments is not the same as the
           // one in the real method (which is in Dart source order).
-          argumentsBuffer[count] = js[jsName];
+          argumentsBuffer[count] = js(jsName);
           parametersBuffer[optionalParameterStart + index] =
               new jsAst.Parameter(jsName);
         // Note that [elements] may be null for a synthesized [member].
         } else if (elements != null && elements.isParameterChecked(element)) {
           argumentsBuffer[count] = constantReference(SentinelConstant.SENTINEL);
         } else {
           Constant value = handler.initialVariableValues[element];
           if (value == null) {
             argumentsBuffer[count] = constantReference(new NullConstant());
           } else {
             if (!value.isNull()) {
               // If the value is the null constant, we should not pass it
               // down to the native method.
               indexOfLastOptionalArgumentInParameters = count;
             }
             argumentsBuffer[count] = constantReference(value);
           }
         }
       }
       count++;
     });
 
     List body;
     if (member.hasFixedBackendName()) {
       body = nativeEmitter.generateParameterStubStatements(
           member, isInterceptedMethod, invocationName,
           parametersBuffer, argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
     } else {
-      body = [js.return_(js['this'][namer.getName(member)](argumentsBuffer))];
+      String name = namer.getName(member);
+      body = [jsBuilder.return_(js('this')[name](argumentsBuffer))];
     }
 
-    jsAst.Fun function = js.fun(parametersBuffer, body);
+    jsAst.Fun function = jsBuilder.fun(parametersBuffer, body);
 
     defineStub(invocationName, function);
   }
 
   void addParameterStubs(FunctionElement member,
                          DefineStubFunction defineStub) {
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, {c, d});
     //
@@ skipping 199 matching lines @@
         includeBackendMembers: true,
         includeSuperMembers: false);
 
     void generateIsTest(Element other) {
       jsAst.Expression code;
       if (other == compiler.objectClass && other != classElement) {
         // Avoid emitting [:$isObject:] on all classes but [Object].
         return;
       }
       if (nativeEmitter.requiresNativeIsCheck(other)) {
-        code = js.fun([], [js.return_(true)]);
+        code = jsBuilder.fun([], [jsBuilder.return_(true)]);
       } else {
         code = new jsAst.LiteralBool(true);
       }
       builder.addProperty(namer.operatorIs(other), code);
     }
 
     void generateSubstitution(Element other, {bool emitNull: false}) {
       RuntimeTypes rti = backend.rti;
       // TODO(karlklose): support typedefs with variables.
       jsAst.Expression expression;
       bool needsNativeCheck = nativeEmitter.requiresNativeIsCheck(other);
       if (other.kind == ElementKind.CLASS) {
         String substitution = rti.getSupertypeSubstitution(classElement, other,
             alwaysGenerateFunction: true);
         if (substitution != null) {
           expression = new jsAst.LiteralExpression(substitution);
         } else if (emitNull || needsNativeCheck) {
           expression = new jsAst.LiteralNull();
         }
       }
       if (expression != null) {
         if (needsNativeCheck) {
-          expression = js.fun([], js.return_(expression));
+          expression = jsBuilder.fun([], jsBuilder.return_(expression));
         }
         builder.addProperty(namer.substitutionName(other), expression);
       }
     }
 
     generateIsTestsOn(classElement, generateIsTest, generateSubstitution);
 
     if (identical(classElement, compiler.objectClass)
         && compiler.enabledNoSuchMethod) {
       // Emit the noSuchMethod handlers on the Object prototype now,
@@ skipping 48 matching lines @@
     }
 
     // Add checks to the constructors of instantiated classes or to the created
     // holder object.
     for (ClassElement cls in typeChecks) {
       String holder = namer.isolateAccess(cls);
       for (ClassElement check in typeChecks[cls]) {
         buffer.write('$holder.${namer.operatorIs(check)}$_=${_}true$N');
         String body = rti.getSupertypeSubstitution(cls, check);
         if (body != null) {
-          buffer.write('$holder.${namer.substitutionName(check)}$_=${_}$body$N');
+          buffer.write(
+              '$holder.${namer.substitutionName(check)}$_=${_}$body$N');
         }
       };
     }
   }
 
   void visitNativeMixins(ClassElement classElement,
                          void visit(MixinApplicationElement mixinApplication)) {
     if (!classElement.isNative()) return;
     // Use recursion to make sure to visit the superclasses before the
     // subclasses. Once we start keeping track of the emitted fields
@@ skipping 106 matching lines @@
 
   void generateGetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String getterName = namer.getterNameFromAccessorName(accessorName);
     String receiver = backend.isInterceptorClass(member.getEnclosingClass())
         ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member)
         ? ['receiver']
         : [];
     builder.addProperty(getterName,
-        js.fun(args, js.return_(js['$receiver.$fieldName'])));
+        jsBuilder.fun(args, jsBuilder.return_(js('$receiver.$fieldName'))));
   }
 
   void generateSetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
     String setterName = namer.setterNameFromAccessorName(accessorName);
     String receiver = backend.isInterceptorClass(member.getEnclosingClass())
         ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member)
         ? ['receiver', 'v']
         : ['v'];
     builder.addProperty(setterName,
-        js.fun(args, js[receiver][fieldName].assign('v')));
+        jsBuilder.fun(args, js(receiver)[fieldName].assign('v')));
   }
 
   bool canGenerateCheckedSetter(Element member) {
     DartType type = member.computeType(compiler);
     if (type.element.isTypeVariable()
         || type.element == compiler.dynamicClass
         || type.element == compiler.objectClass) {
       // TODO(ngeoffray): Support type checks on type parameters.
       return false;
     }
     return true;
   }
 
   void generateCheckedSetter(Element member,
                              String fieldName,
                              String accessorName,
                              ClassBuilder builder) {
     assert(canGenerateCheckedSetter(member));
     DartType type = member.computeType(compiler);
     // TODO(ahe): Generate a dynamic type error here.
     if (type.element.isErroneous()) return;
     FunctionElement helperElement
         = backend.getCheckedModeHelper(type, typeCast: false);
     String helperName = namer.isolateAccess(helperElement);
-    List<jsAst.Expression> arguments = <jsAst.Expression>[js['v']];
+    List<jsAst.Expression> arguments = <jsAst.Expression>[js('v')];
     if (helperElement.computeSignature(compiler).parameterCount != 1) {
-      arguments.add(js.string(namer.operatorIs(type.element)));
+      arguments.add(jsBuilder.string(namer.operatorIs(type.element)));
     }
 
     String setterName = namer.setterNameFromAccessorName(accessorName);
     String receiver = backend.isInterceptorClass(member.getEnclosingClass())
         ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member)
         ? ['receiver', 'v']
         : ['v'];
     builder.addProperty(setterName,
-        js.fun(args,
-            js[receiver][fieldName].assign(js[helperName](arguments))));
+        jsBuilder.fun(
+            args, js(receiver)[fieldName].assign(js(helperName)(arguments))));
   }
 
   void emitClassConstructor(ClassElement classElement, ClassBuilder builder) {
     /* Do nothing. */
   }
 
   void emitSuper(String superName, ClassBuilder builder) {
     /* Do nothing. */
   }
 
@@ skipping 60 matching lines @@
             assert(setterCode != 0);
           }
           int code = getterCode + (setterCode << 2);
           buffer.write(FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE]);
         }
       }
     });
 
     bool fieldsAdded = buffer.length > bufferClassLength;
     String compactClassData = buffer.toString();
-    builder.addProperty('', js.string(compactClassData));
+    builder.addProperty('', jsBuilder.string(compactClassData));
     return fieldsAdded;
   }
 
   void emitClassGettersSetters(ClassElement classElement,
                                ClassBuilder builder) {
 
     visitClassFields(classElement, (Element member,
                                     String name,
                                     String accessorName,
                                     bool needsGetter,
@@ skipping 42 matching lines @@
     ClassBuilder builder = new ClassBuilder();
 
     emitClassConstructor(classElement, builder);
     emitSuper(superName, builder);
     emitClassFields(classElement, builder,
                     superClass: superName, classIsNative: false);
     emitClassGettersSetters(classElement, builder);
     emitInstanceMembers(classElement, builder);
 
     jsAst.Expression init =
-        js[classesCollector][className].assign(builder.toObjectInitializer());
+        js(classesCollector)[className].assign(builder.toObjectInitializer());
     buffer.write(jsAst.prettyPrint(init, compiler));
     buffer.write('$N$n');
   }
 
   bool get getterAndSetterCanBeImplementedByFieldSpec => true;
 
   /// If this is true then we can generate the noSuchMethod handlers at startup
   /// time, instead of them being emitted as part of the Object class.
   bool get generateTrivialNsmHandlers => true;
 
@@ skipping 202 matching lines @@
 
       // Reset the map.
       buffer.write("$classesCollector$_=${_}null$N$n");
     }
   }
 
   void emitStaticFunction(CodeBuffer buffer,
                           String name,
                           jsAst.Expression functionExpression) {
     jsAst.Expression assignment =
-        js[isolateProperties][name].assign(functionExpression);
+        js(isolateProperties)[name].assign(functionExpression);
     buffer.write(jsAst.prettyPrint(assignment, compiler));
     buffer.write('$N$n');
   }
 
   void emitStaticFunctions(CodeBuffer eagerBuffer) {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
@@ skipping 36 matching lines @@
       FunctionElement callElement =
           new ClosureInvocationElement(namer.closureInvocationSelectorName,
                                        element);
       String staticName = namer.getName(element);
       String invocationName = namer.instanceMethodName(callElement);
       String fieldAccess = '$isolateProperties.$staticName';
       buffer.write("$fieldAccess.$invocationName$_=$_$fieldAccess$N");
 
       addParameterStubs(callElement, (String name, jsAst.Expression value) {
         jsAst.Expression assignment =
-            js[isolateProperties][staticName][name].assign(value);
+            js(isolateProperties)[staticName][name].assign(value);
         buffer.write(jsAst.prettyPrint(assignment.toStatement(), compiler));
         buffer.write('$N');
       });
 
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.write('$fieldAccess.$fieldName$_=$_"$staticName"$N');
       getTypedefChecksOn(element.computeType(compiler)).forEach(
         (Element typedef) {
           String operator = namer.operatorIs(typedef);
           buffer.write('$fieldAccess.$operator$_=${_}true$N');
         }
       );
     }
   }
 
   void emitBoundClosureClassHeader(String mangledName,
                                    String superName,
                                    List<String> fieldNames,
                                    ClassBuilder builder) {
     builder.addProperty('',
-        js.string("$superName;${fieldNames.join(',')}"));
+        jsBuilder.string("$superName;${fieldNames.join(',')}"));
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitDynamicFunctionGetter(FunctionElement member,
                                  DefineStubFunction defineStub) {
     assert(invariant(member, member.isDeclaration));
@@ skipping 78 matching lines @@
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(namer.closureInvocationSelectorName,
                                        member);
 
       String invocationName = namer.instanceMethodName(callElement);
 
       List<String> parameters = <String>[];
       List<jsAst.Expression> arguments = <jsAst.Expression>[];
       if (inInterceptor) {
-        arguments.add(js['this'][fieldNames[2]]);
+        arguments.add(js('this')[fieldNames[2]]);
       }
       for (int i = 0; i < parameterCount; i++) {
         String name = 'p$i';
         parameters.add(name);
-        arguments.add(js[name]);
+        arguments.add(js(name));
       }
 
-      jsAst.Expression fun = js.fun(
+      jsAst.Expression fun = jsBuilder.fun(
           parameters,
-          js.return_(
-              js['this'][fieldNames[0]][js['this'][fieldNames[1]]](arguments)));
+          jsBuilder.return_(
+              js('this')[fieldNames[0]][js('this')[fieldNames[1]]](arguments)));
       boundClosureBuilder.addProperty(invocationName, fun);
 
       addParameterStubs(callElement, boundClosureBuilder.addProperty);
       typedefChecks.forEach((Element typedef) {
         String operator = namer.operatorIs(typedef);
         boundClosureBuilder.addProperty(operator, new jsAst.LiteralBool(true));
       });
 
       boundClosures.add(
-          js[classesCollector][mangledName].assign(
+          js(classesCollector)[mangledName].assign(
               boundClosureBuilder.toObjectInitializer()));
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (canBeShared) {
         cache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
     String getterName = namer.getterName(member);
     String targetName = namer.instanceMethodName(member);
 
     List<String> parameters = <String>[];
     List<jsAst.Expression> arguments = <jsAst.Expression>[];
-    arguments.add(js['this']);
-    arguments.add(js.string(targetName));
+    arguments.add(js('this'));
+    arguments.add(jsBuilder.string(targetName));
     if (inInterceptor) {
       parameters.add(extraArg);
-      arguments.add(js[extraArg]);
+      arguments.add(js(extraArg));
     }
 
-    jsAst.Expression getterFunction = js.fun(
+    jsAst.Expression getterFunction = jsBuilder.fun(
         parameters,
-        js.return_(js[closureClass].newWith(arguments)));
+        jsBuilder.return_(js(closureClass).newWith(arguments)));
 
     defineStub(getterName, getterFunction);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              DefineStubFunction defineStub) {
     assert(invariant(member, member.isDeclaration));
     LibraryElement memberLibrary = member.getLibrary();
     // If the method is intercepted, the stub gets the
     // receiver explicitely and we need to pass it to the getter call.
     bool isInterceptedMethod = backend.isInterceptedMethod(member);
 
     const String receiverArgumentName = r'$receiver';
 
     jsAst.Expression buildGetter() {
       if (member.isGetter()) {
         String getterName = namer.getterName(member);
-        return js['this'][getterName](
+        return js('this')[getterName](
             isInterceptedMethod
-                ? <jsAst.Expression>[js[receiverArgumentName]]
+                ? <jsAst.Expression>[js(receiverArgumentName)]
                 : <jsAst.Expression>[]);
       } else {
         String fieldName = member.hasFixedBackendName()
             ? member.fixedBackendName()
             : namer.instanceFieldName(member);
-        return js['this'][fieldName];
+        return js('this')[fieldName];
       }
     }
 
     // Two selectors may match but differ only in type.  To avoid generating
     // identical stubs for each we track untyped selectors which already have
     // stubs.
     Set<Selector> generatedSelectors = new Set<Selector>();
 
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         selector = selector.asUntyped;
         if (generatedSelectors.contains(selector)) continue;
         generatedSelectors.add(selector);
 
         String invocationName = namer.invocationName(selector);
         Selector callSelector = new Selector.callClosureFrom(selector);
         String closureCallName = namer.invocationName(callSelector);
 
         List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
         List<jsAst.Expression> arguments = <jsAst.Expression>[];
         if (isInterceptedMethod) {
           parameters.add(new jsAst.Parameter(receiverArgumentName));
         }
 
         for (int i = 0; i < selector.argumentCount; i++) {
           String name = 'arg$i';
           parameters.add(new jsAst.Parameter(name));
-          arguments.add(js[name]);
+          arguments.add(js(name));
         }
 
-        jsAst.Fun function = js.fun(
+        jsAst.Fun function = jsBuilder.fun(
             parameters,
-            js.return_(buildGetter()[closureCallName](arguments)));
+            jsBuilder.return_(buildGetter()[closureCallName](arguments)));
 
         defineStub(invocationName, function);
       }
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       // [:interceptedNames:] is handled in [emitInterceptedNames].
       if (element == backend.interceptedNames) continue;
       compiler.withCurrentElement(element, () {
         Constant initialValue = handler.getInitialValueFor(element);
         jsAst.Expression init =
-          js[isolateProperties][namer.getName(element)].assign(
+          js(isolateProperties)[namer.getName(element)].assign(
               constantEmitter.referenceInInitializationContext(initialValue));
         buffer.write(jsAst.prettyPrint(init, compiler));
         buffer.write('$N');
       });
     }
   }
 
   void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
       for (VariableElement element in Elements.sortedByPosition(lazyFields)) {
         assert(backend.generatedBailoutCode[element] == null);
         jsAst.Expression code = backend.generatedCode[element];
         // The code is null if we ended up not needing the lazily
         // initialized field after all because of constant folding
         // before code generation.
         if (code == null) continue;
         // The code only computes the initial value. We build the lazy-check
         // here:
         //   lazyInitializer(prototype, 'name', fieldName, getterName, initial);
         // The name is used for error reporting. The 'initial' must be a
         // closure that constructs the initial value.
         List<jsAst.Expression> arguments = <jsAst.Expression>[];
-        arguments.add(js[isolateProperties]);
-        arguments.add(js.string(element.name.slowToString()));
-        arguments.add(js.string(namer.getName(element)));
-        arguments.add(js.string(namer.getLazyInitializerName(element)));
+        arguments.add(js(isolateProperties));
+        arguments.add(jsBuilder.string(element.name.slowToString()));
+        arguments.add(jsBuilder.string(namer.getName(element)));
+        arguments.add(jsBuilder.string(namer.getLazyInitializerName(element)));
         arguments.add(code);
         jsAst.Expression getter = buildLazyInitializedGetter(element);
         if (getter != null) {
           arguments.add(getter);
         }
-        jsAst.Expression init = js[lazyInitializerName](arguments);
+        jsAst.Expression init = js(lazyInitializerName)(arguments);
         buffer.write(jsAst.prettyPrint(init, compiler));
         buffer.write("$N");
       }
     }
   }
 
   jsAst.Expression buildLazyInitializedGetter(VariableElement element) {
     // Nothing to do, the 'lazy' function will create the getter.
     return null;
   }
@@ skipping 12 matching lines @@
       // The name is null when the constant is already a JS constant.
       // TODO(floitsch): every constant should be registered, so that we can
       // share the ones that take up too much space (like some strings).
       if (name == null) continue;
       if (!addedMakeConstantList && constant.isList()) {
         addedMakeConstantList = true;
         emitMakeConstantList(eagerBuffer);
       }
       CodeBuffer buffer =
           bufferForElement(constant.computeType(compiler).element, eagerBuffer);
-      jsAst.Expression init = js[isolateProperties][name].assign(
+      jsAst.Expression init = js(isolateProperties)[name].assign(
           constantInitializerExpression(constant));
       buffer.write(jsAst.prettyPrint(init, compiler));
       buffer.write('$N');
     }
   }
 
   void emitMakeConstantList(CodeBuffer buffer) {
     buffer.write(namer.isolateName);
     buffer.write(r'''.makeConstantList = function(list) {
   list.immutable$list = true;
@@ skipping 156 matching lines @@
       // Values match JSInvocationMirror in js-helper library.
       int type = selector.invocationMirrorKind;
       List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
       CodeBuffer args = new CodeBuffer();
       for (int i = 0; i < selector.argumentCount; i++) {
         parameters.add(new jsAst.Parameter('\$$i'));
       }
 
       List<jsAst.Expression> argNames =
           selector.getOrderedNamedArguments().map((SourceString name) =>
-              js.string(name.slowToString())).toList();
+              jsBuilder.string(name.slowToString())).toList();
 
       String methodName = selector.invocationMirrorMemberName;
       String internalName = namer.invocationMirrorInternalName(selector);
       if (!haveVeryFewNoSuchMemberHandlers &&
           isTrivialNsmHandler(type, argNames, selector, internalName)) {
         trivialNsmHandlers.add(selector);
         return null;
       }
 
       String createInvocationMirror = namer.getName(
           compiler.createInvocationMirrorElement);
 
       assert(backend.isInterceptedName(Compiler.NO_SUCH_METHOD));
-      jsAst.Expression expression = js['this.$noSuchMethodName'](
-          [js['this'],
-           js[namer.CURRENT_ISOLATE][createInvocationMirror]([
-               js.string(compiler.enableMinification ?
+      jsAst.Expression expression = js('this.$noSuchMethodName')(
+          [js('this'),
+           js(namer.CURRENT_ISOLATE)[createInvocationMirror]([
+               jsBuilder.string(compiler.enableMinification ?
                          internalName : methodName),
-               js.string(internalName),
+               jsBuilder.string(internalName),
                type,
                new jsAst.ArrayInitializer.from(
-                   parameters.map((param) => js[param.name]).toList()),
+                   parameters.map((param) => js(param.name)).toList()),
                new jsAst.ArrayInitializer.from(argNames)])]);
       parameters = backend.isInterceptedName(selector.name)
           ? ([new jsAst.Parameter('\$receiver')]..addAll(parameters))
           : parameters;
-      return js.fun(parameters, js.return_(expression));
+      return jsBuilder.fun(parameters, jsBuilder.return_(expression));
     }
 
     for (String jsName in addedJsNames.keys.toList()..sort()) {
       Selector selector = addedJsNames[jsName];
       jsAst.Expression method = generateMethod(jsName, selector);
       if (method != null) defineStub(jsName, method);
     }
   }
 
   String buildIsolateSetup(CodeBuffer buffer,
@@ skipping 42 matching lines @@
   }
 }
 """);
     addComment('END invoke [main].', buffer);
   }
 
   void emitGetInterceptorMethod(CodeBuffer buffer,
                                 String key,
                                 Collection<ClassElement> classes) {
     jsAst.Statement buildReturnInterceptor(ClassElement cls) {
-      return js.return_(js[namer.isolateAccess(cls)]['prototype']);
+      return jsBuilder.return_(js(namer.isolateAccess(cls))['prototype']);
     }
 
     /**
      * Build a JavaScrit AST node for doing a type check on
      * [cls]. [cls] must be an interceptor class.
      */
     jsAst.Statement buildInterceptorCheck(ClassElement cls) {
       jsAst.Expression condition;
       assert(backend.isInterceptorClass(cls));
       if (cls == backend.jsBoolClass) {
-        condition = js['(typeof receiver) == "boolean"'];
+        condition = js('(typeof receiver) == "boolean"');
       } else if (cls == backend.jsIntClass ||
                  cls == backend.jsDoubleClass ||
                  cls == backend.jsNumberClass) {
         throw 'internal error';
       } else if (cls == backend.jsArrayClass ||
                  cls == backend.jsMutableArrayClass ||
                  cls == backend.jsFixedArrayClass ||
                  cls == backend.jsExtendableArrayClass) {
-        condition = js['receiver.constructor == Array'];
+        condition = js('receiver.constructor == Array');
       } else if (cls == backend.jsStringClass) {
-        condition = js['(typeof receiver) == "string"'];
+        condition = js('(typeof receiver) == "string"');
       } else if (cls == backend.jsNullClass) {
-        condition = js['receiver == null'];
+        condition = js('receiver == null');
       } else if (cls == backend.jsFunctionClass) {
-        condition = js['(typeof receiver) == "function"'];
+        condition = js('(typeof receiver) == "function"');
       } else {
         throw 'internal error';
       }
-      return js.if_(condition, buildReturnInterceptor(cls));
+      return jsBuilder.if_(condition, buildReturnInterceptor(cls));
     }
 
     bool hasArray = false;
     bool hasBool = false;
     bool hasDouble = false;
     bool hasFunction = false;
     bool hasInt = false;
     bool hasNull = false;
     bool hasNumber = false;
     bool hasString = false;
@@ skipping 35 matching lines @@
       jsAst.Statement whenNumber;
 
       /// Note: there are two number classes in play: Dart's [num],
       /// and JavaScript's Number (typeof receiver == 'number').  This
       /// is the fallback used when we have determined that receiver
       /// is a JavaScript Number.
       jsAst.Return returnNumberClass = buildReturnInterceptor(
           hasDouble ? backend.jsDoubleClass : backend.jsNumberClass);
 
       if (hasInt) {
-        jsAst.Expression isInt = js['Math.floor(receiver) == receiver'];
-        whenNumber = js.block([
-            js.if_(isInt, buildReturnInterceptor(backend.jsIntClass)),
+        jsAst.Expression isInt = js('Math.floor(receiver) == receiver');
+        whenNumber = jsBuilder.block([
+            jsBuilder.if_(isInt, buildReturnInterceptor(backend.jsIntClass)),
             returnNumberClass]);
       } else {
         whenNumber = returnNumberClass;
       }
       block.statements.add(
-          js.if_('(typeof receiver) == "number"',
+          jsBuilder.if_('(typeof receiver) == "number"',
                  whenNumber));
     }
 
     if (hasString) {
       block.statements.add(buildInterceptorCheck(backend.jsStringClass));
     }
     if (hasNull) {
       block.statements.add(buildInterceptorCheck(backend.jsNullClass));
     } else {
       // Returning "undefined" or "null" here will provoke a JavaScript
       // TypeError which is later identified as a null-error by
       // [unwrapException] in js_helper.dart.
-      block.statements.add(js.if_('receiver == null',
-                                  js.return_(js['receiver'])));
+      block.statements.add(jsBuilder.if_('receiver == null',
+                                  jsBuilder.return_(js('receiver'))));
     }
     if (hasFunction) {
       block.statements.add(buildInterceptorCheck(backend.jsFunctionClass));
     }
     if (hasBool) {
       block.statements.add(buildInterceptorCheck(backend.jsBoolClass));
     }
     // TODO(ahe): It might be faster to check for Array before
     // function and bool.
     if (hasArray) {
       block.statements.add(buildInterceptorCheck(backend.jsArrayClass));
     }
 
     if (hasNative) {
       block.statements.add(
-          js.if_(
-              js['(typeof receiver) != "object"'],
-              js.return_(js['receiver'])));
+          jsBuilder.if_(
+              js('(typeof receiver) != "object"'),
+              jsBuilder.return_(js('receiver'))));
 
       // if (receiver instanceof $.Object) return receiver;
       // return $.getNativeInterceptor(receiver);
       block.statements.add(
-          js.if_(
+          jsBuilder.if_(
               new jsAst.Binary(
                   "instanceof",
-                  js['receiver'],
-                  js[namer.isolateAccess(compiler.objectClass)]),
-              js.return_(js['receiver'])));
+                  js('receiver'),
+                  js(namer.isolateAccess(compiler.objectClass))),
+              jsBuilder.return_(js('receiver'))));
 
       // TODO(sra): Fold this 'Object' check into the `getNativeInterceptor`
       // check by patching `Object.prototype` with a special hook function.
       // TODO(9556): This test is needed in plain non-browser code because
       // 'holders' are not Dart classes.
       block.statements.add(
-          js.if_(
-              js['Object.getPrototypeOf(receiver) === Object.prototype'],
+          jsBuilder.if_(
+              js('Object.getPrototypeOf(receiver) === Object.prototype'),
               buildReturnInterceptor(backend.jsInterceptorClass)));
 
       block.statements.add(
-          js.return_(
-              js[namer.isolateAccess(backend.getNativeInterceptorMethod)](
+          jsBuilder.return_(
+              js(namer.isolateAccess(backend.getNativeInterceptorMethod))(
                   ['receiver'])));
 
     } else {
-      block.statements.add(js.return_(js['receiver']));
+      block.statements.add(jsBuilder.return_(js('receiver')));
     }
 
     buffer.write(jsAst.prettyPrint(
-        js[isolateProperties][key].assign(js.fun(['receiver'], block)),
+        js(isolateProperties)[key].assign(jsBuilder.fun(['receiver'], block)),
         compiler));
     buffer.write(N);
   }
 
   /**
    * Emit all versions of the [:getInterceptor:] method.
    */
   void emitGetInterceptorMethods(CodeBuffer buffer) {
     var specializedGetInterceptors = backend.specializedGetInterceptors;
     for (String name in specializedGetInterceptors.keys.toList()..sort()) {
@@ skipping 53 matching lines @@
       } else {
         regularClasses.add(element);
       }
     }
   }
 
   // Optimize performance critical one shot interceptors.
   jsAst.Statement tryOptimizeOneShotInterceptor(Selector selector,
                                                 Set<ClassElement> classes) {
     jsAst.Expression isNumber(String variable) {
-      return js[variable].typeof.equals(js.string('number'));
+      return js(variable).typeof.equals(jsBuilder.string('number'));
     }
 
     jsAst.Expression isNotObject(String variable) {
-      return js[variable].typeof.equals(js.string('object')).not;
+      return js(variable).typeof.equals(jsBuilder.string('object')).not;
     }
 
     jsAst.Expression isInt(String variable) {
-      jsAst.Expression receiver = js[variable];
+      jsAst.Expression receiver = js(variable);
       return isNumber(variable).binary('&&',
-          js['Math']['floor'](receiver).equals(receiver));
+          js('Math')['floor'](receiver).equals(receiver));
     }
 
     jsAst.Expression tripleShiftZero(jsAst.Expression receiver) {
-      return receiver.binary('>>>', js.toExpression(0));
+      return receiver.binary('>>>', jsBuilder.toExpression(0));
     }
 
     if (selector.isOperator()) {
       String name = selector.name.stringValue;
       if (name == '==') {
         // Unfolds to:
         // [: if (receiver == null) return a0 == null;
         //    if (typeof receiver != 'object') {
         //      return a0 != null && receiver === a0;
         //    }
         // :].
         List<jsAst.Statement> body = <jsAst.Statement>[];
-        body.add(js.if_('receiver == null',
-                        js.return_(js['a0'].equals(new jsAst.LiteralNull()))));
-        body.add(js.if_(
+        body.add(jsBuilder.if_(
+            'receiver == null',
+            jsBuilder.return_(js('a0').equals(new jsAst.LiteralNull()))));
+        body.add(jsBuilder.if_(
             isNotObject('receiver'),
-            js.return_(js['a0'].equals(new jsAst.LiteralNull()).not.binary(
-                '&&', js['receiver'].strictEquals(js['a0'])))));
+            jsBuilder.return_(js('a0')
+                     .equals(new jsAst.LiteralNull())
+                     .not
+                     .binary('&&', js('receiver').strictEquals(js('a0'))))));
         return new jsAst.Block(body);
       }
       if (!classes.contains(backend.jsIntClass)
           && !classes.contains(backend.jsNumberClass)
           && !classes.contains(backend.jsDoubleClass)) {
         return null;
       }
       if (selector.argumentCount == 1) {
         // The following operators do not map to a JavaScript
         // operator.
         if (name != '~/' && name != '<<' && name != '%' && name != '>>') {
-          jsAst.Expression result = js['receiver'].binary(name, js['a0']);
+          jsAst.Expression result = js('receiver').binary(name, js('a0'));
           if (name == '&' || name == '|' || name == '^') {
             result = tripleShiftZero(result);
           }
           // Unfolds to:
           // [: if (typeof receiver == "number" && typeof a0 == "number")
           //      return receiver op a0;
           // :].
-          return js.if_(
+          return jsBuilder.if_(
               isNumber('receiver').binary('&&', isNumber('a0')),
-              js.return_(result));
+              jsBuilder.return_(result));
         }
       } else if (name == 'unary-') {
         // operator~ does not map to a JavaScript operator.
         // Unfolds to:
         // [: if (typeof receiver == "number") return -receiver:].
-        return js.if_(
+        return jsBuilder.if_(
             isNumber('receiver'),
-            js.return_(new jsAst.Prefix('-', js['receiver'])));
+            jsBuilder.return_(new jsAst.Prefix('-', js('receiver'))));
       } else {
         assert(name == '~');
-        return js.if_(
+        return jsBuilder.if_(
             isInt('receiver'),
-            js.return_(
-                tripleShiftZero(new jsAst.Prefix(name, js['receiver']))));
+            jsBuilder.return_(
+                tripleShiftZero(new jsAst.Prefix(name, js('receiver')))));
       }
     } else if (selector.isIndex() || selector.isIndexSet()) {
       // For an index operation, this code generates:
       //
       // [: if (receiver.constructor == Array || typeof receiver == "string") {
       //      if (a0 >>> 0 === a0 && a0 < receiver.length) {
       //        return receiver[a0];
       //      }
       //    }
       // :]
@@ skipping 11 matching lines @@
       // The index set operator requires a check on its set value in
       // checked mode, so we don't optimize the interceptor if the
       // compiler has type assertions enabled.
       if (selector.isIndexSet()
           && (compiler.enableTypeAssertions || !containsArray)) {
         return null;
       }
       if (!containsArray && !containsString) {
         return null;
       }
-      jsAst.Expression receiver = js['receiver'];
-      jsAst.Expression arg0 = js['a0'];
+      jsAst.Expression receiver = js('receiver');
+      jsAst.Expression arg0 = js('a0');
       jsAst.Expression isIntAndAboveZero =
-          arg0.binary('>>>', js.toExpression(0)).strictEquals(arg0);
+          arg0.binary('>>>', jsBuilder.toExpression(0)).strictEquals(arg0);
       jsAst.Expression belowLength = arg0.binary('<', receiver['length']);
       jsAst.Expression arrayCheck = receiver['constructor'].equals('Array');
 
       if (selector.isIndex()) {
         jsAst.Expression stringCheck =
-            receiver.typeof.equals(js.string('string'));
+            receiver.typeof.equals(jsBuilder.string('string'));
         jsAst.Expression typeCheck;
         if (containsArray) {
           if (containsString) {
             typeCheck = arrayCheck.binary('||', stringCheck);
           } else {
             typeCheck = arrayCheck;
           }
         } else {
           assert(containsString);
           typeCheck = stringCheck;
         }
 
-        return js.if_(typeCheck,
-                      js.if_(isIntAndAboveZero.binary('&&', belowLength),
-                             js.return_(receiver[arg0])));
+        return jsBuilder.if_(
+            typeCheck,
+            jsBuilder.if_(isIntAndAboveZero.binary('&&', belowLength),
+            jsBuilder.return_(receiver[arg0])));
       } else {
         jsAst.Expression isImmutableArray = arrayCheck.binary(
             '&&', receiver[r'immutable$list'].not);
-        return js.if_(isImmutableArray.binary(
+        return jsBuilder.if_(isImmutableArray.binary(
                       '&&', isIntAndAboveZero.binary('&&', belowLength)),
-                      js.return_(receiver[arg0].assign(js['a1'])));
+                      jsBuilder.return_(receiver[arg0].assign(js('a1'))));
       }
     }
     return null;
   }
 
   void emitOneShotInterceptors(CodeBuffer buffer) {
     List<String> names = backend.oneShotInterceptors.keys.toList();
     names.sort();
     for (String name in names) {
       Selector selector = backend.oneShotInterceptors[name];
       Set<ClassElement> classes =
           backend.getInterceptedClassesOn(selector.name);
       String getInterceptorName =
           namer.getInterceptorName(backend.getInterceptorMethod, classes);
 
       List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
       List<jsAst.Expression> arguments = <jsAst.Expression>[];
       parameters.add(new jsAst.Parameter('receiver'));
-      arguments.add(js['receiver']);
+      arguments.add(js('receiver'));
 
       if (selector.isSetter()) {
         parameters.add(new jsAst.Parameter('value'));
-        arguments.add(js['value']);
+        arguments.add(js('value'));
       } else {
         for (int i = 0; i < selector.argumentCount; i++) {
           String argName = 'a$i';
           parameters.add(new jsAst.Parameter(argName));
-          arguments.add(js[argName]);
+          arguments.add(js(argName));
         }
       }
 
       List<jsAst.Statement> body = <jsAst.Statement>[];
       jsAst.Statement optimizedPath =
           tryOptimizeOneShotInterceptor(selector, classes);
       if (optimizedPath != null) {
         body.add(optimizedPath);
       }
 
       String invocationName = backend.namer.invocationName(selector);
-      body.add(js.return_(
-          js[isolateProperties][getInterceptorName]('receiver')[invocationName](
+      body.add(jsBuilder.return_(
+          js(isolateProperties)[getInterceptorName]('receiver')[invocationName](
               arguments)));
 
-      jsAst.Fun function = js.fun(parameters, body);
+      jsAst.Fun function = jsBuilder.fun(parameters, body);
 
       jsAst.PropertyAccess property =
-          js[isolateProperties][name];
+          js(isolateProperties)[name];
 
       buffer.write(jsAst.prettyPrint(property.assign(function), compiler));
       buffer.write(N);
     }
   }
 
   /**
    * If [:invokeOn:] has been compiled, emit all the possible selector names
    * that are intercepted into the [:interceptedNames:] top-level
    * variable. The implementation of [:invokeOn:] will use it to
    * determine whether it should call the method with an extra
    * parameter.
    */
   void emitInterceptedNames(CodeBuffer buffer) {
     if (!compiler.enabledInvokeOn) return;
     String name = backend.namer.getName(backend.interceptedNames);
-    jsAst.PropertyAccess property = js[isolateProperties][name];
+    jsAst.PropertyAccess property = js(isolateProperties)[name];
 
     int index = 0;
     List<jsAst.ArrayElement> elements = backend.usedInterceptors.map(
       (Selector selector) {
-        jsAst.Literal str = js.string(namer.invocationName(selector));
+        jsAst.Literal str = jsBuilder.string(namer.invocationName(selector));
         return new jsAst.ArrayElement(index++, str);
       }).toList();
     jsAst.ArrayInitializer array = new jsAst.ArrayInitializer(
         backend.usedInterceptors.length,
         elements);
 
     buffer.write(jsAst.prettyPrint(property.assign(array), compiler));
     buffer.write(N);
   }
 
   void emitInitFunction(CodeBuffer buffer) {
-    jsAst.Fun fun = js.fun([], [
-      js['$isolateProperties = {}'],
+    jsAst.Fun fun = jsBuilder.fun([], [
+      js('$isolateProperties = {}'),
     ]
     ..addAll(buildDefineClassAndFinishClassFunctionsIfNecessary())
     ..addAll(buildLazyInitializerFunctionIfNecessary())
     ..addAll(buildFinishIsolateConstructor())
     );
     jsAst.FunctionDeclaration decl = new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('init'), fun);
     buffer.write(jsAst.prettyPrint(decl, compiler).getText());
   }
 
@@ skipping 185 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;