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

sdk/lib/_internal/compiler/implementation/js_backend/native_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;
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
@@ skipping 139 matching lines @@
     // An empty native class may be omitted since the superclass methods can be
     // located via the dispatch metadata.
     // TODO(sra): Also need to check there are no subclasses that will reference
     // this class.
     // bool hasOnlyGeneratedFields = builder.properties.length == 1;
     // if (hasOnlyGeneratedFields == 1 && !hasFields) return;
 
     // Define interceptor class for [classElement].
     String className = backend.namer.getName(classElement);
     jsAst.Expression init =
-        js[emitter.classesCollector][className].assign(
+        js(emitter.classesCollector)[className].assign(
             builder.toObjectInitializer());
     mainBuffer.write(jsAst.prettyPrint(init, compiler));
     mainBuffer.write('$N$n');
 
     emitter.needsDefineClass = true;
 
     // Define dispatch for [classElement].
     String nativeTag = toNativeTag(classElement);
     String definer = directSubtypes[classElement] == null
         ? defineNativeMethodsName
         : defineNativeMethodsNonleafName;
 
     // TODO(sra): Fix DOM generation.  There is a missing proto in the picture
     // the DOM gives of the proto chain.  We might need an annotation.
     if (nativeTag == 'HTMLElement') definer = defineNativeMethodsNonleafName;
 
     jsAst.Expression definition =
-        js[definer](
+        js(definer)(
             [js.string(nativeTag),
-             js[backend.namer.isolateAccess(classElement)]]);
+             js(backend.namer.isolateAccess(classElement))]);
 
     nativeBuffer.add(jsAst.prettyPrint(definition, compiler));
     nativeBuffer.add('$N$n');
 
     classesWithDynamicDispatch.add(classElement);
   }
 
   void finishGenerateNativeClasses() {
     // TODO(sra): Put specialized version of getNativeMethods on
     // `Object.prototype` to avoid checking in `getInterceptor` and
     // specializations.
 
-    // jsAst.Expression call = js[defineNativeMethodsFinishName]([]);
+    // jsAst.Expression call = js(defineNativeMethodsFinishName)([]);
     // nativeBuffer.add(jsAst.prettyPrint(call, compiler));
     // nativeBuffer.add('$N$n');
   }
 
   List<ClassElement> getDirectSubclasses(ClassElement cls) {
     List<ClassElement> result = directSubtypes[cls];
     return result == null ? const<ClassElement>[] : result;
   }
 
   void potentiallyConvertDartClosuresToJs(
@@ skipping 14 matching lines @@
         if (stubParameter.name == name) {
           DartType type = parameter.computeType(compiler).unalias(compiler);
           if (type is FunctionType) {
             // The parameter type is a function type either directly or through
             // typedef(s).
             int arity = type.computeArity();
 
             statements.add(
                 new jsAst.ExpressionStatement(
                     js.assign(
-                        js[name],
-                        js[closureConverter](
-                            [js[name],
+                        js(name),
+                        js(closureConverter)(
+                            [js(name),
                              new jsAst.LiteralNumber('$arity')]))));
             break;
           }
         }
       }
     });
   }
 
   List<jsAst.Statement> generateParameterStubStatements(
       Element member,
@@ skipping 240 matching lines @@
     // false, and will be overridden by subclasses when they have to
     // return true.
     void emitIsChecks() {
       for (ClassElement element in
                Elements.sortedByPosition(emitter.checkedClasses)) {
         if (!requiresNativeIsCheck(element)) continue;
         if (element.isObject(compiler)) continue;
         // Add function for the is-test.
         String name = backend.namer.operatorIs(element);
         addProperty(name,
-            js.fun([], js.return_(js['false'])));
+            js.fun([], js.return_(js('false'))));
         // Add a function for the (trivial) substitution.
         addProperty(backend.namer.substitutionName(element),
-                    js.fun([], js.return_(js['null'])));
+                    js.fun([], js.return_(js('null'))));
       }
     }
     emitIsChecks();
 
     jsAst.Expression makeCallOnThis(String functionName) {
       // Because we know the function is intercepted, we need an extra
       // parameter.
-      return js.fun(['_'], js.return_(js['$functionName(this)']));
+      return js.fun(['_'], js.return_(js('$functionName(this)')));
     }
 
     if (!nativeClasses.isEmpty) {
       emitDynamicDispatchMetadata();
 
       // In order to have the toString method on every native class,
       // we must patch the JS Object prototype with a helper method.
       String toStringName = backend.namer.publicInstanceMethodNameByArity(
           const SourceString('toString'), 0);
       addProperty(toStringName, makeCallOnThis(toStringHelperName));
 
       // Same as above, but for hashCode.
       String hashCodeName =
           backend.namer.publicGetterName(const SourceString('hashCode'));
       addProperty(hashCodeName, makeCallOnThis(hashCodeHelperName));
 
       // Same as above, but for operator==.
       String equalsName = backend.namer.publicInstanceMethodNameByArity(
           const SourceString('=='), 1);
       // Because we know the function is intercepted, we need an extra
       // parameter.
       addProperty(equalsName, js.fun(['_', 'a'],
-          js.return_(js['this === a'])));
+          js.return_(js('this === a'))));
 
       // If the native emitter has been asked to take care of the
       // noSuchMethod handlers, we do that now.
       if (handleNoSuchMethod) {
         emitter.emitNoSuchMethodHandlers(addProperty);
       }
     }
 
     // If we have any properties to add to Object.prototype, we run
     // through them and add them using defineProperty.
     if (!objectProperties.isEmpty) {
       jsAst.Expression init =
           js.fun(['table'],
               new jsAst.ForIn(
                   new jsAst.VariableDeclarationList(
                       [new jsAst.VariableInitialization(
                           new jsAst.VariableDeclaration('key'),
                           null)]),
-                  js['table'],
+                  js('table'),
                   new jsAst.ExpressionStatement(
-                      js['$defPropName(Object.prototype, key, table[key])'])))(
+                      js('$defPropName(Object.prototype, key, table[key])'))))(
               new jsAst.ObjectInitializer(objectProperties));
 
       if (emitter.compiler.enableMinification) targetBuffer.add(';');
       targetBuffer.add(jsAst.prettyPrint(
           new jsAst.ExpressionStatement(init), compiler));
       targetBuffer.add('\n');
     }
 
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }