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

sdk/lib/core/map.dart

 // Copyright (c) 2011, 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 [Map] is an associative container, mapping a key to a value.
  * Null values are supported, but null keys are not.
  */
 abstract class Map<K, V> {
   /**
@@ skipping 180 matching lines @@
   int _probeForAdding(K key) {
     if (key == null) throw const NullPointerException();
     int hash = _firstProbe(key.hashCode, _keys.length);
     int numberOfProbes = 1;
     int initialHash = hash;
     // insertionIndex points to a slot where a key was deleted.
     int insertionIndex = -1;
     while (true) {
       // [existingKey] can be either of type [K] or [_DeletedKeySentinel].
       Object existingKey = _keys[hash];
-      if (existingKey === null) {
+      if (existingKey == null) {
         // We are sure the key is not already in the set.
         // If the current slot is empty and we didn't find any
         // insertion slot before, return this slot.
         if (insertionIndex < 0) return hash;
         // If we did find an insertion slot before, return it.
         return insertionIndex;
       } else if (existingKey == key) {
         // The key is already in the map. Return its slot.
         return hash;
-      } else if ((insertionIndex < 0) && (_DELETED_KEY === existingKey)) {
+      } else if ((insertionIndex < 0) &&
+                 (identical(existingKey, _DELETED_KEY))) {
         // The slot contains a deleted element. Because previous calls to this
         // method may not have had this slot deleted, we must continue iterate
         // to find if there is a slot with the given key.
         insertionIndex = hash;
       }
 
       // We did not find an insertion slot. Look at the next one.
       hash = _nextProbe(hash, numberOfProbes++, _keys.length);
       // _ensureCapacity has guaranteed the following cannot happen.
       // assert(hash != initialHash);
     }
   }
 
   int _probeForLookup(K key) {
     if (key == null) throw const NullPointerException();
     int hash = _firstProbe(key.hashCode, _keys.length);
     int numberOfProbes = 1;
     int initialHash = hash;
     while (true) {
       // [existingKey] can be either of type [K] or [_DeletedKeySentinel].
       Object existingKey = _keys[hash];
       // If the slot does not contain anything (in particular, it does not
       // contain a deleted key), we know the key is not in the map.
-      if (existingKey === null) return -1;
+      if (existingKey == null) return -1;
       // The key is in the map, return its index.
       if (existingKey == key) return hash;
       // Go to the next probe.
       hash = _nextProbe(hash, numberOfProbes++, _keys.length);
       // _ensureCapacity has guaranteed the following cannot happen.
       // assert(hash != initialHash);
     }
   }
 
   void _ensureCapacity() {
@@ skipping 25 matching lines @@
     int capacity = _keys.length;
     _loadLimit = _computeLoadLimit(newCapacity);
     List oldKeys = _keys;
     List<V> oldValues = _values;
     _keys = new List(newCapacity);
     _values = new List<V>(newCapacity);
     for (int i = 0; i < capacity; i++) {
       // [key] can be either of type [K] or [_DeletedKeySentinel].
       Object key = oldKeys[i];
       // If there is no key, we don't need to deal with the current slot.
-      if (key === null || key === _DELETED_KEY) {
+      if (key == null || identical(key, _DELETED_KEY)) {
         continue;
       }
       V value = oldValues[i];
       // Insert the {key, value} pair in their new slot.
       int newIndex = _probeForAdding(key);
       _keys[newIndex] = key;
       _values[newIndex] = value;
     }
     _numberOfDeleted = 0;
   }
 
   void clear() {
     _numberOfEntries = 0;
     _numberOfDeleted = 0;
     int length = _keys.length;
     for (int i = 0; i < length; i++) {
       _keys[i] = null;
       _values[i] = null;
     }
   }
 
   void operator []=(K key, V value) {
     _ensureCapacity();
     int index = _probeForAdding(key);
-    if ((_keys[index] === null) || (_keys[index] === _DELETED_KEY)) {
+    if ((_keys[index] == null) || (identical(_keys[index], _DELETED_KEY))) {
       _numberOfEntries++;
     }
     _keys[index] = key;
     _values[index] = value;
   }
 
   V operator [](K key) {
     int index = _probeForLookup(key);
     if (index < 0) return null;
     return _values[index];
@@ skipping 27 matching lines @@
   }
 
   int get length {
     return _numberOfEntries;
   }
 
   void forEach(void f(K key, V value)) {
     int length = _keys.length;
     for (int i = 0; i < length; i++) {
       var key = _keys[i];
-      if ((key !== null) && (key !== _DELETED_KEY)) {
+      if ((key != null) && (!identical(key, _DELETED_KEY))) {
         f(key, _values[i]);
       }
     }
   }
 
 
   Collection<K> get keys {
     List<K> list = new List<K>(length);
     int i = 0;
     forEach(void _(K key, V value) {
@@ skipping 12 matching lines @@
   }
 
   bool containsKey(K key) {
     return (_probeForLookup(key) != -1);
   }
 
   bool containsValue(V value) {
     int length = _values.length;
     for (int i = 0; i < length; i++) {
       var key = _keys[i];
-      if ((key !== null) && (key !== _DELETED_KEY)) {
+      if ((key != null) && (!identical(key, _DELETED_KEY))) {
         if (_values[i] == value) return true;
       }
     }
     return false;
   }
 
   String toString() {
     return Maps.mapToString(this);
   }
 }
@@ skipping 45 matching lines @@
     if (_map.containsKey(key)) {
       _map[key].element.value = value;
     } else {
       _list.addLast(new _KeyValuePair<K, V>(key, value));
       _map[key] = _list.lastEntry();
     }
   }
 
   V operator [](K key) {
     DoubleLinkedQueueEntry<_KeyValuePair<K, V>> entry = _map[key];
-    if (entry === null) return null;
+    if (entry == null) return null;
     return entry.element.value;
   }
 
   V remove(K key) {
     DoubleLinkedQueueEntry<_KeyValuePair<K, V>> entry = _map.remove(key);
-    if (entry === null) return null;
+    if (entry == null) return null;
     entry.remove();
     return entry.element.value;
   }
 
   V putIfAbsent(K key, V ifAbsent()) {
     V value = this[key];
-    if ((this[key] === null) && !(containsKey(key))) {
+    if ((this[key] == null) && !(containsKey(key))) {
       value = ifAbsent();
       this[key] = value;
     }
     return value;
   }
 
   Collection<K> get keys {
     List<K> list = new List<K>(length);
     int index = 0;
     _list.forEach(void _(_KeyValuePair<K, V> entry) {
@@ skipping 40 matching lines @@
 
   void clear() {
     _map.clear();
     _list.clear();
   }
 
   String toString() {
     return Maps.mapToString(this);
   }
 }