Remove uses of IterableMixinWorkaround outside of VM and dart2js lists.

sdk/lib/collection/iterable.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;
 
 /**
  * This [Iterable] mixin implements all [Iterable] members except `iterator`.
  *
  * All other methods are implemented in terms of `iterator`.
@@ skipping 390 matching lines @@
    * If the resulting string isn't above 80 characters, more elements are
    * included from the start of the iterable.
    *
    * The conversion may omit calling `toString` on some elements if they
    * are known to now occur in the output, and it may stop iterating after
    * a hundred elements.
    */
   String toString() => _iterableToString(this);
 }
 
-String _iterableToString(Iterable iterable) {
-  if (_toStringVisiting.contains(iterable)) return "(...)";
+String _setToString(Set set) => _collectionToString(set, "{" , "}");

[floitsch, 2014/05/23 10:24:55]

This is not the same as `IterableMixinWorkaround.toStringIterable(this, '{',
'}');`

The IterableMixinWorkaround.toStringIterable was not shortening.

[Lasse Reichstein Nielsen, 2014/05/23 11:46:48]

I know, and I think it should be shortened if it is too long.
I'd do the same for List.

[floitsch, 2014/05/23 11:53:57]

That's a breaking change. I can easily imagine doing a print(list) instead of
going through JSON.encode when I know that the list only contains numbers.

Similarly, users may use the output of sets.

+
+String _iterableToString(Iterable iterable) =>
+    _collectionToString(iterable, "(", ")");
+
+String _collectionToString(Iterable iterable, String before, String after) {
+  if (_toStringVisiting.contains(iterable)) return "$before...$after";
   _toStringVisiting.add(iterable);
   List parts = [];
   try {
-    _iterablePartsToStrings(iterable, parts);
+    _collectionPartsToStrings(iterable, parts);
   } finally {
     _toStringVisiting.remove(iterable);
   }
-  return (new StringBuffer("(")..writeAll(parts, ", ")..write(")")).toString();
+  return (new StringBuffer(before)
+              ..writeAll(parts, ", ")
+              ..write(after)).toString();
 }
 
 /** Convert elments of [iterable] to strings and store them in [parts]. */
-void _iterablePartsToStrings(Iterable iterable, List parts) {
+void _collectionPartsToStrings(Iterable iterable, List parts) {
   /// Try to stay below this many characters.
   const int LENGTH_LIMIT = 80;
   /// Always at least this many elements at the start.
   const int HEAD_COUNT = 3;
   /// Always at least this many elements at the end.
   const int TAIL_COUNT = 2;
   /// Stop iterating after this many elements. Iterables can be infinite.
   const int MAX_COUNT = 100;
   // Per entry length overhead. It's for ", " for all after the first entry,
   // and for "(" and ")" for the initial entry. By pure luck, that's the same
   // number.
   const int OVERHEAD = 2;
   const int ELLIPSIS_SIZE = 3;  // "...".length.
-
   int length = 0;
   int count = 0;
   Iterator it = iterable.iterator;
   // Initial run of elements, at least HEAD_COUNT, and then continue until
   // passing at most LENGTH_LIMIT characters.
   while (length < LENGTH_LIMIT || count < HEAD_COUNT) {
-    if (!it.moveNext()) return;
+    if (!it.moveNext()) {
+      return;
+    }
     String next = "${it.current}";
     parts.add(next);
     length += next.length + OVERHEAD;
     count++;
   }
 
   String penultimateString;
   String ultimateString;
 
   // Find last two elements. One or more of them may already be in the
@@ skipping 53 matching lines @@
   String elision = null;
   if (count > parts.length + TAIL_COUNT) {
     elision = "...";
     length += ELLIPSIS_SIZE + OVERHEAD;
   }
 
   // If the last two elements were very long, and we have more than
   // HEAD_COUNT elements in the initial run, drop some to make room for
   // the last two.
   while (length > LENGTH_LIMIT && parts.length > HEAD_COUNT) {
-    length -= parts.removeLast().length + OVERHEAD;
+    String lastPart = parts.removeLast();
+    length -= lastPart.length + OVERHEAD;
     if (elision == null) {
       elision = "...";
       length += ELLIPSIS_SIZE + OVERHEAD;
     }
   }
   if (elision != null) {
     parts.add(elision);
   }
   parts.add(penultimateString);
   parts.add(ultimateString);
 }