Generate tear-off closures dynamically.

dart/sdk/lib/_internal/compiler/implementation/js_emitter/class_emitter.dart

 // Copyright (c) 2013, 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;
 
 class ClassEmitter extends CodeEmitterHelper {
   /**
    * Documentation wanted -- johnniwinther
    *
@@ skipping 90 matching lines @@
     bool isLibrary = false;
     if (element.isClass()) {
       isClass = true;
     } else if (element.isLibrary()) {
       isLibrary = false;
       assert(invariant(element, emitStatics));
     } else {
       throw new SpannableAssertionFailure(
           element, 'Must be a ClassElement or a LibraryElement');
     }
-    StringBuffer buffer = new StringBuffer();
     if (emitStatics) {
       assert(invariant(element, superName == null, message: superName));
     } else {
       assert(invariant(element, superName != null));
       String nativeName =
           namer.getPrimitiveInterceptorRuntimeName(element);
       if (nativeName != null) {
-        buffer.write('$nativeName/');
+        builder.nativeName = nativeName;
       }
-      buffer.write('$superName;');
+      builder.superName = superName;
     }
-    int bufferClassLength = buffer.length;
-
-    String separator = '';
-
     var fieldMetadata = [];
     bool hasMetadata = false;
+    bool fieldsAdded = false;
 
     if (!onlyForRti) {
       visitFields(element, emitStatics,
                   (VariableElement field,
                    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) {
-          buffer.write(separator);
-          separator = ',';
           var metadata = task.metadataEmitter.buildMetadataFunction(field);
           if (metadata != null) {
             hasMetadata = true;
           } else {
             metadata = new jsAst.LiteralNull();
           }
           fieldMetadata.add(metadata);
           recordMangledField(field, accessorName, field.name);
+          String fieldName = name;
+          String fieldCode = '';
+          String reflectionMarker = '';
           if (!needsAccessor) {
             // Emit field for constructor generation.
             assert(!classIsNative);
-            buffer.write(name);
           } else {
             // Emit (possibly renaming) field name so we can add accessors at
             // runtime.
-            buffer.write(accessorName);
             if (name != accessorName) {
-              buffer.write(':$name');
+              fieldName = '$accessorName:$name';
             }
 
             int getterCode = 0;
             if (needsGetter) {
               if (field.isInstanceMember()) {
                 // 01:  function() { return this.field; }
                 // 10:  function(receiver) { return receiver.field; }
                 // 11:  function(receiver) { return this.field; }
                 bool isIntercepted = backend.fieldHasInterceptedGetter(field);
                 getterCode += isIntercepted ? 2 : 0;
@@ skipping 26 matching lines @@
                 }
               } else {
                 setterCode = 1;
               }
             }
             int code = getterCode + (setterCode << 2);
             if (code == 0) {
               compiler.reportInternalError(
                   field, 'Internal error: code is 0 ($element/$field)');
             } else {
-              buffer.write(FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE]);
+              fieldCode = FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE];
             }
           }
           if (backend.isAccessibleByReflection(field)) {
-            buffer.write('-');
+            reflectionMarker = '-';
             if (backend.isNeededForReflection(field)) {
               DartType type = field.computeType(compiler);
-              buffer.write('${task.metadataEmitter.reifyType(type)}');
+              reflectionMarker = '-${task.metadataEmitter.reifyType(type)}';
             }
           }
+          builder.addField('$fieldName$fieldCode$reflectionMarker');
+          fieldsAdded = true;
         }
       });
     }
 
-    bool fieldsAdded = buffer.length > bufferClassLength;
-    String compactClassData = buffer.toString();
-    jsAst.Expression classDataNode = js.string(compactClassData);
     if (hasMetadata) {
-      fieldMetadata.insert(0, classDataNode);
-      classDataNode = new jsAst.ArrayInitializer.from(fieldMetadata);
+      builder.fieldMetadata = fieldMetadata;
     }
-    builder.addProperty('', classDataNode);
     return fieldsAdded;
   }
 
   void emitClassGettersSetters(ClassElement classElement,
                                ClassBuilder builder,
                                {bool onlyForRti: false}) {
     if (onlyForRti) return;
 
     visitFields(classElement, false,
                 (VariableElement member,
@@ skipping 71 matching lines @@
       if ((!typeVariableProperties.isEmpty && !hasSuper) ||
           (hasSuper && superclass.typeVariables != typeVars)) {
         classBuilder.addProperty('<>',
             new jsAst.ArrayInitializer.from(typeVariableProperties));
       }
     }
 
     List<jsAst.Property> statics = new List<jsAst.Property>();
     ClassBuilder staticsBuilder = new ClassBuilder();
     if (emitFields(classElement, staticsBuilder, null, emitStatics: true)) {
-      statics.add(staticsBuilder.properties.single);
+      statics.add(staticsBuilder.toObjectInitializer().properties.single);
     }
 
     Map<String, ClassBuilder> classPropertyLists =
         task.elementDecriptors.remove(classElement);
     if (classPropertyLists != null) {
       for (ClassBuilder classProperties in classPropertyLists.values) {
         // TODO(ahe): What about deferred?
         if (classProperties != null) {
           statics.addAll(classProperties.properties);
         }
@@ skipping 265 matching lines @@
       computeTypeVariable =
           js(r'this.$builtinTypeInfo && this.$builtinTypeInfo[#]', index);
     }
     jsAst.Expression convertRtiToRuntimeType =
         namer.elementAccess(compiler.findHelper('convertRtiToRuntimeType'));
     builder.addProperty(
         name, js.fun(
             [], [js.return_(convertRtiToRuntimeType(computeTypeVariable))]));
   }
 }