dart2js: Use frequency of occurence to sort metadata indices.

pkg/compiler/lib/src/js_emitter/old_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 {
 
   ClassStubGenerator get _stubGenerator =>
       new ClassStubGenerator(compiler, namer, backend);
@@ skipping 110 matching lines @@
         var metadata =
             task.metadataCollector.buildMetadataFunction(fieldElement);
         if (metadata != null) {
           hasMetadata = true;
         } else {
           metadata = new jsAst.LiteralNull();
         }
         fieldMetadata.add(metadata);
         recordMangledField(fieldElement, accessorName,
             namer.privateName(fieldElement.memberName));
-        String fieldName = name;
-        String fieldCode = '';
-        String reflectionMarker = '';
+        List<jsAst.Literal> fieldNameParts = <jsAst.Literal>[];
         if (!needsAccessor) {
           // Emit field for constructor generation.
           assert(!classIsNative);
+          fieldNameParts.add(js.stringPart(name));
         } else {
           // Emit (possibly renaming) field name so we can add accessors at
           // runtime.
           if (name != accessorName) {
-            fieldName = '$accessorName:$name';
+            fieldNameParts.add(js.stringPart(accessorName));
+            fieldNameParts.add(js.stringPart(':'));
           }
-
+          fieldNameParts.add(js.stringPart(name));
           if (field.needsInterceptedGetter) {
             emitter.interceptorEmitter.interceptorInvocationNames.add(
                 namer.getterForElement(fieldElement));
           }
           // TODO(16168): The setter creator only looks at the getter-name.
           // Even though the setter could avoid the interceptor convention we
           // currently still need to add the additional argument.
           if (field.needsInterceptedGetter || field.needsInterceptedSetter) {
             emitter.interceptorEmitter.interceptorInvocationNames.add(
                 namer.setterForElement(fieldElement));
           }
 
           int code = field.getterFlags + (field.setterFlags << 2);
           if (code == 0) {
             compiler.internalError(fieldElement,
                 'Field code is 0 ($fieldElement).');
-          } else {
-            fieldCode = FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE];
           }
+          fieldNameParts.add(
+              js.stringPart(FIELD_CODE_CHARACTERS[code - FIRST_FIELD_CODE]));
         }
         // Fields can only be reflected if their declaring class is reflectable
         // (as they are only accessible via [ClassMirror.declarations]).
         // However, set/get operations can be performed on them, so they are
         // reflectable in some sense, which leads to [isAccessibleByReflection]
         // reporting `true`.
         if (backend.isAccessibleByReflection(fieldElement)) {
+          fieldNameParts.add(new jsAst.LiteralString('-'));
           if (fieldElement.isTopLevel ||
               backend.isAccessibleByReflection(fieldElement.enclosingClass)) {
             DartType type = fieldElement.type;
-            reflectionMarker = '-${task.metadataCollector.reifyType(type)}';
-          } else {
-            reflectionMarker = '-';
+            fieldNameParts.add(task.metadataCollector.reifyType(type));
           }
         }
-        String builtFieldname = '$fieldName$fieldCode$reflectionMarker';
-        builder.addField(builtFieldname);
+        jsAst.Literal fieldNameAst = js.concatenateStrings(fieldNameParts);
+        builder.addField(fieldNameAst);
         // Add 1 because adding a field to the class also requires a comma
-        compiler.dumpInfoTask.recordFieldNameSize(fieldElement,
-            builtFieldname.length + 1);
+        compiler.dumpInfoTask.registerElementAst(fieldElement, fieldNameAst);
         fieldsAdded = true;
       }
     }
 
     if (hasMetadata) {
       builder.fieldMetadata = fieldMetadata;
     }
     return fieldsAdded;
   }
 
