Revert "Retry "Emit more stuff via ASTs""

sdk/lib/_internal/compiler/implementation/js_backend/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;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
                            FunctionElement other)
       : super.from(name, other, other.enclosingElement),
         methodElement = other;
 
   isInstanceMember() => true;
 
   Element getOutermostEnclosingMemberOrTopLevel() => methodElement;
 
   /**
    * The [member] this invocation refers to.
    */
   Element methodElement;
 }
 
 /**
- * A convenient type alias for some functions that emit keyed values.
- */
-typedef void DefineStubFunction(String invocationName, js.Expression value);
-
-/**
- * A data structure for collecting fragments of a class definition.
- */
-class ClassBuilder {
-  final List<js.Property> properties = <js.Property>[];
-
-  // Has the same signature as [DefineStubFunction].
-  void addProperty(String name, js.Expression value) {
-    properties.add(new js.Property(js.string(name), value));
-  }
-
-  js.Expression toObjectInitializer() => new js.ObjectInitializer(properties);
-}
-
-/**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsClosureClass = false;
   bool needsLazyInitializer = false;
@@ skipping 382 matching lines @@
   /**
    * Generate stubs to handle invocation of methods with optional
    * arguments.
    *
    * A method like [: foo([x]) :] may be invoked by the following
    * calls: [: foo(), foo(1), foo(x: 1) :]. See the sources of this
    * function for detailed examples.
    */
   void addParameterStub(FunctionElement member,
                         Selector selector,
-                        DefineStubFunction defineStub,
+                        DefineMemberFunction defineInstanceMember,
                         Set<String> alreadyGenerated) {
     FunctionSignature parameters = member.computeSignature(compiler);
     int positionalArgumentCount = selector.positionalArgumentCount;
     if (positionalArgumentCount == parameters.parameterCount) {
       assert(selector.namedArgumentCount == 0);
       return;
     }
     if (parameters.optionalParametersAreNamed
         && selector.namedArgumentCount == parameters.optionalParameterCount) {
       // If the selector has the same number of named arguments as
@@ skipping 83 matching lines @@
     } else {
       body = <js.Statement>[
           new js.Return(
               new js.VariableUse('this')
                   .dot(namer.getName(member))
                   .callWith(argumentsBuffer))];
     }
 
     js.Fun function = new js.Fun(parametersBuffer, new js.Block(body));
 
-    defineStub(invocationName, function);
+    CodeBuffer buffer = new CodeBuffer();
+    buffer.add(js.prettyPrint(function, compiler));
+    defineInstanceMember(invocationName, buffer);
   }
 
   void addParameterStubs(FunctionElement member,
-                         DefineStubFunction defineStub) {
+                         DefineMemberFunction defineInstanceMember) {
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, {c, d});
     //
     // We may have multiple ways of calling foo:
     // (1) foo(1, 2);
     // (2) foo(1, 2, c: 3);
     // (3) foo(1, 2, d: 4);
     // (4) foo(1, 2, c: 3, d: 4);
     // (5) foo(1, 2, d: 4, c: 3);
