dart2js: Use frequency of occurence to sort metadata indices.

pkg/compiler/lib/src/js_emitter/model.dart

 // Copyright (c) 2014, 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.
 
 library dart2js.new_js_emitter.model;
 
 import '../js/js.dart' as js show Expression, Statement;
 import '../constants/values.dart' show ConstantValue;
 
 import '../deferred_load.dart' show OutputUnit;
@@ skipping 35 matching lines @@
   /// A list of metadata expressions.
   ///
   /// This list must be emitted in the `METADATA` embedded global.
   /// The list references constants and must hence be emitted after constants
   /// have been initialized.
   ///
   /// Note: the metadata is derived from the task's `metadataCollector`. The
   /// list must not be emitted before all operations on it are done. For
   /// example, the old emitter generates metadata when emitting reflection
   /// data.
-  List<js.Expression> get metadata => _metadataCollector.globalMetadata;
+  js.Expression get metadata => _metadataCollector.globalMetadata;
 
-  /// A map with lists of type expressions.
+  /// Getter for the list of metadata entries for a given [OutputUnit].

[karlklose, 2015/05/28 09:39:53]

Is is not a getter...

[herhut, 2015/06/01 12:09:42]

Done.

   ///
   /// There is one list for each output unit. The list belonging to the main
   /// unit must be emitted in the `TYPES` embedded global. The list references
   /// constants and must hence be emitted after constants have been initialized.
   ///
   /// Note: the metadata is derived from the task's `metadataCollector`. The
-  /// list must not be emitted before all operations on it are done. For
-  /// example, the old emitter generates metadata when emitting reflection
-  /// data.
-  Map<OutputUnit, List<js.Expression>> get metadataTypes
-      => _metadataCollector.types;
+  /// list is only a placeholder and will be filled in once metadata collection
+  /// is finalized.
+  js.Expression metadataTypesForOutputUnit(OutputUnit unit)
+      => _metadataCollector.getTypesForOutputUnit(unit);

[karlklose, 2015/05/28 09:39:53]

Use {} and return when it does not fit on one line.

[herhut, 2015/06/01 12:09:42]

Agree, I inherited this.

 
 
   bool get isSplit => fragments.length > 1;
   Iterable<Fragment> get deferredFragments => fragments.skip(1);
   Fragment get mainFragment => fragments.first;
 }
 
 /**
  * This class represents a JavaScript object that contains static state, like
  * classes or functions.
@@ skipping 149 matching lines @@
 
   /// noSuchMethod stubs in the special case that the class is Object.
   final List<StubMethod> noSuchMethodStubs;
   final List<Field> staticFieldsForReflection;
   final bool onlyForRti;
   final bool isDirectlyInstantiated;
   final bool isNative;
 
   // If the class implements a function type, and the type is encoded in the
   // metatada table, then this field contains the index into that field.
-  final int functionTypeIndex;
+  final js.Expression functionTypeIndex;

[sra1, 2015/05/27 19:38:51]

Could this be js.TokenNumber ?

[herhut, 2015/06/01 12:09:42]

I don't want to expose the fact that the result is a special thing outside of
the MetadataCollector. This code is not supposed to do anything with it.

 
   /// Whether the class must be evaluated eagerly.
   bool isEager = false;
 
   /// Data that must be emitted with the class for native interop.
   String nativeInfo;
 
   Class(this.element, this.name, this.holder,
         this.methods,
         this.fields,
@@ skipping 26 matching lines @@
 
 class MixinApplication extends Class {
   Class _mixinClass;
 
   MixinApplication(Element element, String name, Holder holder,
                    List<Field> instanceFields,
                    List<Field> staticFieldsForReflection,
                    List<StubMethod> callStubs,
                    List<StubMethod> typeVariableReaderStubs,
                    List<StubMethod> isChecks,
-                   int functionTypeIndex,
+                   js.Expression functionTypeIndex,
                    {bool onlyForRti,
                     bool isDirectlyInstantiated})
       : super(element,
               name, holder,
               const <Method>[],
               instanceFields,
               staticFieldsForReflection,
               callStubs,
               typeVariableReaderStubs,
               const <StubMethod>[],
@@ skipping 184 matching lines @@
               requiredParameterCount: requiredParameterCount,
               optionalParameterDefaultValues: optionalParameterDefaultValues,
               functionType: functionType);
 }
 
 class StaticStubMethod extends StubMethod implements StaticMethod {
   Holder holder;
   StaticStubMethod(String name, this.holder, js.Expression code)
       : super(name, code);
 }