Only have one method for generating a method.

dart/sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.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 dart2js.js_emitter;
 
 /**
  * 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.
  *
@@ skipping 893 matching lines @@
             || compiler.codegenWorld.hasInvokedSetter(field, compiler));
   }
 
   // We never access a field in a closure (a captured variable) without knowing
   // that it is there.  Therefore we don't need to use a getter (that will throw
   // if the getter method is missing), but can always access the field directly.
   static bool fieldAccessNeverThrows(VariableElement field) {
     return field is ClosureFieldElement;
   }
 
-  /**
-   * Documentation wanted -- johnniwinther
-   *
-   * Invariant: [member] must be a declaration element.
-   */
-  void addInstanceMember(Element member, ClassBuilder builder) {
-    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;
-      jsAst.Expression code = backend.generatedCode[member];
-      if (code == null) return;
-      String name = namer.getNameOfInstanceMember(member);
-      if (backend.isInterceptedMethod(member)) {
-        interceptorInvocationNames.add(name);
-      }
-      code = extendWithMetadata(member, code);
-      builder.addProperty(name, code);
-      String reflectionName = getReflectionName(member, name);
-      if (reflectionName != null) {
-        var reflectable =
-            js(backend.isAccessibleByReflection(member) ? '1' : '0');
-        builder.addProperty('+$reflectionName', reflectable);
-        jsAst.Node defaultValues = reifyDefaultArguments(member);
-        if (defaultValues != null) {
-          String unmangledName = member.name.slowToString();
-          builder.addProperty('*$unmangledName', defaultValues);
-        }
-      }
-      code = backend.generatedBailoutCode[member];
-      if (code != null) {
-        builder.addProperty(namer.getBailoutName(member), code);
-      }
-      FunctionElement function = member;
-      FunctionSignature parameters = function.computeSignature(compiler);
-      if (!parameters.optionalParameters.isEmpty) {
-        containerBuilder.addParameterStubs(function, builder.addProperty);
-      }
-    } else if (!member.isField()) {
-      compiler.internalError('unexpected kind: "${member.kind}"',
-                             element: member);
-    }
-    containerBuilder.emitExtraAccessors(member, builder);
-  }
-
   /// Returns the "reflection name" of an [Element] or [Selector].
   /// The reflection name of a getter 'foo' is 'foo'.
   /// The reflection name of a setter 'foo' is 'foo='.
   /// The reflection name of a method 'foo' is 'foo:N:M:O', where N is the
   /// number of required arguments, M is the number of optional arguments, and
   /// O is the named arguments.
   /// The reflection name of a constructor is similar to a regular method but
   /// starts with 'new '.
   /// The reflection name of class 'C' is 'C'.
   /// An anonymous mixin application has no reflection name.
