Use elements/types in constants/values

pkg/compiler/lib/src/js_emitter/constant_ordering.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.js_emitter.constant_ordering;
 
 import '../constants/values.dart';
 import '../elements/elements.dart' show Entity, Elements;
 import '../elements/entities.dart' show FieldEntity;
 import '../elements/resolution_types.dart';
@@ skipping 33 matching lines @@
     }
     return 0;
   }
 
   static int compareElements(Entity a, Entity b) {
     int r = a.name.compareTo(b.name);
     if (r != 0) return r;
     return Elements.compareByPosition(a, b);
   }
 
   static int compareDartTypes(ResolutionDartType a, ResolutionDartType b) {

[Siggi Cherem (dart-lang), 2017/01/11 22:57:47]

this looks like a nice candidate to do next :)

[Johnni Winther, 2017/01/12 11:17:45]

Acknowledged.

     if (a == b) return 0;
     int r = a.kind.index.compareTo(b.kind.index);
     if (r != 0) return r;
     r = compareNullable(compareElements, a.element, b.element);
     if (r != 0) return r;
 
     if (a is GenericType) {
       GenericType aGeneric = a;
       GenericType bGeneric = b;
       r = compareLists(
@@ skipping 33 matching lines @@
     DartString aString = a.primitiveValue;
     DartString bString = b.primitiveValue;
     int r = aString.length.compareTo(bString.length);
     if (r != 0) return r;
     return aString.slowToString().compareTo(bString.slowToString());
   }
 
   int visitList(ListConstantValue a, ListConstantValue b) {
     int r = compareLists(compareValues, a.entries, b.entries);
     if (r != 0) return r;
-    return compareDartTypes(a.type, b.type);
+    ResolutionInterfaceType type1 = a.type;
+    ResolutionInterfaceType type2 = b.type;
+    return compareDartTypes(type1, type2);
   }
 
   int visitMap(MapConstantValue a, MapConstantValue b) {
     int r = compareLists(compareValues, a.keys, b.keys);
     if (r != 0) return r;
     r = compareLists(compareValues, a.values, b.values);
     if (r != 0) return r;
-    return compareDartTypes(a.type, b.type);
+    ResolutionInterfaceType type1 = a.type;
+    ResolutionInterfaceType type2 = b.type;
+    return compareDartTypes(type1, type2);
   }
 
   int visitConstructed(ConstructedConstantValue a, ConstructedConstantValue b) {
-    int r = compareDartTypes(a.type, b.type);
+    ResolutionInterfaceType type1 = a.type;
+    ResolutionInterfaceType type2 = b.type;
+    int r = compareDartTypes(type1, type2);
     if (r != 0) return r;
 
     List<FieldEntity> aFields = a.fields.keys.toList()..sort(compareElements);
     List<FieldEntity> bFields = b.fields.keys.toList()..sort(compareElements);
 
     r = compareLists(compareElements, aFields, bFields);
     if (r != 0) return r;
 
     return compareLists(
         compareValues,
         aFields.map((field) => a.fields[field]).toList(),
         aFields.map((field) => b.fields[field]).toList());
   }
 
   int visitType(TypeConstantValue a, TypeConstantValue b) {
     int r = compareDartTypes(a.representedType, b.representedType);
     if (r != 0) return r;
-    return compareDartTypes(a.type, b.type);
+    ResolutionInterfaceType type1 = a.type;
+    ResolutionInterfaceType type2 = b.type;
+    return compareDartTypes(type1, type2);
   }
 
   int visitInterceptor(InterceptorConstantValue a, InterceptorConstantValue b) {
-    return compareDartTypes(a.dispatchedType, b.dispatchedType);
+    return compareElements(a.cls, b.cls);
   }
 
   int visitSynthetic(SyntheticConstantValue a, SyntheticConstantValue b) {
     // [SyntheticConstantValue]s have abstract fields that are set only by
     // convention.  Lucky for us, they do not occur as top level constant, only
     // as elements of a few constants.  If this becomes a source of instability,
     // we will need to add a total ordering on JavaScript ASTs including
     // deferred elements.
     SyntheticConstantKind aKind = a.valueKind;
     SyntheticConstantKind bKind = b.valueKind;
@@ skipping 53 matching lines @@
   int visitBool(BoolConstantValue a, _) => BOOL;
   int visitString(StringConstantValue a, _) => STRING;
   int visitList(ListConstantValue a, _) => LIST;
   int visitMap(MapConstantValue a, _) => MAP;
   int visitConstructed(ConstructedConstantValue a, _) => CONSTRUCTED;
   int visitType(TypeConstantValue a, _) => TYPE;
   int visitInterceptor(InterceptorConstantValue a, _) => INTERCEPTOR;
   int visitSynthetic(SyntheticConstantValue a, _) => SYNTHETIC;
   int visitDeferred(DeferredConstantValue a, _) => DEFERRED;
 }