Update dart:collection.

tool/input_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 269 matching lines @@
       : _comparator = compare ?? Comparable.compare as Comparator<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 K] = v as V; });
+    other.forEach((k, v) { result[k as Object/*=K*/] = v as Object/*=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.
    *
@@ skipping 31 matching lines @@
     return map;
   }
 
   int _compare(K key1, K key2) => _comparator(key1, key2);
 
   SplayTreeMap._internal();
 
   V operator [](Object key) {
     if (!_validKey(key)) return null;
     if (_root != null) {
-      int comp = _splay(key as K);
+      int comp = _splay(key as dynamic/*=K*/);
       if (comp == 0) {
         return _root.value;
       }
     }
     return null;
   }
 
   V remove(Object key) {
     if (!_validKey(key)) return null;
-    _SplayTreeMapNode<K, V> mapRoot = _remove(key as K);
+    _SplayTreeMapNode<K, V> mapRoot = _remove(key as dynamic/*=K*/);
     if (mapRoot != null) return mapRoot.value;
     return null;
   }
 
   void operator []=(K key, V value) {
     if (key == null) throw new ArgumentError(key);
     // Splay on the key to move the last node on the search path for
     // the key to the root of the tree.
     int comp = _splay(key);
     if (comp == 0) {
@@ skipping 46 matching lines @@
 
   int get length {
     return _count;
   }
 
   void clear() {
     _clear();
   }
 
   bool containsKey(Object key) {
-    return _validKey(key) && _splay(key as K) == 0;
+    return _validKey(key) && _splay(key as dynamic/*=K*/) == 0;
   }
 
   bool containsValue(Object value) {
     bool found = false;
     int initialSplayCount = _splayCount;
     bool visit(_SplayTreeMapNode node) {
       while (node != null) {
         if (node.value == value) return true;
         if (initialSplayCount != _splayCount) {
           throw new ConcurrentModificationError(this);
@@ skipping 204 matching lines @@
 }
 
 class _SplayTreeKeyIterator<K> extends _SplayTreeIterator<K, K> {
   _SplayTreeKeyIterator(_SplayTree<K, _SplayTreeNode<K>> map): super(map);
   K _getValue(_SplayTreeNode<K> node) => node.key;
 }
 
 class _SplayTreeValueIterator<K, V> extends _SplayTreeIterator<K, V> {
   _SplayTreeValueIterator(SplayTreeMap<K, V> map): super(map);
   V _getValue(_SplayTreeNode<K> node) {
-    _SplayTreeMapNode<K, V> mapNode = node as _SplayTreeMapNode<K, V>;
+    _SplayTreeMapNode<K, V> mapNode =
+        node as dynamic/*=_SplayTreeMapNode<K, V>*/;
     return mapNode.value;
   }
 }
 
 class _SplayTreeNodeIterator<K>
     extends _SplayTreeIterator<K, _SplayTreeNode<K>> {
   _SplayTreeNodeIterator(_SplayTree<K, _SplayTreeNode<K>> tree): super(tree);
   _SplayTreeNodeIterator.startAt(
       _SplayTree<K, _SplayTreeNode<K>> tree, K startKey)
       : super.startAt(tree, startKey);
@@ skipping 43 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 Comparator<E>,
+      : _comparator =
+            compare ?? Comparable.compare as dynamic/*=Comparator<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,
                             [int compare(E key1, E key2),
                              bool isValidKey(potentialKey)]) {
     SplayTreeSet<E> result = new SplayTreeSet<E>(compare, isValidKey);
     for (final element in elements) {
-      result.add(element as E);
+      E e = element as Object/*=E*/;
+      result.add(e);
     }
     return result;
   }
 
   int _compare(E e1, E e2) => _comparator(e1, e2);
 
   // From Iterable.
 
   Iterator<E> get iterator => new _SplayTreeKeyIterator<E>(this);
 
@@ skipping 12 matching lines @@
   }
 
   E get single {
     if (_count == 0) throw IterableElementError.noElement();
     if (_count > 1) throw IterableElementError.tooMany();
     return _root.key;
   }
 
   // From Set.
   bool contains(Object object) {
-    return _validKey(object) && _splay(object as E) == 0;
+    return _validKey(object) && _splay(object as dynamic/*=E*/) == 0;
   }
 
   bool add(E element) {
     int compare = _splay(element);
     if (compare == 0) return false;
     _addNewRoot(new _SplayTreeNode(element), compare);
     return true;
   }
 
   bool remove(Object object) {
     if (!_validKey(object)) return false;
-    return _remove(object as E) != null;
+    return _remove(object as dynamic/*=E*/) != null;
   }
 
   void addAll(Iterable<E> elements) {
     for (E element in elements) {
       int compare = _splay(element);
       if (compare != 0) {
         _addNewRoot(new _SplayTreeNode(element), compare);
       }
     }
   }
 
   void removeAll(Iterable<Object> elements) {
     for (Object element in elements) {
-      if (_validKey(element)) _remove(element as E);
+      if (_validKey(element)) _remove(element as dynamic/*=E*/);
     }
   }
 
   void retainAll(Iterable<Object> elements) {
     // Build a set with the same sense of equality as this set.
     SplayTreeSet<E> retainSet = new SplayTreeSet<E>(_comparator, _validKey);
     int modificationCount = _modificationCount;
     for (Object object in elements) {
       if (modificationCount != _modificationCount) {
         // The iterator should not have side effects.
         throw new ConcurrentModificationError(this);
       }
       // Equivalent to this.contains(object).
-      if (_validKey(object) && _splay(object as E) == 0) {
+      if (_validKey(object) && _splay(object as dynamic/*=E*/) == 0) {
         retainSet.add(_root.key);
       }
     }
     // Take over the elements from the retained set, if it differs.
     if (retainSet._count != _count) {
       _root = retainSet._root;
       _count = retainSet._count;
       _modificationCount++;
     }
   }
 
   E lookup(Object object) {
     if (!_validKey(object)) return null;
-    int comp = _splay(object as E);
+    int comp = _splay(object as dynamic/*=E*/);
     if (comp != 0) return null;
     return _root.key;
   }
 
   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;
@@ skipping 25 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, '{', '}');
 }