@@ skipping 67 matching lines @@
       // them. Note that this helper is invoked before analyzing the
       // full JS script.
       emitter.nsmEmitter.emitNoSuchMethodHandlers(builder.addProperty);
     }
   }
 
   /// Emits the members from the model.
   void emitRuntimeTypeInformation(Class cls, ClassBuilder builder) {
     assert(builder.functionType == null);
     if (cls.functionTypeIndex != null) {
-      builder.functionType = '${cls.functionTypeIndex}';
+      builder.functionType = cls.functionTypeIndex;
     }
 
     for (Method method in cls.isChecks) {
       builder.addProperty(method.name, method.code);
     }
   }
 
   void emitNativeInfo(Class cls, ClassBuilder builder) {
     if (cls.nativeInfo != null) {
       builder.addProperty(namer.nativeSpecProperty, js.string(cls.nativeInfo));
     }
   }
 
   void emitClassBuilderWithReflectionData(Class cls,
                                           ClassBuilder classBuilder,
                                           ClassBuilder enclosingBuilder,
                                           Fragment fragment) {
     ClassElement classElement = cls.element;
     String className = cls.name;
 
     var metadata = task.metadataCollector.buildMetadataFunction(classElement);
     if (metadata != null) {
       classBuilder.addProperty("@", metadata);
     }
 
     if (backend.isAccessibleByReflection(classElement)) {
       List<DartType> typeVars = classElement.typeVariables;
       Iterable typeVariableProperties = emitter.typeVariableHandler
-          .typeVariablesOf(classElement).map(js.number);
+          .typeVariablesOf(classElement);
 
       ClassElement superclass = classElement.superclass;
       bool hasSuper = superclass != null;
       if ((!typeVariableProperties.isEmpty && !hasSuper) ||
           (hasSuper && !equalElements(superclass.typeVariables, typeVars))) {
         classBuilder.addProperty('<>',
             new jsAst.ArrayInitializer(typeVariableProperties.toList()));
       }
     }
 
@@ skipping 14 matching lines @@
         emitter.elementDescriptors[fragment].remove(classElement);
     if (classProperties != null) {
       statics.addAll(classProperties.properties);
     }
 
     if (!statics.isEmpty) {
       classBuilder.addProperty('static', new jsAst.ObjectInitializer(statics));
     }
 
     // TODO(ahe): This method (generateClass) should return a jsAst.Expression.
-    jsAst.ObjectInitializer propertyValue = classBuilder.toObjectInitializer();
+    jsAst.ObjectInitializer propertyValue =
+        classBuilder.toObjectInitializer();
     compiler.dumpInfoTask.registerElementAst(classBuilder.element, propertyValue);
     enclosingBuilder.addProperty(className, propertyValue);
 
     String reflectionName = emitter.getReflectionName(classElement, className);
     if (reflectionName != null) {
       if (!backend.isAccessibleByReflection(classElement)) {
         enclosingBuilder.addProperty("+$reflectionName", js.number(0));
       } else {
-        List<int> types = <int>[];
+        List<jsAst.Expression> types = <jsAst.Expression>[];
         if (classElement.supertype != null) {
           types.add(task.metadataCollector.reifyType(classElement.supertype));
         }
         for (DartType interface in classElement.interfaces) {
           types.add(task.metadataCollector.reifyType(interface));
         }
-        enclosingBuilder.addProperty("+$reflectionName", js.numArray(types));
+        enclosingBuilder.addProperty("+$reflectionName",
+            new jsAst.ArrayInitializer(types));
       }
     }
   }
 
   /**
    * Invokes [f] for each of the fields of [element].
    *
    * [element] must be a [ClassElement] or a [LibraryElement].
    *
    * If [element] is a [ClassElement], the static fields of the class are
@@ skipping 195 matching lines @@
         ? new Selector.getter(member.name, member.library)
         : new Selector.setter(member.name, member.library);
     String reflectionName = emitter.getReflectionName(selector, name);
     if (reflectionName != null) {
       var reflectable =
           js(backend.isAccessibleByReflection(member) ? '1' : '0');
       builder.addProperty('+$reflectionName', reflectable);
     }
   }
 }