Reinstall previous behavior for Set and Queue toString.

sdk/lib/collection/queue.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.
 
 part of dart.collection;
 
 /**
  * A [Queue] is a collection that can be manipulated at both ends. One
  * can iterate over the elements of a queue through [forEach] or with
  * an [Iterator].
@@ skipping 13 matching lines @@
    */
   factory Queue() = ListQueue<E>;
 
   /**
    * Creates a queue with the elements of [other]. The order in
    * the queue will be the order provided by the iterator of [other].
    */
   factory Queue.from(Iterable<E> other) = ListQueue<E>.from;
 
   /**
-   * Removes and returns the first element of this queue. Throws an
-   * [StateError] exception if this queue is empty.
+   * Removes and returns the first element of this queue.
+   *
+   * The queue must not be empty when this method is called.
    */
   E removeFirst();
 
   /**
-   * Removes and returns the last element of the queue. Throws an
-   * [StateError] exception if this queue is empty.
+   * Removes and returns the last element of the queue.
+   *
+   * The queue must not be empty when this method is called.
    */
   E removeLast();
 
   /**
    * Adds [value] at the beginning of the queue.
    */
   void addFirst(E value);
 
   /**
    * Adds [value] at the end of the queue.
@@ skipping 103 matching lines @@
  * which is the only entry when the list is constructed.
  * Initially, a sentinel has its next and previous entry point to itself.
  * A sentinel does not box any user element.
  */
 class _DoubleLinkedQueueEntrySentinel<E> extends DoubleLinkedQueueEntry<E> {
   _DoubleLinkedQueueEntrySentinel() : super(null) {
     _link(this, this);
   }
 
   E remove() {
-    throw new StateError("Empty queue");
+    throw IterableElementError.noElement();
   }
 
   DoubleLinkedQueueEntry<E> _asNonSentinelEntry() {
     return null;
   }
 
   void set element(E e) {
     // This setter is unreachable.
     // TODO(lrn): Don't inherit the field if we don't use it.
     assert(false);
   }
 
   E get element {
-    throw new StateError("Empty queue");
+    throw IterableElementError.noElement();
   }
 }
 
 /**
  * A [Queue] implementation based on a double-linked list.
  *
  * Allows constant time add, remove-at-ends and peek operations.
  */
 class DoubleLinkedQueue<E> extends IterableBase<E> implements Queue<E> {
   _DoubleLinkedQueueEntrySentinel<E> _sentinel;
@@ skipping 82 matching lines @@
 
   E get first {
     return _sentinel._next.element;
   }
 
   E get last {
     return _sentinel._previous.element;
   }
 
   E get single {
-    // Note that this also covers the case where the queue is empty.
+    // Note that this throws correctly if the queue is empty.
     if (identical(_sentinel._next, _sentinel._previous)) {
       return _sentinel._next.element;
     }
-    throw new StateError("More than one element");
+    throw IterableElementError.tooMany();
   }
 
   DoubleLinkedQueueEntry<E> lastEntry() {
     return _sentinel.previousEntry();
   }
 
   DoubleLinkedQueueEntry<E> firstEntry() {
     return _sentinel.nextEntry();
   }
 
@@ skipping 13 matching lines @@
       DoubleLinkedQueueEntry<E> nextEntry = entry._next;
       f(entry);
       entry = nextEntry;
     }
   }
 
   _DoubleLinkedQueueIterator<E> get iterator {
     return new _DoubleLinkedQueueIterator<E>(_sentinel);
   }
 
-  String toString() => _collectionToString(this, '{', '}');
+  String toString() => IterableBase.iterableToFullString(this, '{', '}');
 }
 
 class _DoubleLinkedQueueIterator<E> implements Iterator<E> {
   _DoubleLinkedQueueEntrySentinel<E> _sentinel;
   DoubleLinkedQueueEntry<E> _nextEntry = null;
   E _current;
 
   _DoubleLinkedQueueIterator(_DoubleLinkedQueueEntrySentinel<E> sentinel)
       : _sentinel = sentinel, _nextEntry = sentinel._next;
 
@@ skipping 71 matching lines @@
       action(_table[i]);
       _checkModification(modificationCount);
     }
   }
 
   bool get isEmpty => _head == _tail;
 
   int get length => (_tail - _head) & (_table.length - 1);
 
   E get first {
-    if (_head == _tail) throw new StateError("No elements");
+    if (_head == _tail) throw IterableElementError.noElement();
     return _table[_head];
   }
 
   E get last {
-    if (_head == _tail) throw new StateError("No elements");
+    if (_head == _tail) throw IterableElementError.noElement();
     return _table[(_tail - 1) & (_table.length - 1)];
   }
 
   E get single {
-    if (_head == _tail) throw new StateError("No elements");
-    if (length > 1) throw new StateError("Too many elements");
+    if (_head == _tail) throw IterableElementError.noElement();
+    if (length > 1) throw IterableElementError.tooMany();
     return _table[_head];
   }
 
   E elementAt(int index) {
     if (index < 0 || index > length) {
       throw new RangeError.range(index, 0, length);
     }
     return _table[(_head + index) & (_table.length - 1)];
   }
 
@@ skipping 95 matching lines @@
   void clear() {
     if (_head != _tail) {
       for (int i = _head; i != _tail; i = (i + 1) & (_table.length - 1)) {
         _table[i] = null;
       }
       _head = _tail = 0;
       _modificationCount++;
     }
   }
 
-  String toString() => _collectionToString(this, '{', '}');
+  String toString() => IterableBase.iterableToFullString(this, "{", "}");
 
   // Queue interface.
 
   void addLast(E element) { _add(element); }
 
   void addFirst(E element) {
     _head = (_head - 1) & (_table.length - 1);
     _table[_head] = element;
     if (_head == _tail) _grow();
     _modificationCount++;
   }
 
   E removeFirst() {
-    if (_head == _tail) throw new StateError("No elements");
+    if (_head == _tail) throw IterableElementError.noElement();
     _modificationCount++;
     E result = _table[_head];
     _table[_head] = null;
     _head = (_head + 1) & (_table.length - 1);
     return result;
   }
 
   E removeLast() {
-    if (_head == _tail) throw new StateError("No elements");
+    if (_head == _tail) throw IterableElementError.noElement();
     _modificationCount++;
     _tail = (_tail - 1) & (_table.length - 1);
     E result = _table[_tail];
     _table[_tail] = null;
     return result;
   }
 
   // Internal helper functions.
 
   /**
@@ skipping 135 matching lines @@
     _queue._checkModification(_modificationCount);
     if (_position == _end) {
       _current = null;
       return false;
     }
     _current = _queue._table[_position];
     _position = (_position + 1) & (_queue._table.length - 1);
     return true;
   }
 }