@@ skipping 102 matching lines @@
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void emitInstanceMembers(ClassElement classElement,
                            ClassBuilder builder) {
     assert(invariant(classElement, classElement.isDeclaration));
 
     void visitMember(ClassElement enclosing, Element member) {
       assert(invariant(classElement, member.isDeclaration));
       if (member.isInstanceMember()) {
-        addInstanceMember(member, builder);
+        containerBuilder.addMember(member, builder);
       }
     }
 
     classElement.implementation.forEachMember(
         visitMember,
         includeBackendMembers: true);
 
     if (identical(classElement, compiler.objectClass)
         && compiler.enabledNoSuchMethod) {
       // Emit the noSuchMethod handlers on the Object prototype now,
@@ skipping 935 matching lines @@
     if (needsDefineClass) {
       buffer.write('$finishClassesName($classesCollector,'
                    '$_$isolateProperties,'
                    '${_}null)$N');
 
       // Reset the map.
       buffer.write("$classesCollector$_=${_}null$N$n");
     }
   }
 
-  void emitStaticFunction(CodeBuffer buffer,
-                          String name,
-                          jsAst.Expression functionExpression) {
-    // TODO(ahe): This method (emitStaticFunction) should return a
-    // jsAst.Expression.
-    if (!buffer.isEmpty) {
-      buffer.write(',$n$n');
-    }
-    buffer.write('$name:$_');
-    buffer.write(jsAst.prettyPrint(functionExpression, compiler));
-  }
-
   void emitStaticFunctions(CodeBuffer eagerBuffer) {
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
     Set<Element> pendingElementsWithBailouts =
         backend.generatedBailoutCode.keys
             .where(isStaticFunction)
             .toSet();
 
     for (Element element in Elements.sortedByPosition(elements)) {
-      CodeBuffer buffer = bufferForElement(element, eagerBuffer);
-      jsAst.Expression code = backend.generatedCode[element];
-      String name = namer.getNameOfGlobalFunction(element);
-      code = extendWithMetadata(element, code);
-      emitStaticFunction(buffer, name, code);
-      String reflectionName = getReflectionName(element, name);
-      if (reflectionName != null) {
-        var reflectable = backend.isAccessibleByReflection(element) ? 1 : 0;
-        buffer.write(',$n$n"+$reflectionName":${_}$reflectable');
-        jsAst.Node defaultValues = reifyDefaultArguments(element);
-        if (defaultValues != null) {
-          String unmangledName = element.name.slowToString();
-          buffer.write(',$n$n"*$unmangledName":${_}');
-          buffer.write(jsAst.prettyPrint(defaultValues, compiler));
-        }
-      }
-      jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
-      if (bailoutCode != null) {
-        pendingElementsWithBailouts.remove(element);
-        emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
-      }
+      pendingElementsWithBailouts.remove(element);
+      ClassBuilder builder = new ClassBuilder();
+      containerBuilder.addMember(element, builder);
+      builder.writeOn(
+          bufferForElement(element, eagerBuffer), compiler, ',$n$n');

[kasperl, 2013/10/03 07:08:37]

Nit: I'd compute the buffer and throw it in a local to avoid the line break.

[ahe, 2013/10/03 07:20:17]

I find code more readable when I can easily see that an expression is only used
once.

     }
 
     if (!pendingElementsWithBailouts.isEmpty) {
       addComment('pendingElementsWithBailouts', eagerBuffer);
     }
     // Is it possible the primary function was inlined but the bailout was not?
     for (Element element in
              Elements.sortedByPosition(pendingElementsWithBailouts)) {
-      CodeBuffer buffer = bufferForElement(element, eagerBuffer);
       jsAst.Expression bailoutCode = backend.generatedBailoutCode[element];
-      emitStaticFunction(buffer, namer.getBailoutName(element), bailoutCode);
+      new ClassBuilder()
+          ..addProperty(namer.getBailoutName(element), bailoutCode)
+          ..writeOn(bufferForElement(element, eagerBuffer), compiler, ',$n$n');
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
       // [:interceptedNames:] is handled in [emitInterceptedNames].
       if (element == backend.interceptedNames) continue;
@@ skipping 952 matching lines @@
     return addGlobalMetadata('"${name.slowToString()}"');
   }
 
   int addGlobalMetadata(String string) {
     return globalMetadataMap.putIfAbsent(string, () {
       globalMetadata.add(string);
       return globalMetadata.length - 1;
     });
   }
 
-  jsAst.Fun extendWithMetadata(FunctionElement element, jsAst.Fun code) {
-    if (!backend.retainMetadataOf(element)) return code;
-    return compiler.withCurrentElement(element, () {
-      List<int> metadata = <int>[];
-      FunctionSignature signature = element.functionSignature;
-      if (element.isConstructor()) {
-        metadata.add(reifyType(element.getEnclosingClass().thisType));
-      } else {
-        metadata.add(reifyType(signature.returnType));
-      }
-      signature.forEachParameter((Element parameter) {
-        metadata
-            ..add(reifyName(parameter.name))
-            ..add(reifyType(parameter.computeType(compiler)));
-      });
-      Link link = element.metadata;
-      // TODO(ahe): Why is metadata sometimes null?
-      if (link != null) {
-        for (; !link.isEmpty; link = link.tail) {
-          metadata.add(reifyMetadata(link.head));
-        }
-      }
-      code.body.statements.add(js.string(metadata.join(',')).toStatement());
-      return code;
-    });
-  }
-
   void emitMetadata(CodeBuffer buffer) {
     var literals = backend.typedefTypeLiterals.toList();
     Elements.sortedByPosition(literals);
     var properties = [];
     for (TypedefElement literal in literals) {
       var key = namer.getNameX(literal);
       var value = js.toExpression(reifyType(literal.rawType));
       properties.add(new jsAst.Property(js.string(key), value));
     }
     var map = new jsAst.ObjectInitializer(properties);
@@ skipping 492 matching lines @@
   }
 
   bool isDeferred(Element element) {
     return compiler.deferredLoadTask.isDeferred(element);
   }
 
   bool get areAnyElementsDeferred {
     return compiler.deferredLoadTask.areAnyElementsDeferred;
   }
 }