SDK fixes

test/generated_sdk/lib/collection/splay_tree.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 dart.collection;
 
 typedef bool _Predicate<T>(T value);
 
 /**
  * A node in a splay tree. It holds the sorting key and the left
@@ skipping 215 matching lines @@
     return _root;
   }
 
   void _clear() {
     _root = null;
     _count = 0;
     _modificationCount++;
   }
 }
 
-class _TypeTest<T> {
-  bool test(v) => v is T;
-}
-
 /**
  * A [Map] of objects that can be ordered relative to each other.
  *
  * The map is based on a self-balancing binary tree. It allows most operations
  * in amortized logarithmic time.
  *
  * Keys of the map are compared using the `compare` function passed in
  * the constructor, both for ordering and for equality.
  * If the map contains only the key `a`, then `map.containsKey(b)`
  * will return `true` if and only if `compare(a, b) == 0`,
@@ skipping 339 matching lines @@
       return false;
     }
     if (_tree._splayCount != _splayCount && _currentNode != null) {
       _rebuildWorkList(_currentNode);
     }
     _currentNode = _workList.removeLast();
     _findLeftMostDescendent(_currentNode.right);
     return true;
   }
 
-  T _getValue(_SplayTreeNode node);
+  T _getValue(_SplayTreeMapNode node);
 }
 
 class _SplayTreeKeyIterable<K> extends IterableBase<K>
                               implements EfficientLength {
   _SplayTree<K> _tree;
   _SplayTreeKeyIterable(this._tree);
   int get length => _tree._count;
   bool get isEmpty => _tree._count == 0;
   Iterator<K> get iterator => new _SplayTreeKeyIterator<K>(_tree);
 
@@ skipping 178 matching lines @@
     }
   }
 
   E lookup(Object object) {
     if (!_validKey(object)) return null;
     int comp = _splay(object);
     if (comp != 0) return null;
     return _root.key;
   }
 
-  Set<E> intersection(Set<E> other) {
+  Set<E> intersection(Set<Object> other) {
     Set<E> result = new SplayTreeSet<E>(_comparator, _validKey);
     for (E element in this) {
       if (other.contains(element)) result.add(element);
     }
     return result;
   }
 
-  Set<E> difference(Set<E> other) {
+  Set<E> difference(Set<Object> other) {
     Set<E> result = new SplayTreeSet<E>(_comparator, _validKey);
     for (E element in this) {
       if (!other.contains(element)) result.add(element);
     }
     return result;
   }
 
   Set<E> union(Set<E> other) {
     return _clone()..addAll(other);
   }
@@ skipping 12 matching lines @@
     return new _SplayTreeNode<E>(node.key)..left = _copyNode(node.left)
                                           ..right = _copyNode(node.right);
   }
 
   void clear() { _clear(); }
 
   Set<E> toSet() => _clone();
 
   String toString() => IterableBase.iterableToFullString(this, '{', '}');
 }