[core] cleanup === and !==

lib/coreimpl/queue.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.
 
 
 /**
  * An entry in a doubly linked list. It contains a pointer to the next
  * entry, the previous entry, and the boxed element.
  */
 class DoubleLinkedQueueEntry<E> {
@@ skipping 141 matching lines @@
     return _sentinel.nextEntry();
   }
 
   int get length {
     int counter = 0;
     forEach(void _(E element) { counter++; });
     return counter;
   }
 
   bool isEmpty() {
-    return (_sentinel._next === _sentinel);
+    return (identical(_sentinel._next, _sentinel));

[ahe, 2012/10/22 09:05:21]

Put _sentinel on the left to avoid using identical. Applies to rest of this
file.

[floitsch, 2012/10/22 12:07:37]

I would prefer keeping it.

   }
 
   void clear() {
     _sentinel._next = _sentinel;
     _sentinel._previous = _sentinel;
   }
 
   void forEach(void f(E element)) {
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
-    while (entry !== _sentinel) {
+    while (!identical(entry, _sentinel)) {
       DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       f(entry._element);
       entry = nextEntry;
     }
   }
 
   void forEachEntry(void f(DoubleLinkedQueueEntry<E> element)) {
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
-    while (entry !== _sentinel) {
+    while (!identical(entry, _sentinel)) {
       DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       f(entry);
       entry = nextEntry;
     }
   }
 
   bool every(bool f(E element)) {
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
-    while (entry !== _sentinel) {
+    while (!identical(entry, _sentinel)) {
       DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       if (!f(entry._element)) return false;
       entry = nextEntry;
     }
     return true;
   }
 
   bool some(bool f(E element)) {
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
-    while (entry !== _sentinel) {
+    while (!identical(entry, _sentinel)) {
       DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       if (f(entry._element)) return true;
       entry = nextEntry;
     }
     return false;
   }
 
   Queue map(f(E element)) {
     Queue other = new Queue();
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
-    while (entry !== _sentinel) {
+    while (!identical(entry, _sentinel)) {
       DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       other.addLast(f(entry._element));
       entry = nextEntry;
     }
     return other;
   }
 
   Dynamic reduce(Dynamic initialValue,
                  Dynamic combine(Dynamic previousValue, E element)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   Queue<E> filter(bool f(E element)) {
     Queue<E> other = new Queue<E>();
     DoubleLinkedQueueEntry<E> entry = _sentinel._next;
-    while (entry !== _sentinel) {
+    while (!identical(entry, _sentinel)) {
       DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       if (f(entry._element)) other.addLast(entry._element);
       entry = nextEntry;
     }
     return other;
   }
 
   _DoubleLinkedQueueIterator<E> iterator() {
     return new _DoubleLinkedQueueIterator<E>(_sentinel);
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 }
 
 class _DoubleLinkedQueueIterator<E> implements Iterator<E> {
   final _DoubleLinkedQueueEntrySentinel<E> _sentinel;
   DoubleLinkedQueueEntry<E> _currentEntry;
 
   _DoubleLinkedQueueIterator(_DoubleLinkedQueueEntrySentinel this._sentinel) {
     _currentEntry = _sentinel;
   }
 
   bool hasNext() {
-    return _currentEntry._next !== _sentinel;
+    return !identical(_currentEntry._next, _sentinel);
   }
 
   E next() {
     if (!hasNext()) {
       throw const NoMoreElementsException();
     }
     _currentEntry = _currentEntry._next;
     return _currentEntry.element;
   }
 }