Make the analyzer happy about collections.

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;
 
 /**
  * A node in a splay tree. It holds the sorting key and the left
  * and right children in the tree.
  */
@@ skipping 68 matching lines @@
 
     // The right child of the dummy node will hold
     // the L tree of the algorithm.  The left child of the dummy node
     // will hold the R tree of the algorithm.  Using a dummy node, left
     // and right will always be nodes and we avoid special cases.
     _SplayTreeNode<K> left = _dummy;
     _SplayTreeNode<K> right = _dummy;
     _SplayTreeNode<K> current = _root;
     int comp;
     while (true) {
-      comp = current.key.compareTo(key);
+      comp = _compare(current.key, key);
       if (comp > 0) {
         if (current.left == null) break;
-        comp = current.left.key.compareTo(key);
+        comp = _compare(current.left.key, key);
         if (comp > 0) {
           // Rotate right.
           _SplayTreeNode<K> tmp = current.left;
           current.left = tmp.right;
           tmp.right = current;
           current = tmp;
           if (current.left == null) break;
         }
         // Link right.
         right.left = current;
         right = current;
         current = current.left;
       } else if (comp < 0) {
         if (current.right == null) break;
-        comp = current.right.key.compareTo(key);
+        comp = _compare(current.right.key, key);
         if (comp < 0) {
           // Rotate left.
           _SplayTreeNode<K> tmp = current.right;
           current.right = tmp.left;
           tmp.left = current;
           current = tmp;
           if (current.right == null) break;
         }
         // Link left.
         left.right = current;
@@ skipping 131 matching lines @@
       : _comparator = (compare == null) ? Comparable.compare : compare;
 
   int _compare(K key1, K key2) => _comparator(key1, key2);
 
   SplayTreeMap._internal();
 
   V operator [](K key) {
     if (key == null) throw new ArgumentError(key);
     if (_root != null) {
       int comp = _splay(key);
-      if (comp == 0) return _root.value;
+      if (comp == 0) {
+        _SplayTreeMapNode mapRoot = _root;
+        return mapRoot.value;
+      }
     }
     return null;
   }
 
   V remove(Object key) {
     if (key is! K) return null;
-    _SplayTreeMapNode root = _remove(key);
-    if (root != null) return root.value;
+    _SplayTreeMapNode mapRoot = _remove(key);
+    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) {
-      _root.value = value;
+      _SplayTreeMapNode mapRoot = _root;
+      mapRoot.value = value;
       return;
     }
     _addNewRoot(new _SplayTreeMapNode(key, value), comp);
   }
 
 
   V putIfAbsent(K key, V ifAbsent()) {
     if (key == null) throw new ArgumentError(key);
     int comp = _splay(key);
-    if (comp == 0) return _root.value;
+    if (comp == 0) {
+      _SplayTreeMapNode mapRoot = _root;
+      return mapRoot.value;
+    }
     int modificationCount = _modificationCount;
     int splayCount = _splayCount;
     V value = ifAbsent();
     if (modificationCount != _modificationCount) {
       throw new ConcurrentModificationError(this);
     }
     if (splayCount != _splayCount) {
       comp = _splay(key);
       // Key is still not there, otherwise _modificationCount would be changed.
       assert(comp != 0);
@@ skipping 25 matching lines @@
     _clear();
   }
 
   bool containsKey(K key) {
     return _splay(key) == 0;
   }
 
   bool containsValue(V value) {
     bool found = false;
     int initialSplayCount = _splayCount;
-    bool visit(_SplayTreeNode node) {
+    bool visit(_SplayTreeMapNode node) {
       while (node != null) {
         if (node.value == value) return true;
         if (initialSplayCount != _splayCount) {
           throw new ConcurrentModificationError(this);
         }
         if (node.right != null && visit(node.right)) return true;
         node = node.left;
       }
       return false;
     }
@@ skipping 178 matching lines @@
 class _SplayTreeValueIterator<K, V> extends _SplayTreeIterator<V> {
   _SplayTreeValueIterator(SplayTreeMap<K, V> map): super(map);
   V _getValue(_SplayTreeMapNode node) => node.value;
 }
 
 class _SplayTreeNodeIterator<K>
     extends _SplayTreeIterator<_SplayTreeNode<K>> {
   _SplayTreeNodeIterator(_SplayTree<K> map): super(map);
   _SplayTreeNode<K> _getValue(_SplayTreeNode node) => node;
 }