Add type arguments to constants.

sdk/lib/_internal/compiler/implementation/constants.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.
 
 part of dart2js;
 
 abstract class ConstantVisitor<R> {
   R visitSentinel(SentinelConstant constant);
   R visitFunction(FunctionConstant constant);
   R visitNull(NullConstant constant);
@@ skipping 328 matching lines @@
 
   accept(ConstantVisitor visitor) => visitor.visitType(this);
 }
 
 class ListConstant extends ObjectConstant {
   final List<Constant> entries;
   final int hashCode;
 
   ListConstant(DartType type, List<Constant> entries)
       : this.entries = entries,
-        hashCode = _computeHash(entries),
+        hashCode = _computeHash(type, entries),
         super(type);
   bool isList() => true;
 
-  static int _computeHash(List<Constant> entries) {
+  static int _computeHash(DartType type, List<Constant> entries) {
     // TODO(floitsch): create a better hash.
-    int hash = 0;
-    for (Constant input in entries) hash ^= input.hashCode;
+    int hash = 7;
+    for (Constant input in entries) {
+      hash ^= input.hashCode;
+    }
+    hash ^= type.hashCode;
     return hash;
   }
 
   bool operator ==(var other) {
     if (other is !ListConstant) return false;
     ListConstant otherList = other;
     if (hashCode != otherList.hashCode) return false;
-    // TODO(floitsch): verify that the generic types are the same.
+    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;
   }
 
   List<Constant> getDependencies() => entries;
 
   int get length => entries.length;
@@ skipping 18 matching lines @@
   static const SourceString KEYS_NAME = const SourceString("_keys");
   static const SourceString PROTO_VALUE = const SourceString("_protoValue");
 
   final ListConstant keys;
   final List<Constant> values;
   final Constant protoValue;
   final int hashCode;
 
   MapConstant(DartType type, this.keys, List<Constant> values, this.protoValue)
       : this.values = values,
-        this.hashCode = computeHash(values),
+        this.hashCode = computeHash(type, values),
         super(type);
   bool isMap() => true;
 
-  static int computeHash(List<Constant> values) {
+  static int computeHash(DartType type, List<Constant> values) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
-    for (Constant value in values) hash ^= value.hashCode;
+    for (Constant value in values) {
+      hash ^= value.hashCode;
+    }
+    hash ^= type.hashCode;
     return hash;
   }
 
   bool operator ==(var other) {
     if (other is !MapConstant) return false;
     MapConstant otherMap = other;
     if (hashCode != otherMap.hashCode) return false;
-    // TODO(floitsch): verify that the generic types are the same.
+    if (type != other.type) return false;
     if (keys != otherMap.keys) return false;
     for (int i = 0; i < values.length; i++) {
       if (values[i] != otherMap.values[i]) return false;
     }
     return true;
   }
 
   List<Constant> getDependencies() {
     List<Constant> result = <Constant>[keys];
     result.addAll(values);
@@ skipping 39 matching lines @@
     assert(type != null);
   }
   bool isConstructedObject() => true;
 
   static int computeHash(DartType type, List<Constant> fields) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant field in fields) {
       hash ^= field.hashCode;
     }
-    hash ^= type.element.hashCode;
+    hash ^= type.hashCode;
     return hash;
   }
 
   bool operator ==(var otherVar) {
     if (otherVar is !ConstructedConstant) return false;
     ConstructedConstant other = otherVar;
     if (hashCode != other.hashCode) return false;
-    // TODO(floitsch): verify that the (generic) types are the same.
-    if (type.element != other.type.element) return false;
+    if (type != other.type) return false;
     if (fields.length != other.fields.length) return false;
     for (int i = 0; i < fields.length; i++) {
       if (fields[i] != other.fields[i]) return false;
     }
     return true;
   }
 
   List<Constant> getDependencies() => fields;
 
   accept(ConstantVisitor visitor) => visitor.visitConstructed(this);
 }