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.string(nativeTag),
-             js[backend.namer.isolateAccess(classElement)]]);
+        js(definer)(
+            [jsBuilder.string(nativeTag),
+             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 13 matching lines @@
       for (jsAst.Parameter stubParameter in stubParameters) {
         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],
+                    jsBuilder.assign(
+                        js(name),
+                        js(closureConverter)(
+                            [js(name),
                              new jsAst.LiteralNumber('$arity')]))));
             break;
           }
         }
       }
     });
   }
 
   List<jsAst.Statement> generateParameterStubStatements(
       Element member,
@@ skipping 131 matching lines @@
               tagDefns[tag] = new jsAst.VariableUse(varName);
               expressions.add(new jsAst.VariableUse(varName));
             }
           }
         }
       }
       walk(classElement);
 
       if (!subtags.isEmpty) {
         subtags.sort();
-        expressions.add(js.string(subtags.join('|')));
+        expressions.add(jsBuilder.string(subtags.join('|')));
       }
       jsAst.Expression expression;
       if (expressions.length == 1) {
         expression = expressions[0];
       } else {
         jsAst.Expression array = new jsAst.ArrayInitializer.from(expressions);
-        expression = array['join']([js.string('|')]);
+        expression = array['join']([jsBuilder.string('|')]);
       }
       return expression;
     }
 
     for (final ClassElement classElement in preorderDispatchClasses) {
       tagDefns[classElement] = makeExpression(classElement);
     }
 
     // Write out a thunk that builds the metadata.
     if (!tagDefns.isEmpty) {
@@ skipping 14 matching lines @@
       }
 
       // [table] is a list of lists, each inner list of the form:
       //   [dynamic-dispatch-tag, tags-of-classes-implementing-dispatch-tag]
       // E.g.
       //   [['Node', 'Text|HTMLElement|HTMLDivElement|...'], ...]
       jsAst.Expression table =
           new jsAst.ArrayInitializer.from(
               preorderDispatchClasses.map((cls) =>
                   new jsAst.ArrayInitializer.from([
-                      js.string(toNativeTag(cls)),
+                      jsBuilder.string(toNativeTag(cls)),
                       tagDefns[cls]])));
 
       //  $.dynamicSetMetadata(table);
       statements.add(
           new jsAst.ExpressionStatement(
               new jsAst.Call(
                   new jsAst.VariableUse(dynamicSetMetadataName),
                   [table])));
 
       //  (function(){statements})();
@@ skipping 30 matching lines @@
     if (!element.isClass()) return false;
     ClassElement cls = element;
     if (cls.isNative()) return true;
     return isSupertypeOfNativeClass(element);
   }
 
   void assembleCode(CodeBuffer targetBuffer) {
     List<jsAst.Property> objectProperties = <jsAst.Property>[];
 
     void addProperty(String name, jsAst.Expression value) {
-      objectProperties.add(new jsAst.Property(js.string(name), value));
+      objectProperties.add(new jsAst.Property(jsBuilder.string(name), value));
     }
 
     // Because of native classes, we have to generate some is checks
     // by calling a method, instead of accessing a property. So we
     // attach to the JS Object prototype these methods that return
     // 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'])));
+            jsBuilder.fun([], jsBuilder.return_(js('false'))));
         // Add a function for the (trivial) substitution.
         addProperty(backend.namer.substitutionName(element),
-                    js.fun([], js.return_(js['null'])));
+                    jsBuilder.fun([], jsBuilder.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 jsBuilder.fun(['_'], jsBuilder.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'])));
+      addProperty(equalsName, jsBuilder.fun(['_', 'a'],
+          jsBuilder.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'],
+          jsBuilder.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');
   }
 }