dart2js: Use frequency of occurence to sort metadata indices.

pkg/compiler/lib/src/constants/values.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.
 
 library dart2js.constants.values;
 
 import '../core_types.dart';
 import '../dart_types.dart';
 import '../dart2jslib.dart'
     show assertDebugMode;
@@ skipping 585 matching lines @@
 
   String unparse() {
     return 'interceptor($dispatchedType)';
   }
 
   String toStructuredString() {
     return 'InterceptorConstant(${dispatchedType.getStringAsDeclared("o")})';
   }
 }
 
-// TODO(johnniwinther): Remove this class.
 class DummyConstantValue extends ConstantValue {

[Johnni Winther, 2015/05/28 12:07:17]

Rename to SyntheticConstantValue, ForeignConstantValue or BackendConstantValue,
or ...

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

I went for SyntheticConstantValue.

-  final ti.TypeMask typeMask;
+  final payload;

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

TL;DR: should this class be split into 2 to 3 classes?

The original dummy constant was only copied (e.g. passed as an argument to an
unused parameter).  It did not matter at all what the textual JS representation
was.

If there is a different kind of 'constant' that actually flows to a nontrivial
use I think it should be a different kind of ConstantValue.  When 'payload' is
an expression, what how is that expression used at runtime?

I see that some uses of payload are js.Expression and some are TypeMask.  Are
there other uses?

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

The idea is that these constants are opaque to the constant system and only the
specific system that uses them, e.g. the JavaScript backend, knows which exist
and what they are. 

Currently we have
  DUMMY_INTERCEPTOR
  EMPTY_VALUE
  TYPEVARIABLE_REFERENCE

Only the last is new, the other two existed before.

+  final String kind;
 
-  DummyConstantValue(this.typeMask);
+  DummyConstantValue(this.kind, this.payload);
 
   bool get isDummy => true;
 
   bool operator ==(other) {
     return other is DummyConstantValue
-        && typeMask == other.typeMask;
+        && payload == other.payload;
   }
 
-  get hashCode => typeMask.hashCode;
+  get hashCode => payload.hashCode;
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitDummy(this, arg);
 
   DartType getType(CoreTypes types) => const DynamicType();
 
-  String unparse() => 'dummy($typeMask)';
+  String unparse() => 'dummy($kind, $payload)';
 
-  String toStructuredString() => 'DummyConstant($typeMask)';
+  String toStructuredString() => 'DummyConstant($kind, $payload)';
 }
 
 class ConstructedConstantValue extends ObjectConstantValue {
   final Map<FieldElement, ConstantValue> fields;
   final int hashCode;
 
   ConstructedConstantValue(InterfaceType type,
                            Map<FieldElement, ConstantValue> fields)
     : this.fields = fields,
       hashCode = Hashing.mapHash(fields, Hashing.objectHash(type)),
@@ skipping 101 matching lines @@
 
   @override
   DartType getType(CoreTypes types) => const DynamicType();
 
   @override
   String toStructuredString() => 'NonConstant';
 
   @override
   String unparse() => '>>non-constant<<';
 }