Adjust types in SplayTree implementation and some strong tests to

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 226 matching lines @@
     _root = null;
     _count = 0;
     _modificationCount++;
   }
 }
 
 class _TypeTest<T> {
   bool test(v) => v is T;
 }
 
+int _dynamicCompare(dynamic a, dynamic b) => Comparable.compare(a, b);
+
+Comparator<K> _defaultCompare<K>() {
+  // If K <: Comparable, then we can just use Comparable.compare
+  // with no casts.
+  Object compare = Comparable.compare;
+  if (compare is Comparator<K>) {
+    return compare;
+  }
+  // Otherwise wrap and cast the arguments on each call.
+  return _dynamicCompare;
+}
+
 /**
  * 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 13 matching lines @@
 class SplayTreeMap<K, V> extends _SplayTree<K, _SplayTreeMapNode<K, V>>
     implements Map<K, V> {
   _SplayTreeMapNode<K, V> _root;
   final _SplayTreeMapNode<K, V> _dummy =
       new _SplayTreeMapNode<K, V>(null, null);
 
   Comparator<K> _comparator;
   _Predicate _validKey;
 
   SplayTreeMap([int compare(K key1, K key2), bool isValidKey(potentialKey)])
-      : _comparator = compare ?? Comparable.compare as Comparator<K>,
+      : _comparator = compare ?? _defaultCompare<K>(),
         _validKey = isValidKey ?? ((v) => v is K);
 
   /**
    * Creates a [SplayTreeMap] that contains all key/value pairs of [other].
    */
   factory SplayTreeMap.from(Map other,
       [int compare(K key1, K key2), bool isValidKey(potentialKey)]) {
     SplayTreeMap<K, V> result = new SplayTreeMap<K, V>(compare, isValidKey);
     other.forEach((k, v) {
       result[k as Object/*=K*/] = v as Object/*=V*/;
@@ skipping 407 matching lines @@
    *
    * If [isValidKey] is provided, only values satisfying `isValidKey(other)`
    * are compared using the `compare` method in the methods mentioned above.
    * If the `isValidKey` function returns false for an object, it is assumed to
    * not be in the set.
    *
    * If omitted, the `isValidKey` function defaults to checking against the
    * type parameter: `other is E`.
    */
   SplayTreeSet([int compare(E key1, E key2), bool isValidKey(potentialKey)])
-      : _comparator =
-            compare ?? Comparable.compare as dynamic/*=Comparator<E>*/,
+      : _comparator = compare ?? _defaultCompare<E>(),
         _validKey = isValidKey ?? ((v) => v is E);
 
   /**
    * Creates a [SplayTreeSet] that contains all [elements].
    *
    * The set works as if created by `new SplayTreeSet<E>(compare, isValidKey)`.
    *
    * All the [elements] should be valid as arguments to the [compare] function.
    */
   factory SplayTreeSet.from(Iterable elements,
@@ skipping 130 matching lines @@
   }
 
   void clear() {
     _clear();
   }
 
   Set<E> toSet() => _clone();
 
   String toString() => IterableBase.iterableToFullString(this, '{', '}');
 }