Typing fixes to eliminate casts/dcalls

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 240 matching lines @@
  *
  * To allow calling [operator[]], [remove] or [containsKey] with objects
  * that are not supported by the `compare` function, an extra `isValidKey`
  * predicate function can be supplied. This function is tested before
  * using the `compare` function on an argument value that may not be a [K]
  * value. If omitted, the `isValidKey` function defaults to testing if the
  * value is a [K].
  */
 class SplayTreeMap<K, V> extends _SplayTree<K> implements Map<K, V> {
   Comparator<K> _comparator;
-  _Predicate _validKey;
+  _Predicate<Object> _validKey;
 
-  SplayTreeMap([int compare(K key1, K key2), bool isValidKey(potentialKey)])
+  SplayTreeMap([int compare(K key1, K key2),
+                bool isValidKey(Object potentialKey)])
       : _comparator = (compare == null) ? Comparable.compare : compare,
         _validKey = (isValidKey != null) ? 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)]) {
+                             bool isValidKey(Object potentialKey)]) {
     SplayTreeMap<K, V> result = new SplayTreeMap<K, V>();
     other.forEach((k, v) { result[k] = v; });
     return result;
   }
 
   /**
    * Creates a [SplayTreeMap] where the keys and values are computed from the
    * [iterable].
    *
    * For each element of the [iterable] this constructor computes a key/value
    * pair, by applying [key] and [value] respectively.
    *
    * The keys of the key/value pairs do not need to be unique. The last
    * occurrence of a key will simply overwrite any previous value.
    *
    * If no functions are specified for [key] and [value] the default is to
    * use the iterable value itself.
    */
   factory SplayTreeMap.fromIterable(Iterable iterable,
                                     {K key(element),
                                      V value(element),
                                      int compare(K key1, K key2),
-                                     bool isValidKey(potentialKey) }) {
+                                     bool isValidKey(Object potentialKey) }) {
     SplayTreeMap<K, V> map = new SplayTreeMap<K, V>(compare, isValidKey);
     Maps._fillMapWithMappedIterable(map, iterable, key, value);
     return map;
   }
 
   /**
    * Creates a [SplayTreeMap] associating the given [keys] to [values].
    *
    * This constructor iterates over [keys] and [values] and maps each element of
    * [keys] to the corresponding element of [values].
    *
    * If [keys] contains the same object multiple times, the last occurrence
    * overwrites the previous value.
    *
    * It is an error if the two [Iterable]s don't have the same length.
    */
   factory SplayTreeMap.fromIterables(Iterable<K> keys, Iterable<V> values,
-      [int compare(K key1, K key2), bool isValidKey(potentialKey)]) {
+      [int compare(K key1, K key2), bool isValidKey(Object potentialKey)]) {
     SplayTreeMap<K, V> map = new SplayTreeMap<K, V>(compare, isValidKey);
     Maps._fillMapWithIterables(map, keys, values);
     return map;
   }
 
   int _compare(K key1, K key2) => _comparator(key1, key2);
 
   SplayTreeMap._internal();
 
   V operator [](Object key) {
@@ skipping 327 matching lines @@
  * the constructor, both for ordering and for equality.
  * If the set contains only an object `a`, then `set.contains(b)`
  * will return `true` if and only if `compare(a, b) == 0`,
  * and the value of `a == b` is not even checked.
  * If the compare function is omitted, the objects are assumed to be
  * [Comparable], and are compared using their [Comparable.compareTo] method.
  * Non-comparable objects (including `null`) will not work as an element
  * in that case.
  */
 class SplayTreeSet<E> extends _SplayTree<E> with IterableMixin<E>, SetMixin<E> {
-  Comparator _comparator;
-  _Predicate _validKey;
+  Comparator<E> _comparator;
+  _Predicate<Object> _validKey;
 
   /**
    * Create a new [SplayTreeSet] with the given compare function.
    *
    * If the [compare] function is omitted, it defaults to [Comparable.compare],
    * and the elements must be comparable.
    *
    * A provided `compare` function may not work on all objects. It may not even
    * work on all `E` instances.
    *
    * For operations that add elements to the set, the user is supposed to not
    * pass in objects that doesn't work with the compare function.
    *
    * The methods [contains], [remove], [lookup], [removeAll] or [retainAll]
    * are typed to accept any object(s), and the [isValidKey] test can used to
    * filter those objects before handing them to the `compare` function.
    *
    * 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)])
+  SplayTreeSet([int compare(E key1, E key2),
+                bool isValidKey(Object potentialKey)])
       : _comparator = (compare == null) ? Comparable.compare : compare,
         _validKey = (isValidKey != null) ? 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,
                             [int compare(E key1, E key2),
-                             bool isValidKey(potentialKey)]) {
+                             bool isValidKey(Object potentialKey)]) {
     SplayTreeSet<E> result = new SplayTreeSet<E>(compare, isValidKey);
     for (final E element in elements) {
       result.add(element);
     }
     return result;
   }
 
   int _compare(E e1, E e2) => _comparator(e1, e2);
 
   // From Iterable.
@@ skipping 113 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, '{', '}');
 }