Add a small JS parser to ease the building of ASTs

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 231 matching lines @@
   // If a method is overridden, we must check if the prototype of 'this' has the
   // method available. Otherwise, we may end up calling the method from the
   // super class. If the method is not available, we make a direct call to
   // Object.prototype.$methodName.  This method will patch the prototype of
   // 'this' to the real method.
   jsAst.Statement generateMethodBodyWithPrototypeCheck(
       String methodName,
       jsAst.Statement body,
       List<jsAst.Parameter> parameters) {
     return js.if_(
-        js['Object']['getPrototypeOf']('this')['hasOwnProperty'](
-            js.string(methodName)),
+        js['(Object.getPrototypeOf(this)).hasOwnProperty("$methodName")'],
         body,
         js.return_(
-            js['Object']['prototype'][methodName]['call'](
+            js['Object.prototype.$methodName.call'](
                 <jsAst.Expression>[js['this']]..addAll(
                     parameters.map((param) => js[param.name])))));
   }
 
   jsAst.Block generateMethodBodyWithPrototypeCheckForElement(
       FunctionElement element,
       jsAst.Block body,
       List<jsAst.Parameter> parameters) {
     ElementKind kind = element.kind;
     if (kind != ElementKind.FUNCTION &&
@@ skipping 205 matching lines @@
     // 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;
         String name = backend.namer.operatorIs(element);
         addProperty(name,
-            js.fun([], js.return_(new jsAst.LiteralBool(false))));
+            js.fun([], js.return_(js['false'])));
       }
     }
     emitIsChecks();
 
     jsAst.Expression makeCallOnThis(String functionName) {
-      return js.fun([], js.return_(js[functionName]('this')));
+      return js.fun([], js.return_(js['$functionName(this)']));
     }
 
     // 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);
     addProperty(equalsName, js.fun(['a'],
-        js.return_(js.strictEquals(new jsAst.This(), js['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'],
                   new jsAst.ExpressionStatement(
-                      js[defPropName](
-                          [js['Object']['prototype'],
-                           js['key'],
-                           new jsAst.PropertyAccess(js['table'],
-                                                    js['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');
   }
 }