SDK fixes

tool/input_sdk/lib/internal/list.dart

 // Copyright (c) 2013, 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 dart._internal;
 
 /**
  * Mixin that throws on the length changing operations of [List].
  *
  * Intended to mix-in on top of [ListMixin] for fixed-length lists.
@@ skipping 230 matching lines @@
     RangeError.checkValidIndex(index, this);
     return index;
   }
 }
 
 class ListMapView<E> implements Map<int, E> {
   List<E> _values;
 
   ListMapView(this._values);
 
-  E operator[] (int key) => containsKey(key) ? _values[key] : null;
+  E operator[] (Object key) => containsKey(key) ? _values[key] : null;

[vsm, 2015/05/04 21:09:21]

This is consistent with the Map.[] - but perhaps the cleaner solution is to
change that to take the Key type?  I guess this choice (Object vs the key or val
type) appears a few places though.

[Leaf, 2015/05/04 21:50:42]

Yes, I'd probably prefer that as well.  I was trying to minimize breaking API
changes though, with an eye towards potentially upstreaming some of these
changes.

A related one that came up as well was with inconsistent types for Set
intersection and difference (Set<K> vs Set<Object>).

   int get length => _values.length;
 
   Iterable<E> get values => new SubListIterable<E>(_values, 0, null);
   Iterable<int> get keys => new _ListIndicesIterable(_values);
 
   bool get isEmpty => _values.isEmpty;
   bool get isNotEmpty => _values.isNotEmpty;
   bool containsValue(Object value) => _values.contains(value);
-  bool containsKey(int key) => key is int && key >= 0 && key < length;
+  bool containsKey(Object key) => key is int && key >= 0 && key < length;
 
   void forEach(void f(int key, E value)) {
     int length = _values.length;
     for (int i = 0; i < length; i++) {
       f(i, _values[i]);
       if (length != _values.length) {
         throw new ConcurrentModificationError(_values);
       }
     }
   }
 
   /** This operation is not supported by an unmodifiable map. */
   void operator[]= (int key, E value) {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
 
   /** This operation is not supported by an unmodifiable map. */
   E putIfAbsent(int key, E ifAbsent()) {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
 
   /** This operation is not supported by an unmodifiable map. */
-  E remove(int key) {
+  E remove(Object key) {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
 
   /** This operation is not supported by an unmodifiable map. */
   void clear() {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
 
   /** This operation is not supported by an unmodifiable map. */
   void addAll(Map<int, E> other) {
@@ skipping 73 matching lines @@
  * or become empty or been otherwise modified.
  * It will still be a valid object, so references to it will not, e.g., crash
  * the runtime if accessed, but no promises are made wrt. its contents.
  *
  * This unspecified behavior is the reason the function is not exposed to
  * users. We allow the underlying implementation to make the most efficient
  * conversion, at the cost of leaving the original list in an unspecified
  * state.
  */
 external List makeListFixedLength(List growableList);