Emit classes using 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 107 matching lines @@
     String quotedName = cls.nativeTagInfo.slowToString();
     if (isNativeGlobal(quotedName)) {
       // Global object, just be like the other types for now.
       return quotedName.substring(3, quotedName.length - 1);
     } else {
       return quotedName.substring(2, quotedName.length - 1);
     }
   }
 
   void generateNativeClass(ClassElement classElement) {
+    assert(classElement.backendMembers.isEmpty);
     nativeClasses.add(classElement);
 
-    assert(classElement.backendMembers.isEmpty);
-    String quotedName = classElement.nativeTagInfo.slowToString();
+    ClassBuilder builder = new ClassBuilder();
+    emitter.emitClassFields(classElement, builder, classIsNative: true);
+    emitter.emitClassGettersSetters(classElement, builder);
+    emitter.emitInstanceMembers(classElement, builder);
 
-    CodeBuffer fieldBuffer = new CodeBuffer();
-    CodeBuffer getterSetterBuffer = new CodeBuffer();
-    CodeBuffer methodBuffer = new CodeBuffer();
-
-    emitter.emitClassFields(classElement, fieldBuffer, false,
-                            classIsNative: true);
-    emitter.emitClassGettersSetters(classElement, getterSetterBuffer, false);
-    emitter.emitInstanceMembers(classElement, methodBuffer, false);
-
-    if (methodBuffer.isEmpty
-        && fieldBuffer.isEmpty
-        && getterSetterBuffer.isEmpty) {
-      return;
-    }
+    // An empty native class may be omitted since the superclass methods can be
+    // located via the dispatch metadata.
+    if (builder.properties.isEmpty) return;
 
     String nativeTag = toNativeTag(classElement);
-    nativeBuffer.add("$defineNativeClassName('$nativeTag',$_");
-    nativeBuffer.add('{');
-    bool firstInMap = true;
-    if (!fieldBuffer.isEmpty) {
-      firstInMap = false;
-      nativeBuffer.add(fieldBuffer);
-    }
-    if (!getterSetterBuffer.isEmpty) {
-      if (!firstInMap) nativeBuffer.add(",");
-      firstInMap = false;
-      nativeBuffer.add("\n$_");
-      nativeBuffer.add(getterSetterBuffer);
-    }
-    if (!methodBuffer.isEmpty) {
-      if (!firstInMap) nativeBuffer.add(",");
-      nativeBuffer.add(methodBuffer);
-    }
-    nativeBuffer.add('$n})$N$n');
+    js.Expression definition =
+        js.call(js.use(defineNativeClassName),
+                [js.string(nativeTag), builder.toObjectInitializer()]);
+
+    nativeBuffer.add(js.prettyPrint(definition, compiler));
+    nativeBuffer.add('$N$n');
 
     classesWithDynamicDispatch.add(classElement);
   }
 
   List<ClassElement> getDirectSubclasses(ClassElement cls) {
     List<ClassElement> result = directSubtypes[cls];
     return result == null ? const<ClassElement>[] : result;
   }
 
   void potentiallyConvertDartClosuresToJs(List<js.Statement> statements,
@@ skipping 12 matching lines @@
       for (js.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 js.ExpressionStatement(
-                    new js.Assignment(
-                        new js.VariableUse(name),
-                        new js.VariableUse(closureConverter)
-                            .callWith([new js.VariableUse(name),
-                                       new js.LiteralNumber('$arity')]))));
+                    js.assign(
+                        js.use(name),
+                        js.use(closureConverter).callWith(
+                            [js.use(name), new js.LiteralNumber('$arity')]))));
             break;
           }
         }
       }
     });
   }
 
   List<js.Statement> generateParameterStubStatements(
       Element member,
       String invocationName,
       List<js.Parameter> stubParameters,
       List<js.Expression> argumentsBuffer,
       int indexOfLastOptionalArgumentInParameters) {
     // The target JS function may check arguments.length so we need to
     // make sure not to pass any unspecified optional arguments to it.
     // For example, for the following Dart method:
     //   foo([x, y, z]);
     // The call:
     //   foo(y: 1)
     // must be turned into a JS call to:
     //   foo(null, y).
 
     ClassElement classElement = member.enclosingElement;
-    //String nativeTagInfo = classElement.nativeName.slowToString();
     String nativeTagInfo = classElement.nativeTagInfo.slowToString();
 
     List<js.Statement> statements = <js.Statement>[];
     potentiallyConvertDartClosuresToJs(statements, member, stubParameters);
 
     String target;
     List<js.Expression> arguments;
 
     if (!nativeMethods.contains(member)) {
       // When calling a method that has a native body, we call it with our
@@ skipping 23 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.
   js.Statement generateMethodBodyWithPrototypeCheck(
       String methodName,
       js.Statement body,
       List<js.Parameter> parameters) {
-    return new js.If(
-        new js.VariableUse('Object')
-            .dot('getPrototypeOf')
-            .callWith([new js.VariableUse('this')])
-            .dot('hasOwnProperty')
-            .callWith([new js.LiteralString("'$methodName'")]),
+    return js.if_(
+        js.use('Object').dot('getPrototypeOf')
+            .callWith([js.use('this')])
+            .dot('hasOwnProperty').callWith([js.string(methodName)]),
         body,
-        new js.Block(
-            <js.Statement>[
-                new js.Return(
-                    new js.VariableUse('Object')
-                        .dot('prototype').dot(methodName).dot('call')
-                        .callWith(
-                            <js.Expression>[new js.VariableUse('this')]
-                                ..addAll(parameters.map((param) =>
-                                        new js.VariableUse(param.name)))))
-            ]));
+        js.return_(
+            js.use('Object').dot('prototype').dot(methodName).dot('call')
+            .callWith(
+                <js.Expression>[js.use('this')]..addAll(
+                    parameters.map((param) => js.use(param.name))))));
   }
 
   js.Block generateMethodBodyWithPrototypeCheckForElement(
       FunctionElement element,
       js.Block body,
       List<js.Parameter> parameters) {
     String methodName;
     Namer namer = backend.namer;
     if (element.kind == ElementKind.FUNCTION) {
       methodName = namer.instanceMethodName(element);
     } else if (element.kind == ElementKind.GETTER) {
       methodName = namer.getterName(element.getLibrary(), element.name);
     } else if (element.kind == ElementKind.SETTER) {
       methodName = namer.setterName(element.getLibrary(), element.name);
     } else {
-      compiler.internalError('unexpected kind: "${element.kind}"',
+      compiler.internalError("unexpected kind: '${element.kind}'",
           element: element);
     }
 
     return new js.Block(
         [generateMethodBodyWithPrototypeCheck(methodName, body, parameters)]);
   }
 
 
   void emitDynamicDispatchMetadata() {
     if (classesWithDynamicDispatch.isEmpty) return;
@@ skipping 79 matching lines @@
               varDefns[varName] = existing;
               tagDefns[tag] = new js.VariableUse(varName);
               expressions.add(new js.VariableUse(varName));
             }
           }
         }
       }
       walk(classElement);
 
       if (!subtags.isEmpty) {
-        expressions.add(
-            new js.LiteralString("'${Strings.join(subtags, '|')}'"));
+        expressions.add(js.string(Strings.join(subtags, '|')));
       }
       js.Expression expression;
       if (expressions.length == 1) {
         expression = expressions[0];
       } else {
         js.Expression array = new js.ArrayInitializer.from(expressions);
-        expression = new js.Call(
-            new js.PropertyAccess.field(array, 'join'),
-            [new js.LiteralString("'|'")]);
+        expression = js.call(array.dot('join'), [js.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|...'], ...]
       js.Expression table =
           new js.ArrayInitializer.from(
               preorderDispatchClasses.map((cls) =>
                   new js.ArrayInitializer.from([
-                      new js.LiteralString("'${toNativeTag(cls)}'"),
+                      js.string(toNativeTag(cls)),
                       tagDefns[cls]])));
 
       //  $.dynamicSetMetadata(table);
       statements.add(
           new js.ExpressionStatement(
               new js.Call(
                   new js.VariableUse(dynamicSetMetadataName),
                   [table])));
 
       //  (function(){statements})();
@@ skipping 25 matching lines @@
     return subtypes[element] != null;
   }
 
   bool requiresNativeIsCheck(Element element) {
     if (!element.isClass()) return false;
     ClassElement cls = element;
     if (cls.isNative()) return true;
     return isSupertypeOfNativeClass(element);
   }
 
-  void emitIsChecks(Map<String, String> objectProperties) {
-    for (Element element in emitter.checkedClasses) {
-      if (!requiresNativeIsCheck(element)) continue;
-      if (element.isObject(compiler)) continue;
-      String name = backend.namer.operatorIs(element);
-      objectProperties[name] = 'function()$_{${_}return false;$_}';
-    }
-  }
-
   void assembleCode(CodeBuffer targetBuffer) {
     if (nativeClasses.isEmpty) return;
     emitDynamicDispatchMetadata();
     targetBuffer.add('$defineNativeClassName = '
                      '$defineNativeClassFunction$N$n');
 
+    List<js.Property> objectProperties = <js.Property>[];
+
+    void addProperty(String name, js.Expression value) {
+      objectProperties.add(new js.Property(js.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.
-    Map<String, String> objectProperties = new Map<String, String>();
-    emitIsChecks(objectProperties);
+    void emitIsChecks() {
+      for (Element 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.block1(js.return_(new js.LiteralBool(false)))));
+      }
+    }
+    emitIsChecks();
+
+    js.Expression makeCallOnThis(String functionName) =>
+        js.fun([],
+            js.block1(
+                js.return_(
+                    js.call(js.use(functionName), [js.use('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);
-    objectProperties[toStringName] =
-        'function() { return $toStringHelperName(this); }';
+    addProperty(toStringName, makeCallOnThis(toStringHelperName));
 
     // Same as above, but for hashCode.
     String hashCodeName =
         backend.namer.publicGetterName(const SourceString('hashCode'));
-    objectProperties[hashCodeName] =
-        'function() { return $hashCodeHelperName(this); }';
+    addProperty(hashCodeName, makeCallOnThis(hashCodeHelperName));
 
     // If the native emitter has been asked to take care of the
     // noSuchMethod handlers, we do that now.
     if (handleNoSuchMethod) {
-      emitter.emitNoSuchMethodHandlers((String name, CodeBuffer buffer) {
-        objectProperties[name] = buffer.toString();
-      });
+      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) {
-      if (emitter.compiler.enableMinification) targetBuffer.add(";");
-      targetBuffer.add("(function(table) {\n"
-                       "  for (var key in table) {\n"
-                       "    $defPropName(Object.prototype, key, table[key]);\n"
-                       "  }\n"
-                       "})({\n");
-      bool first = true;
-      objectProperties.forEach((String name, String function) {
-        if (!first) targetBuffer.add(",\n");
-        targetBuffer.add("$_$name:$_$function");
-        first = false;
-      });
-      targetBuffer.add("\n})$N$n");
+      js.Expression init =
+          js.call(
+              js.fun(['table'],
+                  js.block1(
+                      new js.ForIn(
+                          new js.VariableDeclarationList(
+                              [new js.VariableInitialization(
+                                  new js.VariableDeclaration('key'),
+                                  null)]),
+                          js.use('table'),
+                          new js.ExpressionStatement(
+                              js.call(
+                                  js.use(defPropName),
+                                  [js.use('Object').dot('prototype'),
+                                   js.use('key'),
+                                   new js.PropertyAccess(js.use('table'),
+                                                         js.use('key'))]))))),
+              [new js.ObjectInitializer(objectProperties)]);
+
+      if (emitter.compiler.enableMinification) targetBuffer.add(';');
+      targetBuffer.add(js.prettyPrint(
+          new js.ExpressionStatement(init), compiler));
+      targetBuffer.add('\n');
     }
+
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }