a === b -> identical(a, b)

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.
 
 /**
  * A node in a splay tree. It holds the key, the value and the left
  * and right children in the tree.
  */
 class SplayTreeNode<K, V> {
   SplayTreeNode(K this.key, V this.value);
@@ skipping 45 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, V> left = _dummy;
     SplayTreeNode<K, V> right = _dummy;
     SplayTreeNode<K, V> current = _root;
     while (true) {
       int comp = key.compareTo(current.key);
       if (comp < 0) {
-        if (current.left === null) break;
+        if (current.left == null) break;
         if (key.compareTo(current.left.key) < 0) {
           // Rotate right.
           SplayTreeNode<K, V> tmp = current.left;
           current.left = tmp.right;
           tmp.right = current;
           current = tmp;
-          if (current.left === null) break;
+          if (current.left == null) break;
         }
         // Link right.
         right.left = current;
         right = current;
         current = current.left;
       } else if (comp > 0) {
-        if (current.right === null) break;
+        if (current.right == null) break;
         if (key.compareTo(current.right.key) > 0) {
           // Rotate left.
           SplayTreeNode<K, V> tmp = current.right;
           current.right = tmp.left;
           tmp.left = current;
           current = tmp;
-          if (current.right === null) break;
+          if (current.right == null) break;
         }
         // Link left.
         left.right = current;
         left = current;
         current = current.right;
       } else {
         break;
       }
     }
     // Assemble.
@@ skipping 16 matching lines @@
   }
 
   V remove(K key) {
     if (isEmpty) return null;
     splay_(key);
     if (_root.key.compareTo(key) != 0) return null;
     V value = _root.value;
 
     _count--;
     // assert(_count >= 0);
-    if (_root.left === null) {
+    if (_root.left == null) {
       _root = _root.right;
     } else {
       SplayTreeNode<K, V> right = _root.right;
       _root = _root.left;
       // Splay to make sure that the new root has an empty right child.
       splay_(key);
       // Insert the original right child as the right child of the new
       // root.
       _root.right = right;
     }
@@ skipping 29 matching lines @@
   }
 
   V putIfAbsent(K key, V ifAbsent()) {
     if (containsKey(key)) return this[key];
     V value = ifAbsent();
     this[key] = value;
     return value;
   }
 
   bool get isEmpty {
-    // assert(!((_root === null) && (_count != 0)));
-    // assert(!((_count == 0) && (_root !== null)));
-    return (_root === null);
+    // assert(!((_root == null) && (_count != 0)));
+    // assert(!((_count == 0) && (_root != null)));
+    return (_root == null);
   }
 
   void forEach(void f(K key, V value)) {
     List<SplayTreeNode<K, V>> list = new List<SplayTreeNode<K, V>>();
     SplayTreeNode<K, V> current = _root;
-    while (current !== null) {
-      if (current.left !== null) {
+    while (current != null) {
+      if (current.left != null) {
         list.add(current);
         current = current.left;
       } else {
         f(current.key, current.value);
-        while (current.right === null) {
+        while (current.right == null) {
           if (list.isEmpty) return;
           current = list.removeLast();
           f(current.key, current.value);
         }
         current = current.right;
       }
     }
   }
 
   int get length {
     return _count;
   }
 
   void clear() {
     _root = null;
     _count = 0;
   }
 
   bool containsKey(K key) {
     if (!isEmpty) {
       splay_(key);
       if (_root.key.compareTo(key) == 0) return true;
     }
     return false;
   }
 
   bool containsValue(V value) {
     bool found = false;
     bool visit(SplayTreeNode node) {
-      if (node === null) return false;
+      if (node == null) return false;
       if (node.value == value) return true;
       return visit(node.left) || visit(node.right);
     }
     return visit(_root);
   }
 
   Collection<K> get keys {
     List<K> list = new List<K>();
     forEach((K k, V v) { list.add(k); });
     return list;
   }
 
   Collection<V> get values {
     List<V> list = new List<V>();
     forEach((K k, V v) { list.add(v); });
     return list;
   }
 
   String toString() {
     return Maps.mapToString(this);
   }
 
   /**
    * Get the first key in the map. Returns [null] if the map is empty.
    */
   K firstKey() {
-    if (_root === null) return null;
+    if (_root == null) return null;
     SplayTreeNode<K, V> node = _root;
-    while (node.left !== null) {
+    while (node.left != null) {
       node = node.left;
     }
     // Maybe implement a splay-method that can splay the minimum without
     // performing comparisons.
     splay_(node.key);
     return node.key;
   }
 
   /**
    * Get the last key in the map. Returns [null] if the map is empty.
    */
   K lastKey() {
-    if (_root === null) return null;
+    if (_root == null) return null;
     SplayTreeNode<K, V> node = _root;
-    while (node.right !== null) {
+    while (node.right != null) {
       node = node.right;
     }
     // Maybe implement a splay-method that can splay the maximum without
     // performing comparisons.
     splay_(node.key);
     return node.key;
   }
 
   /**
    * Get the last key in the map that is strictly smaller than [key]. Returns
    * [null] if no key was not found.
    */
   K lastKeyBefore(K key) {
     splay_(key);
     K visit(SplayTreeNode node, K ifEmpty) {
-      if (node === null) return ifEmpty;
+      if (node == null) return ifEmpty;
       if (node.key.compareTo(key) >= 0) {
         return visit(node.left, ifEmpty);
       }
       if (node.key.compareTo(key) < 0) {
         return visit(node.right, node.key);
       }
     }
     return visit(_root, null);
   }
 
   /**
    * Get the first key in the map that is strictly larger than [key]. Returns
    * [null] if no key was not found.
    */
   K firstKeyAfter(K key) {
     splay_(key);
     K visit(SplayTreeNode node, K ifEmpty) {
-      if (node === null) return ifEmpty;
+      if (node == null) return ifEmpty;
       if (node.key.compareTo(key) > 0) {
         return visit(node.left, node.key);
       }
       if (node.key.compareTo(key) <= 0) {
         return visit(node.right, ifEmpty);
       }
     }
     return visit(_root, null);
   }
 }