Allow Object when doing lookups.

pkg/serialization/lib/src/serialization_helpers.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.
 
 /**
  * This contains extra functions and classes useful for implementing
  * serialiation. Some or all of these will be removed once the functionality is
  * available in the core library.
  */
 library serialization_helpers;
@@ skipping 172 matching lines @@
  * This provides an identity map which also allows true, false, and null
  * as valid keys. In the interests of avoiding duplicating map code, and
  * because hashCode for arbitrary objects is currently very slow on the VM,
  * just do a linear lookup.
  */
 class IdentityMap<K, V> implements Map<K, V> {
 
   final List<K> keys = <K>[];
   final List<V> values = <V>[];
 
-  V operator [](K key) {
+  V operator [](Object key) {
     var index =  _indexOf(key);
     return (index == -1) ? null : values[index];
   }
 
   void operator []=(K key, V value) {
     var index = _indexOf(key);
     if (index == -1) {
       keys.add(key);
       values.add(value);
     } else {
       values[index] = value;
     }
   }
 
   V putIfAbsent(K key, Function ifAbsent) {
     var index = _indexOf(key);
     if (index == -1) {
       keys.add(key);
       values.add(ifAbsent());
       return values.last;
     } else {
       return values[index];
     }
   }
 
-  int _indexOf(K key) {
+  int _indexOf(Object key) {
     // Go backwards on the guess that we are most likely to access the most
     // recently added.
     // Make strings and primitives unique
     var compareEquality = isPrimitive(key);
     for (var i = keys.length - 1; i >= 0; i--) {
       var equal = compareEquality ? key == keys[i] : identical(key, keys[i]);
       if (equal) return i;
     }
     return -1;
   }
 
-  bool containsKey(K key) => _indexOf(key) != -1;
+  bool containsKey(Object key) => _indexOf(key) != -1;
   void forEach(f(K key, V value)) {
     for (var i = 0; i < keys.length; i++) {
       f(keys[i], values[i]);
     }
   }
 
-  V remove(K key) {
+  V remove(Object key) {
     var index = _indexOf(key);
     if (index == -1) return null;
     keys.removeAt(index);
     return values.removeAt(index);
   }
 
   int get length => keys.length;
   void clear() {
     keys.clear();
     values.clear();
   }
   bool get isEmpty => keys.isEmpty;
   bool get isNotEmpty => !isEmpty;
 
   // Note that this is doing an equality comparison.
-  bool containsValue(x) => values.contains(x);
+  bool containsValue(Object x) => values.contains(x);
 
   void addAll(Map<K, V> other) {
     other.forEach((K key, V value) {
       this[key] = value;
     });
   }
 }