Recognize identical() ConstantValues as equal.

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 '../common.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart'
@@ skipping 371 matching lines @@
         this.hashCode = value.slowToString().hashCode;
 
   StringConstantValue.fromString(String value)
       : this(new DartString.literal(value));
 
   bool get isString => true;
 
   DartType getType(CoreTypes types) => types.stringType;
 
   bool operator ==(var other) {
+    if (identical(this, other)) return true;
     if (other is !StringConstantValue) return false;
     StringConstantValue otherString = other;
     return hashCode == otherString.hashCode &&
            primitiveValue == otherString.primitiveValue;
   }
 
   DartString toDartString() => primitiveValue;
 
   int get length => primitiveValue.length;
 
@@ skipping 52 matching lines @@
   final int hashCode;
 
   ListConstantValue(InterfaceType type, List<ConstantValue> entries)
       : this.entries = entries,
         hashCode = Hashing.listHash(entries, Hashing.objectHash(type)),
         super(type);
 
   bool get isList => true;
 
   bool operator ==(var other) {
+    if (identical(this, other)) return true;
     if (other is !ListConstantValue) return false;
     ListConstantValue otherList = other;
     if (hashCode != otherList.hashCode) return false;
     if (type != otherList.type) return false;
     if (entries.length != otherList.entries.length) return false;
     for (int i = 0; i < entries.length; i++) {
       if (entries[i] != otherList.entries[i]) return false;
     }
     return true;
   }
@@ skipping 44 matching lines @@
         this.hashCode = Hashing.listHash(values,
                             Hashing.listHash(keys,
                                 Hashing.objectHash(type))),
         super(type) {
     assert(keys.length == values.length);
   }
 
   bool get isMap => true;
 
   bool operator ==(var other) {
+    if (identical(this, other)) return true;
     if (other is !MapConstantValue) return false;
     MapConstantValue otherMap = other;
     if (hashCode != otherMap.hashCode) return false;
     if (type != other.type) return false;
     if (length != other.length) return false;
     for (int i = 0; i < length; i++) {
       if (keys[i] != otherMap.keys[i]) return false;
       if (values[i] != otherMap.values[i]) return false;
     }
     return true;
@@ skipping 116 matching lines @@
     : this.fields = fields,
       hashCode = Hashing.mapHash(fields, Hashing.objectHash(type)),
       super(type) {
     assert(type != null);
     assert(!fields.containsValue(null));
   }
 
   bool get isConstructedObject => true;
 
   bool operator ==(var otherVar) {
+    if (identical(this, otherVar)) return true;
     if (otherVar is !ConstructedConstantValue) return false;
     ConstructedConstantValue other = otherVar;
     if (hashCode != other.hashCode) return false;
     if (type != other.type) return false;
     if (fields.length != other.fields.length) return false;
     for (FieldElement field in fields.keys) {
       if (fields[field] != other.fields[field]) return false;
     }
     return true;
   }
@@ skipping 84 matching lines @@
 
   @override
   DartType getType(CoreTypes types) => const DynamicType();
 
   @override
   String toStructuredString() => 'NonConstant';
 
   @override
   String unparse() => '>>non-constant<<';
 }