@@ skipping 19 matching lines @@
     Set<String> generatedStubNames = new Set<String>();
     if (compiler.enabledFunctionApply
         && member.name == namer.closureInvocationSelectorName) {
       // If [Function.apply] is called, we pessimistically compile all
       // possible stubs for this closure.
       FunctionSignature signature = member.computeSignature(compiler);
       Set<Selector> selectors = signature.optionalParametersAreNamed
           ? computeNamedSelectors(signature, member)
           : computeOptionalSelectors(signature, member);
       for (Selector selector in selectors) {
-        addParameterStub(member, selector, defineStub, generatedStubNames);
+        addParameterStub(
+            member, selector, defineInstanceMember, generatedStubNames);
       }
     } else {
       Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
       if (selectors == null) return;
       for (Selector selector in selectors) {
         if (!selector.applies(member, compiler)) continue;
-        addParameterStub(member, selector, defineStub, generatedStubNames);
+        addParameterStub(
+            member, selector, defineInstanceMember, generatedStubNames);
       }
     }
   }
 
   /**
    * Compute the set of possible selectors in the presence of named
    * parameters.
    */
   Set<Selector> computeNamedSelectors(FunctionSignature signature,
                                       FunctionElement element) {
@@ skipping 66 matching lines @@
     return member.hasFixedBackendName()
         ? member.fixedBackendName()
         : namer.getName(member);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
-  void addInstanceMember(Element member, ClassBuilder builder) {
+  void addInstanceMember(Element member,
+                         DefineMemberFunction defineInstanceMember) {
     assert(invariant(member, member.isDeclaration));
     // TODO(floitsch): we don't need to deal with members of
     // uninstantiated classes, that have been overwritten by subclasses.
 
     if (member.isFunction()
         || member.isGenerativeConstructorBody()
         || member.isAccessor()) {
       if (member.isAbstract(compiler)) return;
-      js.Expression code = compiler.codegenWorld.generatedCode[member];
-      if (code == null) return;
-      builder.addProperty(namer.getName(member), code);
-      code = compiler.codegenWorld.generatedBailoutCode[member];
-      if (code != null) {
-        builder.addProperty(namer.getBailoutName(member), code);
+      CodeBuffer codeBuffer = compiler.codegenWorld.generatedCode[member];
+      if (codeBuffer == null) return;
+      defineInstanceMember(namer.getName(member), codeBuffer);
+      codeBuffer = compiler.codegenWorld.generatedBailoutCode[member];
+      if (codeBuffer != null) {
+        defineInstanceMember(namer.getBailoutName(member), codeBuffer);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
       if (!parameters.optionalParameters.isEmpty) {
-        addParameterStubs(member, builder.addProperty);
+        addParameterStubs(member, defineInstanceMember);
       }
     } else if (!member.isField()) {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
-    emitExtraAccessors(member, builder);
+    emitExtraAccessors(member, defineInstanceMember);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void emitInstanceMembers(ClassElement classElement,
-                           ClassBuilder builder) {
+                           CodeBuffer buffer,
+                           bool emitLeadingComma) {
     assert(invariant(classElement, classElement.isDeclaration));
+    void defineInstanceMember(String name, StringBuffer memberBuffer) {
+      if (emitLeadingComma) buffer.add(',');
+      emitLeadingComma = true;
+      buffer.add('\n');
+      buffer.add('$_$name:$_');
+      buffer.add(memberBuffer);
+    }
+
     JavaScriptBackend backend = compiler.backend;
     if (classElement == backend.objectInterceptorClass) {
-      emitInterceptorMethods(builder);
+      emitInterceptorMethods(defineInstanceMember);
       // The ObjectInterceptor does not have any instance methods.
       return;
     }
 
     classElement.implementation.forEachMember(
         (ClassElement enclosing, Element member) {
           assert(invariant(classElement, member.isDeclaration));
           if (member.isInstanceMember()) {
-            addInstanceMember(member, builder);
+            addInstanceMember(member, defineInstanceMember);
           }
         },
         includeBackendMembers: true);
 
     generateIsTestsOn(classElement, (Element other) {
-      js.Expression code;
+      String code;
       if (compiler.objectClass == other) return;
       if (nativeEmitter.requiresNativeIsCheck(other)) {
-        code = js.fun([], js.block1(js.return_(new js.LiteralBool(true))));
+        code = 'function()$_{${_}return true;$_}';
       } else {
-        code = new js.LiteralBool(true);
+        code = 'true';
       }
-      builder.addProperty(namer.operatorIs(other), code);
+      CodeBuffer typeTestBuffer = new CodeBuffer();
+      typeTestBuffer.add(code);
+      defineInstanceMember(namer.operatorIs(other), typeTestBuffer);
     });
 
     if (identical(classElement, compiler.objectClass)
         && compiler.enabledNoSuchMethod) {
       // Emit the noSuchMethod handlers on the Object prototype now,
       // so that the code in the dynamicFunction helper can find
       // them. Note that this helper is invoked before analyzing the
       // full JS script.
       if (!nativeEmitter.handleNoSuchMethod) {
-        emitNoSuchMethodHandlers(builder.addProperty);
+        emitNoSuchMethodHandlers(defineInstanceMember);
       }
     }
   }
 
   void emitRuntimeClassesAndTests(CodeBuffer buffer) {
     JavaScriptBackend backend = compiler.backend;
     RuntimeTypeInformation rti = backend.rti;
 
     TypeChecks typeChecks = rti.computeRequiredChecks();
 
@@ skipping 103 matching lines @@
     // generate the field getter/setter dynamically. Since this is only
     // allowed on fields that are in [classElement] we don't need to visit
     // superclasses for non-instantiated classes.
     classElement.implementation.forEachInstanceField(
         visitField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
   }
 
   void generateGetter(Element member, String fieldName, String accessorName,
-                      ClassBuilder builder) {
+                      CodeBuffer buffer) {
     String getterName = namer.getterNameFromAccessorName(accessorName);
-    builder.addProperty(getterName,
-        js.fun([], js.block1(js.return_(js.use('this').dot(fieldName)))));
+    buffer.add("$getterName: function() { return this.$fieldName; }");
   }
 
   void generateSetter(Element member, String fieldName, String accessorName,
-                      ClassBuilder builder) {
+                      CodeBuffer buffer) {
     String setterName = namer.setterNameFromAccessorName(accessorName);
-    builder.addProperty(setterName,
-        js.fun(['v'],
-            js.block1(
-                new js.ExpressionStatement(
-                    js.assign(js.use('this').dot(fieldName), js.use('v'))))));
+    buffer.add("$setterName: function(v) { this.$fieldName = v; }");
   }
 
   bool canGenerateCheckedSetter(Element member) {
     DartType type = member.computeType(compiler);
     if (type.element.isTypeVariable()
         || type.element == compiler.dynamicClass
         || type.element == compiler.objectClass) {
       // TODO(ngeoffray): Support type checks on type parameters.
       return false;
     }
     return true;
   }
 
   void generateCheckedSetter(Element member,
                              String fieldName,
                              String accessorName,
-                             ClassBuilder builder) {
+                             CodeBuffer buffer) {
     assert(canGenerateCheckedSetter(member));
     DartType type = member.computeType(compiler);
     SourceString helper = compiler.backend.getCheckedModeHelper(type);
     FunctionElement helperElement = compiler.findHelper(helper);
     String helperName = namer.isolateAccess(helperElement);
-    List<js.Expression> arguments = <js.Expression>[js.use('v')];
+    String additionalArgument = '';
     if (helperElement.computeSignature(compiler).parameterCount != 1) {
-      arguments.add(js.string(namer.operatorIs(type.element)));
+      additionalArgument = ",$_'${namer.operatorIs(type.element)}'";
     }
-
     String setterName = namer.setterNameFromAccessorName(accessorName);
-    builder.addProperty(setterName,
-        js.fun(['v'],
-            js.block1(
-                new js.ExpressionStatement(
-                    js.assign(
-                        js.use('this').dot(fieldName),
-                        js.call(js.use(helperName), arguments))))));
+    buffer.add("$setterName:${_}function(v)$_{$_"
+        "this.$fieldName$_=$_$helperName(v$additionalArgument);}");
   }
 
-  void emitClassConstructor(ClassElement classElement, ClassBuilder builder) {
+  void emitClassConstructor(ClassElement classElement, CodeBuffer buffer) {
     /* Do nothing. */
   }
 
-  void emitSuper(String superName, ClassBuilder builder) {
+  void emitSuper(String superName, CodeBuffer buffer) {
     /* Do nothing. */
   }
 
   void emitClassFields(ClassElement classElement,
-                       ClassBuilder builder,
+                       CodeBuffer buffer,
+                       bool emitEndingComma,
                        { String superClass: "",
                          bool classIsNative: false}) {
     bool isFirstField = true;
-    StringBuffer buffer = new StringBuffer();
+    bool isAnythingOutput = false;
     if (!classIsNative) {
-      buffer.add('$superClass;');
+      buffer.add('"":"$superClass;');
+      isAnythingOutput = true;
     }
     visitClassFields(classElement, (Element member,
                                     String name,
                                     String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
       // Ignore needsCheckedSetter - that is handled below.
       bool needsAccessor = (needsGetter || needsSetter);
       // We need to output the fields for non-native classes so we can auto-
       // generate the constructor.  For native classes there are no
       // constructors, so we don't need the fields unless we are generating
       // accessors at runtime.
       if (!classIsNative || needsAccessor) {
         // Emit correct commas.
         if (isFirstField) {
           isFirstField = false;
+          if (!isAnythingOutput) {
+            buffer.add('"":"');
+            isAnythingOutput = true;
+          }
         } else {
-          buffer.add(',');
+          buffer.add(",");
         }
         int flag = 0;
         if (!needsAccessor) {
           // Emit field for constructor generation.
           assert(!classIsNative);
           buffer.add(name);
         } else {
           // Emit (possibly renaming) field name so we can add accessors at
           // runtime.
           buffer.add(accessorName);
           if (name != accessorName) {
             buffer.add(':$name');
             // Only the native classes can have renaming accessors.
             assert(classIsNative);
             flag = RENAMING_FLAG;
           }
         }
         if (needsGetter && needsSetter) {
           buffer.addCharCode(GETTER_SETTER_CODE + flag);
         } else if (needsGetter) {
           buffer.addCharCode(GETTER_CODE + flag);
         } else if (needsSetter) {
           buffer.addCharCode(SETTER_CODE + flag);
         }
       }
     });
-
-    String compactClassData = buffer.toString();
-    if (compactClassData.length > 0) {
-      builder.addProperty('', js.string(compactClassData));
+    if (isAnythingOutput) {
+      buffer.add('"');
+      if (emitEndingComma) {
+        buffer.add(',');
+      }
     }
   }
 
+  /** Each getter/setter must be prefixed with a ",\n ". */
   void emitClassGettersSetters(ClassElement classElement,
-                               ClassBuilder builder) {
+                               CodeBuffer buffer,
+                               bool emitLeadingComma) {
+    emitComma() {
+      if (emitLeadingComma) {
+        buffer.add(",\n$_");
+      } else {
+        emitLeadingComma = true;
+      }
+    }
 
     visitClassFields(classElement, (Element member,
                                     String name,
                                     String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
       if (needsCheckedSetter) {
         assert(!needsSetter);
-        generateCheckedSetter(member, name, accessorName, builder);
+        emitComma();
+        generateCheckedSetter(member, name, accessorName, buffer);
       }
       if (!getterAndSetterCanBeImplementedByFieldSpec) {
         if (needsGetter) {
-          generateGetter(member, name, accessorName, builder);
+          emitComma();
+          generateGetter(member, name, accessorName, buffer);
         }
         if (needsSetter) {
-          generateSetter(member, name, accessorName, builder);
+          emitComma();
+          generateSetter(member, name, accessorName, buffer);
         }
       }
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
@@ skipping 10 matching lines @@
     }
 
     needsDefineClass = true;
     String className = namer.getName(classElement);
     ClassElement superclass = classElement.superclass;
     String superName = "";
     if (superclass != null) {
       superName = namer.getName(superclass);
     }
 
-    ClassBuilder builder = new ClassBuilder();
-
-    emitClassConstructor(classElement, builder);
-    emitSuper(superName, builder);
-    emitClassFields(classElement, builder,
+    buffer.add('$classesCollector.$className$_=$_{');
+    emitClassConstructor(classElement, buffer);
+    emitSuper(superName, buffer);
+    emitClassFields(classElement, buffer, false,
                     superClass: superName, classIsNative: false);
-    emitClassGettersSetters(classElement, builder);
-    emitInstanceMembers(classElement, builder);
-
-    js.Expression init =
-        js.assign(
-            js.use(classesCollector).dot(className),
-            builder.toObjectInitializer());
-    buffer.add(js.prettyPrint(init, compiler));
-    buffer.add('$N$n');
+    // TODO(floitsch): the emitInstanceMember should simply always emit a ',\n'.
+    // That does currently not work because the native classes have a different
+    // syntax.
+    emitClassGettersSetters(classElement, buffer, true);
+    emitInstanceMembers(classElement, buffer, true);
+    buffer.add('$n}$N$n');
   }
 
   bool get getterAndSetterCanBeImplementedByFieldSpec => true;
 
-  void emitInterceptorMethods(ClassBuilder builder) {
+  void emitInterceptorMethods(
+      void defineInstanceMember(String name, StringBuffer memberBuffer)) {
     JavaScriptBackend backend = compiler.backend;
     // Emit forwarders for the ObjectInterceptor class. We need to
     // emit all possible sends on intercepted methods.
     for (Selector selector in backend.usedInterceptors) {
 
       List<js.Parameter> parameters = <js.Parameter>[];
       List<js.Expression> arguments = <js.Expression>[];
       parameters.add(new js.Parameter('receiver'));
 
       String name;
@@ skipping 13 matching lines @@
         }
       }
       js.Fun function =
           new js.Fun(parameters,
               new js.Block(
                   <js.Statement>[
                       new js.Return(
                           new js.VariableUse('receiver')
                               .dot(name)
                               .callWith(arguments))]));
-      builder.addProperty(name, function);
+
+      CodeBuffer code = new CodeBuffer();
+      code.add(js.prettyPrint(function, compiler));
+      defineInstanceMember(name, code);
     }
   }
 
   Collection<Element> getTypedefChecksOn(DartType type) {
     return checkedTypedefs.filter((TypedefElement typedef) {
       FunctionType typedefType =
           typedef.computeType(compiler).unalias(compiler);
       return compiler.types.isSubtype(type, typedefType);
     });
   }
@@ skipping 145 matching lines @@
   }
 
   void emitFinishClassesInvocationIfNecessary(CodeBuffer buffer) {
     if (needsDefineClass) {
       buffer.add("$finishClassesName($classesCollector)$N");
       // Reset the map.
       buffer.add("$classesCollector$_=$_{}$N");
     }
   }
 
-  void emitStaticFunction(CodeBuffer buffer,
-                          String name,
-                          js.Expression functionExpression) {
-    js.Expression assignment =
-        js.assign(js.use(isolateProperties).dot(name), functionExpression);
-    buffer.add(js.prettyPrint(assignment, compiler));
+  void emitStaticFunctionWithNamer(CodeBuffer buffer,
+                                   Element element,
+                                   CodeBuffer functionBuffer,
+                                   String functionNamer(Element element)) {
+    String functionName = functionNamer(element);
+    buffer.add('$isolateProperties.$functionName$_=$_');
+    buffer.add(functionBuffer);
     buffer.add('$N$n');
   }
 
   void emitStaticFunctions(CodeBuffer buffer) {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
     Collection<Element> elements =
         compiler.codegenWorld.generatedCode.keys.filter(isStaticFunction);
     Set<Element> pendingElementsWithBailouts =
         new Set<Element>.from(
             compiler.codegenWorld.generatedBailoutCode.keys.filter(
                 isStaticFunction));
 
     for (Element element in Elements.sortedByPosition(elements)) {
-      js.Expression code = compiler.codegenWorld.generatedCode[element];
-      emitStaticFunction(buffer, namer.getName(element), code);
-      js.Expression bailoutCode =
+      CodeBuffer code = compiler.codegenWorld.generatedCode[element];
+      emitStaticFunctionWithNamer(buffer, element, code, namer.getName);
+      CodeBuffer bailoutCode =
           compiler.codegenWorld.generatedBailoutCode[element];
       if (bailoutCode != null) {
         pendingElementsWithBailouts.remove(element);
-        emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
+        emitStaticFunctionWithNamer(
+            buffer, element, bailoutCode, namer.getBailoutName);
       }
     }
 
     // Is it possible the primary function was inlined but the bailout was not?
     for (Element element in
              Elements.sortedByPosition(pendingElementsWithBailouts)) {
       CodeBuffer bailoutCode =
           compiler.codegenWorld.generatedBailoutCode[element];
-      emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
+      emitStaticFunctionWithNamer(
+          buffer, element, bailoutCode, namer.getBailoutName);
     }
   }
 
   void emitStaticFunctionGetters(CodeBuffer buffer) {
     Set<FunctionElement> functionsNeedingGetter =
         compiler.codegenWorld.staticFunctionsNeedingGetter;
-    for (FunctionElement element in functionsNeedingGetter) {
+    for (FunctionElement element in
+             Elements.sortedByPosition(functionsNeedingGetter)) {
       // The static function does not have the correct name. Since
       // [addParameterStubs] use the name to create its stubs we simply
       // create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(namer.closureInvocationSelectorName,
                                        element);
       String staticName = namer.getName(element);
       String invocationName = namer.instanceMethodName(callElement);
       String fieldAccess = '$isolateProperties.$staticName';
       buffer.add("$fieldAccess.$invocationName$_=$_$fieldAccess$N");
-
-      addParameterStubs(callElement, (String name, js.Expression value) {
-        js.Expression assignment =
-            js.assign(
-                js.use(isolateProperties).dot(staticName).dot(name),
-                value);
-        buffer.add(
-            js.prettyPrint(new js.ExpressionStatement(assignment), compiler));
-        buffer.add('$N');
+      addParameterStubs(callElement, (String name, CodeBuffer value) {
+        buffer.add('$fieldAccess.$name$_=$_$value$N');
       });
-
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.add('$fieldAccess.$fieldName$_=$_"$staticName"$N');
       getTypedefChecksOn(element.computeType(compiler)).forEach(
         (Element typedef) {
           String operator = namer.operatorIs(typedef);
           buffer.add('$fieldAccess.$operator$_=${_}true$N');
         }
       );
     }
   }
 
   void emitBoundClosureClassHeader(String mangledName,
                                    String superName,
                                    List<String> fieldNames,
-                                   ClassBuilder builder) {
-    builder.addProperty('',
-        js.string("$superName;${Strings.join(fieldNames,',')}"));
+                                   CodeBuffer buffer) {
+    buffer.add('$classesCollector.$mangledName$_=$_'
+               '{"":"$superName;${Strings.join(fieldNames,',')}",');
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitDynamicFunctionGetter(FunctionElement member,
-                                 DefineStubFunction defineStub) {
+                                 DefineMemberFunction defineInstanceMember) {
     assert(invariant(member, member.isDeclaration));
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
     // 'foo'. Then we generate the following code (in pseudo Dart/JavaScript):
     //
     // class A {
     //    foo(x, y, z) { ... } // Original function.
     //    get foo { return new BoundClosure499(this, "foo"); }
     // }
@@ skipping 42 matching lines @@
       // Create a new closure class.
       SourceString name = const SourceString("BoundClosure");
       ClassElement closureClassElement = new ClosureClassElement(
           name, compiler, member, member.getCompilationUnit());
       String mangledName = namer.getName(closureClassElement);
       String superName = namer.getName(closureClassElement.superclass);
       needsClosureClass = true;
 
       // Define the constructor with a name so that Object.toString can
       // find the class name of the closure class.
-      ClassBuilder boundClosureBuilder = new ClassBuilder();
       emitBoundClosureClassHeader(
-          mangledName, superName, fieldNames, boundClosureBuilder);
+          mangledName, superName, fieldNames, boundClosureBuffer);
       // Now add the methods on the closure class. The instance method does not
       // have the correct name. Since [addParameterStubs] use the name to create
       // its stubs we simply create a fake element with the correct name.
       // Note: the callElement will not have any enclosingElement.
       FunctionElement callElement =
           new ClosureInvocationElement(namer.closureInvocationSelectorName,
                                        member);
 
       String invocationName = namer.instanceMethodName(callElement);
 
@@ skipping 10 matching lines @@
 
       js.Expression fun =
           new js.Fun(parameters,
               new js.Block(
                   <js.Statement>[
                       new js.Return(
                           new js.PropertyAccess(
                               new js.This().dot(fieldNames[0]),
                               new js.This().dot(fieldNames[1]))
                           .callWith(arguments))]));
-      boundClosureBuilder.addProperty(invocationName, fun);
 
-      addParameterStubs(callElement, boundClosureBuilder.addProperty);
+      boundClosureBuffer.add(
+          '$_$invocationName:$_${js.prettyPrint(fun,compiler)}');
+
+      addParameterStubs(callElement, (String stubName, CodeBuffer memberValue) {
+        boundClosureBuffer.add(',\n$_$stubName:$_$memberValue');
+      });
+
       typedefChecks.forEach((Element typedef) {
         String operator = namer.operatorIs(typedef);
-        boundClosureBuilder.addProperty(operator, new js.LiteralBool(true));
+        boundClosureBuffer.add(',\n$_$operator$_:${_}true');
       });
 
-      js.Expression init =
-          js.assign(
-              js.use(classesCollector).dot(mangledName),
-              boundClosureBuilder.toObjectInitializer());
-      boundClosureBuffer.add(js.prettyPrint(init, compiler));
-      boundClosureBuffer.add("$N");
+      boundClosureBuffer.add("$n}$N");
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (canBeShared) {
         cache[parameterCount] = closureClass;
       }
     }
 
     // And finally the getter.
     String getterName = namer.getterName(member.getLibrary(), member.name);
     String targetName = namer.instanceMethodName(member);
 
     List<js.Parameter> parameters = <js.Parameter>[];
     List<js.Expression> arguments = <js.Expression>[];
     arguments.add(new js.This());
-    arguments.add(js.string(targetName));
+    arguments.add(new js.LiteralString("'$targetName'"));
     if (inInterceptor) {
       parameters.add(new js.Parameter(extraArg));
       arguments.add(new js.VariableUse(extraArg));
     }
 
     js.Expression getterFunction =
         new js.Fun(parameters,
             new js.Block(
                 <js.Statement>[
                     new js.Return(
                         new js.New(
                             new js.VariableUse(closureClass),
                             arguments))]));
 
-    defineStub(getterName, getterFunction);
+    CodeBuffer getterBuffer = new CodeBuffer();
+    getterBuffer.add(js.prettyPrint(getterFunction, compiler));
+    defineInstanceMember(getterName, getterBuffer);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
-                             DefineStubFunction defineStub) {
+                             DefineMemberFunction defineInstanceMember) {
     assert(invariant(member, member.isDeclaration));
     LibraryElement memberLibrary = member.getLibrary();
     JavaScriptBackend backend = compiler.backend;
     // If the class is an interceptor class, the stub gets the
     // receiver explicitely and we need to pass it to the getter call.
     bool isInterceptorClass =
         backend.isInterceptorClass(member.getEnclosingClass());
 
     const String receiverArgumentName = r'$receiver';
 
@@ skipping 35 matching lines @@
         }
 
         js.Fun function =
             new js.Fun(parameters,
                 new js.Block(
                     <js.Statement>[
                         new js.Return(
                             buildGetter().dot(closureCallName)
                                 .callWith(arguments))]));
 
-        defineStub(invocationName, function);
+        CodeBuffer getterBuffer = new CodeBuffer();
+        getterBuffer.add(js.prettyPrint(function, compiler));
+        defineInstanceMember(invocationName, getterBuffer);
       }
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in staticNonFinalFields) {
       compiler.withCurrentElement(element, () {
@@ skipping 11 matching lines @@
   }
 
   void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
       for (VariableElement element in lazyFields) {
         assert(compiler.codegenWorld.generatedBailoutCode[element] == null);
-        js.Expression code = compiler.codegenWorld.generatedCode[element];
+        StringBuffer code = compiler.codegenWorld.generatedCode[element];
         assert(code != null);
         // The code only computes the initial value. We build the lazy-check
         // here:
         //   lazyInitializer(prototype, 'name', fieldName, getterName, initial);
         // The name is used for error reporting. The 'initial' must be a
         // closure that constructs the initial value.
         buffer.add("$lazyInitializerName(");
         buffer.add(isolateProperties);
         buffer.add(",$_'");
         buffer.add(element.name.slowToString());
         buffer.add("',$_'");
         buffer.add(namer.getName(element));
         buffer.add("',$_'");
         buffer.add(namer.getLazyInitializerName(element));
         buffer.add("',$_");
-        buffer.add(js.prettyPrint(code, compiler));
+        buffer.add(code);
         emitLazyInitializedGetter(element, buffer);
         buffer.add(")$N");
       }
     }
   }
 
   void emitLazyInitializedGetter(VariableElement element, CodeBuffer buffer) {
     // Nothing to do, the 'lazy' function will create the getter.
   }
 
@@ skipping 35 matching lines @@
   return list;
 };
 ''');
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
-  void emitExtraAccessors(Element member, ClassBuilder builder) {
+  void emitExtraAccessors(Element member,
+                          DefineMemberFunction defineInstanceMember) {
     assert(invariant(member, member.isDeclaration));
     if (member.isGetter() || member.isField()) {
       Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
       if (selectors != null && !selectors.isEmpty) {
-        emitCallStubForGetter(member, selectors, builder.addProperty);
+        emitCallStubForGetter(member, selectors, defineInstanceMember);
       }
     } else if (member.isFunction()) {
       if (compiler.codegenWorld.hasInvokedGetter(member, compiler)) {
-        emitDynamicFunctionGetter(member, builder.addProperty);
+        emitDynamicFunctionGetter(member, defineInstanceMember);
       }
     }
   }
 
-  void emitNoSuchMethodHandlers(DefineStubFunction defineStub) {
+  void emitNoSuchMethodHandlers(DefineMemberFunction defineInstanceMember) {
     // Do not generate no such method handlers if there is no class.
     if (compiler.codegenWorld.instantiatedClasses.isEmpty) return;
 
     String noSuchMethodName = namer.publicInstanceMethodNameByArity(
         Compiler.NO_SUCH_METHOD, Compiler.NO_SUCH_METHOD_ARG_COUNT);
 
     Element createInvocationMirrorElement =
         compiler.findHelper(const SourceString("createInvocationMirror"));
     String createInvocationMirrorName =
         namer.getName(createInvocationMirrorElement);
@@ skipping 25 matching lines @@
       int type = selector.invocationMirrorKind;
       String methodName = selector.invocationMirrorMemberName;
       List<js.Parameter> parameters = <js.Parameter>[];
       CodeBuffer args = new CodeBuffer();
       for (int i = 0; i < selector.argumentCount; i++) {
         parameters.add(new js.Parameter('\$$i'));
       }
 
       List<js.Expression> argNames =
           selector.getOrderedNamedArguments().map((SourceString name) =>
-              js.string(name.slowToString()));
+              new js.LiteralString('"${name.slowToString()}"'));
 
       String internalName = namer.invocationMirrorInternalName(selector);
 
       String createInvocationMirror = namer.getName(
           compiler.createInvocationMirrorElement);
 
       js.Expression expression =
           new js.This()
           .dot(noSuchMethodName)
           .callWith(
               <js.Expression>[
                   new js.VariableUse(namer.CURRENT_ISOLATE)
                   .dot(createInvocationMirror)
                   .callWith(
                       <js.Expression>[
-                          js.string(methodName),
-                          js.string(internalName),
+                          new js.LiteralString('"$methodName"'),
+                          new js.LiteralString('"$internalName"'),
                           new js.LiteralNumber('$type'),
                           new js.ArrayInitializer.from(
-                              parameters.map((param) => js.use(param.name))),
+                              parameters.map((param) =>
+                                  new js.VariableUse(param.name))),
                           new js.ArrayInitializer.from(argNames)])]);
       js.Expression function =
           new js.Fun(parameters,
               new js.Block(<js.Statement>[new js.Return(expression)]));
       return function;
     }
 
     void addNoSuchMethodHandlers(SourceString ignore, Set<Selector> selectors) {
       // Cache the object class and type.
       ClassElement objectClass = compiler.objectClass;
@@ skipping 77 matching lines @@
         // bar through inheritance.
         //
         // If we're calling bar on an object of type A we do need the
         // handler because we may have to call B.noSuchMethod since B
         // does not implement bar.
         Set<ClassElement> holders = noSuchMethodHoldersFor(receiverType);
         if (holders.every(hasMatchingMember)) continue;
         String jsName = namer.invocationMirrorInternalName(selector);
         if (!addedJsNames.contains(jsName)) {
           js.Expression method = generateMethod(jsName, selector);
-          defineStub(jsName, method);
+          CodeBuffer jsCode = new CodeBuffer();
+          jsCode.add(js.prettyPrint(method, compiler));
+          defineInstanceMember(jsName, jsCode);
           addedJsNames.add(jsName);
         }
       }
     }
 
     compiler.codegenWorld.invokedNames.forEach(addNoSuchMethodHandlers);
     compiler.codegenWorld.invokedGetters.forEach(addNoSuchMethodHandlers);
     compiler.codegenWorld.invokedSetters.forEach(addNoSuchMethodHandlers);
   }
 
@@ skipping 281 matching lines @@
                      '${_}new ${namer.isolateName}()$N');
 
       nativeEmitter.assembleCode(mainBuffer);
       emitMain(mainBuffer);
       mainBuffer.add('function init()$_{\n');
       mainBuffer.add('$isolateProperties$_=$_{}$N');
       addDefineClassAndFinishClassFunctionsIfNecessary(mainBuffer);
       addLazyInitializerFunctionIfNecessary(mainBuffer);
       emitFinishIsolateConstructor(mainBuffer);
       mainBuffer.add('}\n');
-      compiler.assembledCode = mainBuffer.getText();
+      compiler.assembledCode = mainBuffer.toString();
 
       if (generateSourceMap) {
         SourceFile compiledFile = new SourceFile(null, compiler.assembledCode);
         String sourceMap = buildSourceMap(mainBuffer, compiledFile);
         // TODO(podivilov): We should find a better way to return source maps to
         // compiler. Using diagnostic handler for that purpose is a temporary
         // hack.
         compiler.reportDiagnostic(
             null, sourceMap, new api.Diagnostic(-1, 'source map'));
       }
     });
     return compiler.assembledCode;
   }
 
   String buildSourceMap(CodeBuffer buffer, SourceFile compiledFile) {
     SourceMapBuilder sourceMapBuilder = new SourceMapBuilder();
     buffer.forEachSourceLocation(sourceMapBuilder.addMapping);
     return sourceMapBuilder.build(compiledFile);
   }
 }
 
+typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);
+
 const String GENERATED_BY = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;