Make Iterable.toList more efficient if the length is known.

runtime/lib/typed_data.dart

 // Copyright (c) 2013, 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.
 
 library dart.typed_data;
 
 import "dart:_internal";
 import "dart:collection" show ListBase;
 import 'dart:math' show Random;
 
@@ skipping 717 matching lines @@
   Iterable<int> get reversed => new ReversedListIterable<int>(this);
 
   Map<int, int> asMap() => new ListMapView<int>(this);
 
   Iterable<int> getRange(int start, [int end]) {
     RangeError.checkValidRange(start, end, this.length);
     return new SubListIterable<int>(this, start, end);
   }
 
   Iterator<int> get iterator => new _TypedListIterator<int>(this);
+
+  List<int> toList({bool growable: true}) {
+    return new List<int>.from(this, growable: growable);
+  }
+
+  Set<int> toSet() {
+    return new Set<int>.from(this);
+  }
 }
 
 
 class _DoubleListMixin {
   Iterable<double> where(bool f(int element)) =>
     new WhereIterable<double>(this, f);
 
   Iterable<double> take(int n) => new SubListIterable<double>(this, 0, n);
 
   Iterable<double> takeWhile(bool test(int element)) =>
     new TakeWhileIterable<double>(this, test);
 
   Iterable<double> skip(int n) => new SubListIterable<double>(this, n, null);
 
   Iterable<double> skipWhile(bool test(element)) =>
     new SkipWhileIterable<double>(this, test);
 
   Iterable<double> get reversed => new ReversedListIterable<double>(this);
 
   Map<int, double> asMap() => new ListMapView<double>(this);
 
   Iterable<double> getRange(int start, [int end]) {
     RangeError.checkValidRange(start, end, this.length);
     return new SubListIterable<double>(this, start, end);
   }
 
   Iterator<double> get iterator => new _TypedListIterator<double>(this);
+
+  List<double> toList({bool growable: true}) {
+    return new List<double>.from(this, growable: growable);
+  }
+
+  Set<double> toSet() {
+    return new Set<double>.from(this);
+  }
 }
 
 
 class _Float32x4ListMixin {
   Iterable<Float32x4> where(bool f(int element)) =>
     new WhereIterable<Float32x4>(this, f);
 
   Iterable<Float32x4> take(int n) => new SubListIterable<Float32x4>(this, 0, n);
 
   Iterable<Float32x4> takeWhile(bool test(int element)) =>
     new TakeWhileIterable<Float32x4>(this, test);
 
   Iterable<Float32x4> skip(int n) =>
     new SubListIterable<Float32x4>(this, n, null);
 
   Iterable<Float32x4> skipWhile(bool test(element)) =>
     new SkipWhileIterable<Float32x4>(this, test);
 
   Iterable<Float32x4> get reversed => new ReversedListIterable<Float32x4>(this);
 
   Map<int, Float32x4> asMap() => new ListMapView<Float32x4>(this);
 
   Iterable<Float32x4> getRange(int start, [int end]) {
     RangeError.checkValidRange(start, end, this.length);
     return new SubListIterable<Float32x4>(this, start, end);
   }
 
   Iterator<Float32x4> get iterator => new _TypedListIterator<Float32x4>(this);
+
+  List<Float32x4> toList({bool growable: true}) {
+    return new List<Float32x4>.from(this, growable: growable);
+  }
+
+  Set<Float32x4> toSet() {
+    return new Set<Float32x4>.from(this);
+  }
 }
 
 
 class _Int32x4ListMixin {
   Iterable<Int32x4> where(bool f(int element)) =>
     new WhereIterable<Int32x4>(this, f);
 
   Iterable<Int32x4> take(int n) => new SubListIterable<Int32x4>(this, 0, n);
 
   Iterable<Int32x4> takeWhile(bool test(int element)) =>
     new TakeWhileIterable<Int32x4>(this, test);
 
   Iterable<Int32x4> skip(int n) => new SubListIterable<Int32x4>(this, n, null);
 
   Iterable<Int32x4> skipWhile(bool test(element)) =>
     new SkipWhileIterable<Int32x4>(this, test);
 
   Iterable<Int32x4> get reversed => new ReversedListIterable<Int32x4>(this);
 
   Map<int, Int32x4> asMap() => new ListMapView<Int32x4>(this);
 
   Iterable<Int32x4> getRange(int start, [int end]) {
     RangeError.checkValidRange(start, end, this.length);
     return new SubListIterable<Int32x4>(this, start, end);
   }
 
   Iterator<Int32x4> get iterator => new _TypedListIterator<Int32x4>(this);
+
+  List<Int32x4> toList({bool growable: true}) {
+    return new List<Int32x4>.from(this, growable: growable);
+  }
+
+  Set<Int32x4> toSet() {
+    return new Set<Int32x4>.from(this);
+  }
 }
 
 
 class _Float64x2ListMixin {
   Iterable<Float64x2> where(bool f(int element)) =>
     new WhereIterable<Float64x2>(this, f);
 
   Iterable<Float64x2> take(int n) => new SubListIterable<Float64x2>(this, 0, n);
 
   Iterable<Float64x2> takeWhile(bool test(int element)) =>
     new TakeWhileIterable<Float64x2>(this, test);
 
   Iterable<Float64x2> skip(int n) =>
     new SubListIterable<Float64x2>(this, n, null);
 
   Iterable<Float64x2> skipWhile(bool test(element)) =>
     new SkipWhileIterable<Float64x2>(this, test);
 
   Iterable<Float64x2> get reversed => new ReversedListIterable<Float64x2>(this);
 
   Map<int, Float64x2> asMap() => new ListMapView<Float64x2>(this);
 
   Iterable<Float64x2> getRange(int start, [int end]) {
     RangeError.checkValidRange(start, end, this.length);
     return new SubListIterable<Float64x2>(this, start, end);
   }
 
   Iterator<Float64x2> get iterator => new _TypedListIterator<Float64x2>(this);
+
+  List<Float64x2> toList({bool growable: true}) {
+    return new List<Float64x2>.from(this, growable: growable);
+  }
+
+  Set<Float64x2> toSet() {
+    return new Set<Float64x2>.from(this);
+  }
 }
 
 
 class ByteBuffer {
   final _TypedList _data;
 
   ByteBuffer(this._data);
 
   factory ByteBuffer._New(data) => new ByteBuffer(data);
 
@@ skipping 281 matching lines @@
     _setUint8(index, _toUint8(value));
   }
 
   static const int BYTES_PER_ELEMENT = 1;
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
-
   // Internal utility methods.
 
   Uint8List _createList(int length) {
     return new Uint8List(length);
   }
 }
 
 
 class Uint8ClampedList extends _TypedList with _IntListMixin implements List<int>, TypedData {
   // Factory constructors.
@@ skipping 3105 matching lines @@
   }
 }
 
 
 int _defaultIfNull(object, value) {
   if (object == null) {
     return value;
   }
   return object;
 }