Revert "Retry "Emit more stuff via 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);
 
-    ClassBuilder builder = new ClassBuilder();
-    emitter.emitClassFields(classElement, builder, classIsNative: true);
-    emitter.emitClassGettersSetters(classElement, builder);
-    emitter.emitInstanceMembers(classElement, builder);
+    assert(classElement.backendMembers.isEmpty);
+    String quotedName = classElement.nativeTagInfo.slowToString();
 
-    // An empty native class may be omitted since the superclass methods can be
-    // located via the dispatch metadata.
-    if (builder.properties.isEmpty) return;
+    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;
+    }
 
     String nativeTag = toNativeTag(classElement);
-    js.Expression definition =
-        js.call(js.use(defineNativeClassName),
-                [js.string(nativeTag), builder.toObjectInitializer()]);
-
-    nativeBuffer.add(js.prettyPrint(definition, compiler));
-    nativeBuffer.add('$N$n');
+    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');
 
     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(
-                    js.assign(
-                        js.use(name),
-                        js.use(closureConverter).callWith(
-                            [js.use(name), new js.LiteralNumber('$arity')]))));
+                    new js.Assignment(
+                        new js.VariableUse(name),
+                        new js.VariableUse(closureConverter)
+                            .callWith([new js.VariableUse(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 js.if_(
-        js.use('Object').dot('getPrototypeOf')
-            .callWith([js.use('this')])
-            .dot('hasOwnProperty').callWith([js.string(methodName)]),
+    return new js.If(
+        new js.VariableUse('Object')
+            .dot('getPrototypeOf')
+            .callWith([new js.VariableUse('this')])
+            .dot('hasOwnProperty')
+            .callWith([new js.LiteralString("'$methodName'")]),
         body,
-        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))))));
+        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.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(js.string(Strings.join(subtags, '|')));
+        expressions.add(
+            new js.LiteralString("'${Strings.join(subtags, '|')}'"));
       }
       js.Expression expression;
       if (expressions.length == 1) {
         expression = expressions[0];
       } else {
         js.Expression array = new js.ArrayInitializer.from(expressions);
-        expression = js.call(array.dot('join'), [js.string('|')]);
+        expression = new js.Call(
+            new js.PropertyAccess.field(array, 'join'),
+            [new js.LiteralString("'|'")]);
       }
       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([
-                      js.string(toNativeTag(cls)),
+                      new js.LiteralString("'${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.
-    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')]))));
+    Map<String, String> objectProperties = new Map<String, String>();
+    emitIsChecks(objectProperties);
 
     // 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));
+    objectProperties[toStringName] =
+        'function() { return $toStringHelperName(this); }';
 
     // Same as above, but for hashCode.
     String hashCodeName =
         backend.namer.publicGetterName(const SourceString('hashCode'));
-    addProperty(hashCodeName, makeCallOnThis(hashCodeHelperName));
+    objectProperties[hashCodeName] =
+        'function() { return $hashCodeHelperName(this); }';
 
     // If the native emitter has been asked to take care of the
     // noSuchMethod handlers, we do that now.
     if (handleNoSuchMethod) {
-      emitter.emitNoSuchMethodHandlers(addProperty);
+      emitter.emitNoSuchMethodHandlers((String name, CodeBuffer buffer) {
+        objectProperties[name] = buffer.toString();
+      });
     }
 
     // If we have any properties to add to Object.prototype, we run
     // through them and add them using defineProperty.
     if (!objectProperties.isEmpty) {
-      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');
+      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");
     }
-
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }