SDK fixes

tool/input_sdk/lib/internal/iterable.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._internal;
 
 /**
  * Marker interface for [Iterable] subclasses that have an efficient
  * [length] implementation.
  */
 abstract class EfficientLength {
   /**
    * Returns the number of elements in the iterable.
    *
    * This is an efficient operation that doesn't require iterating through
    * the elements.
    */
   int get length;
 }
 
 /**
  * An [Iterable] for classes that have efficient [length] and [elementAt].
  *
  * All other methods are implemented in terms of [length] and [elementAt],
  * including [iterator].
  */
 abstract class ListIterable<E> extends IterableBase<E>
-                               implements EfficientLength {
+    implements EfficientLength {
   int get length;
   E elementAt(int i);
 
   const ListIterable();
 
   Iterator<E> get iterator => new ListIterator<E>(this);
 
   void forEach(void action(E element)) {
     int length = this.length;
     for (int i = 0; i < length; i++) {
@@ skipping 48 matching lines @@
     int length = this.length;
     for (int i = 0; i < length; i++) {
       if (test(elementAt(i))) return true;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     return false;
   }
 
-  E firstWhere(bool test(E element), { E orElse() }) {
+  E firstWhere(bool test(E element), {E orElse()}) {
     int length = this.length;
     for (int i = 0; i < length; i++) {
       E element = elementAt(i);
       if (test(element)) return element;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  E lastWhere(bool test(E element), { E orElse() }) {
+  E lastWhere(bool test(E element), {E orElse()}) {
     int length = this.length;
     for (int i = length - 1; i >= 0; i--) {
       E element = elementAt(i);
       if (test(element)) return element;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
@@ skipping 44 matching lines @@
         if (length != this.length) {
           throw new ConcurrentModificationError(this);
         }
       }
       return buffer.toString();
     }
   }
 
   Iterable<E> where(bool test(E element)) => super.where(test);
 
-  Iterable/*<T>*/ map/*<T>*/(/*=T*/f(E element)) => new MappedListIterable<E, dynamic/*=T*/>(this, f);
+  Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E element)) =>
+      new MappedListIterable<E, dynamic/*=T*/ >(this, f);

[Bob Nystrom, 2016/03/18 00:34:51]

The space after the comment looks wrong to me. Might want to make sure you have
the latest dartfmt?

[Leaf, 2016/03/18 00:48:22]

Seems to be:

leafp-macbookpro:dev_compiler leafp$ rundart.sh dartfmt --version
0.2.4
leafp-macbookpro:dev_compiler leafp$ rundart.sh dart --version
Dart VM version: 1.16.0-dev.1.0 (Wed Mar 16 09:20:32 2016) on "macos_x64"
leafp-macbookpro:dev_compiler leafp$ rundart.sh dartfmt --version
0.2.4
leafp-macbookpro:dev_compiler leafp$ rundart.sh dartfmt -w
tool/input_sdk/lib/internal/iterable.dart 
Unchanged tool/input_sdk/lib/internal/iterable.dart

 
   E reduce(E combine(var value, E element)) {
     int length = this.length;
     if (length == 0) throw IterableElementError.noElement();
     E value = elementAt(0);
     for (int i = 1; i < length; i++) {
       value = combine(value, elementAt(i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
-
     }
     return value;
   }
 
-  /*=T*/ fold/*<T>*/(var/*=T*/ initialValue, /*=T*/combine(var/*=T*/ previousValue, E element)) {
+  /*=T*/ fold/*<T>*/(
+      var/*=T*/ initialValue, /*=T*/ combine(
+          var/*=T*/ previousValue, E element)) {
     var value = initialValue;
     int length = this.length;
     for (int i = 0; i < length; i++) {
       value = combine(value, elementAt(i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     return value;
   }
 
   Iterable<E> skip(int count) => new SubListIterable<E>(this, count, null);
 
   Iterable<E> skipWhile(bool test(E element)) => super.skipWhile(test);
 
   Iterable<E> take(int count) => new SubListIterable<E>(this, 0, count);
 
   Iterable<E> takeWhile(bool test(E element)) => super.takeWhile(test);
 
-  List<E> toList({ bool growable: true }) {
+  List<E> toList({bool growable: true}) {
     List<E> result;
     if (growable) {
       result = new List<E>()..length = length;
     } else {
       result = new List<E>(length);
     }
     for (int i = 0; i < length; i++) {
       result[i] = elementAt(i);
     }
     return result;
   }
 
   Set<E> toSet() {
     Set<E> result = new Set<E>();
     for (int i = 0; i < length; i++) {
       result.add(elementAt(i));
     }
     return result;
   }
 }
 
 class SubListIterable<E> extends ListIterable<E> {
-  final Iterable<E> _iterable;  // Has efficient length and elementAt.
+  final Iterable<E> _iterable; // Has efficient length and elementAt.
   final int _start;
   /** If null, represents the length of the iterable. */
   final int _endOrLength;
 
   SubListIterable(this._iterable, this._start, this._endOrLength) {
     RangeError.checkNotNegative(_start, "start");
     if (_endOrLength != null) {
       RangeError.checkNotNegative(_endOrLength, "end");
       if (_start > _endOrLength) {
         throw new RangeError.range(_start, 0, _endOrLength, "start");
@@ skipping 49 matching lines @@
       return new SubListIterable<E>(_iterable, _start, newEnd);
     }
   }
 
   List<E> toList({bool growable: true}) {
     int start = _start;
     int end = _iterable.length;
     if (_endOrLength != null && _endOrLength < end) end = _endOrLength;
     int length = end - start;
     if (length < 0) length = 0;
-    List result = growable ? (new List<E>()..length = length)
-                           : new List<E>(length);
+    List result =
+        growable ? (new List<E>()..length = length) : new List<E>(length);
     for (int i = 0; i < length; i++) {
       result[i] = _iterable.elementAt(start + i);
       if (_iterable.length < end) throw new ConcurrentModificationError(this);
     }
     return result;
   }
 }
 
 /**
  * An [Iterator] that iterates a list-like [Iterable].
  *
  * All iterations is done in terms of [Iterable.length] and
  * [Iterable.elementAt]. These operations are fast for list-like
  * iterables.
  */
 class ListIterator<E> implements Iterator<E> {
   final Iterable<E> _iterable;
   final int _length;
   int _index;
   E _current;
 
   ListIterator(Iterable<E> iterable)
-      : _iterable = iterable, _length = iterable.length, _index = 0;
+      : _iterable = iterable,
+        _length = iterable.length,
+        _index = 0;
 
   E get current => _current;
 
   bool moveNext() {
     int length = _iterable.length;
     if (_length != length) {
       throw new ConcurrentModificationError(_iterable);
     }
     if (_index >= length) {
       _current = null;
@@ skipping 27 matching lines @@
   bool get isEmpty => _iterable.isEmpty;
 
   // Index based lookup can be done before transforming.
   T get first => _f(_iterable.first);
   T get last => _f(_iterable.last);
   T get single => _f(_iterable.single);
   T elementAt(int index) => _f(_iterable.elementAt(index));
 }
 
 class EfficientLengthMappedIterable<S, T> extends MappedIterable<S, T>
-                                          implements EfficientLength {
+    implements EfficientLength {
   EfficientLengthMappedIterable(Iterable iterable, T function(S value))
       : super._(iterable, function);
 }
 
 class MappedIterator<S, T> extends Iterator<T> {
   T _current;
   final Iterator<S> _iterator;
   final _Transformation<S, T> _f;
 
   MappedIterator(this._iterator, T this._f(S element));
 
   bool moveNext() {
     if (_iterator.moveNext()) {
       _current = _f(_iterator.current);
       return true;
     }
     _current = null;
     return false;
   }
 
   T get current => _current;
 }
 
 /**
  * Specialized alternative to [MappedIterable] for mapped [List]s.
  *
  * Expects efficient `length` and `elementAt` on the source iterable.
  */
 class MappedListIterable<S, T> extends ListIterable<T>
-                               implements EfficientLength {
+    implements EfficientLength {
   final Iterable<S> _source;
   final _Transformation<S, T> _f;
 
   MappedListIterable(this._source, T this._f(S value));
 
   int get length => _source.length;
   T elementAt(int index) => _f(_source.elementAt(index));
 }
 
-
 typedef bool _ElementPredicate<E>(E element);
 
 class WhereIterable<E> extends IterableBase<E> {
   final Iterable<E> _iterable;
   final _ElementPredicate<E> _f;
 
   WhereIterable(this._iterable, bool this._f(E element));
 
   Iterator<E> get iterator => new WhereIterator<E>(_iterable.iterator, _f);
 }
@@ skipping 31 matching lines @@
   final Iterator<S> _iterator;
   final _ExpandFunction _f;
   // Initialize _currentExpansion to an empty iterable. A null value
   // marks the end of iteration, and we don't want to call _f before
   // the first moveNext call.
   Iterator<T> _currentExpansion = const EmptyIterator();
   T _current;
 
   ExpandIterator(this._iterator, Iterable<T> this._f(S element));
 
-  void _nextExpansion() {
-  }
+  void _nextExpansion() {}
 
   T get current => _current;
 
   bool moveNext() {
     if (_currentExpansion == null) return false;
     while (!_currentExpansion.moveNext()) {
       _current = null;
       if (_iterator.moveNext()) {
         // If _f throws, this ends iteration. Otherwise _currentExpansion and
         // _current will be set again below.
@@ skipping 23 matching lines @@
   }
 
   TakeIterable._(this._iterable, this._takeCount);
 
   Iterator<E> get iterator {
     return new TakeIterator<E>(_iterable.iterator, _takeCount);
   }
 }
 
 class EfficientLengthTakeIterable<E> extends TakeIterable<E>
-                                     implements EfficientLength {
+    implements EfficientLength {
   EfficientLengthTakeIterable(Iterable<E> iterable, int takeCount)
       : super._(iterable, takeCount);
 
   int get length {
     int iterableLength = _iterable.length;
     if (iterableLength > _takeCount) return _takeCount;
     return iterableLength;
   }
 }
 
-
 class TakeIterator<E> extends Iterator<E> {
   final Iterator<E> _iterator;
   int _remaining;
 
   TakeIterator(this._iterator, this._remaining) {
     assert(_remaining is int && _remaining >= 0);
   }
 
   bool moveNext() {
     _remaining--;
@@ skipping 68 matching lines @@
     RangeError.checkNotNegative(_skipCount, "count");
     return new SkipIterable<E>._(_iterable, _skipCount + count);
   }
 
   Iterator<E> get iterator {
     return new SkipIterator<E>(_iterable.iterator, _skipCount);
   }
 }
 
 class EfficientLengthSkipIterable<E> extends SkipIterable<E>
-                                     implements EfficientLength {
+    implements EfficientLength {
   EfficientLengthSkipIterable(Iterable<E> iterable, int skipCount)
       : super._(iterable, skipCount);
 
   int get length {
     int length = _iterable.length - _skipCount;
     if (length >= 0) return length;
     return 0;
   }
 }
 
@@ skipping 52 matching lines @@
   const EmptyIterable();
 
   Iterator<E> get iterator => const EmptyIterator();
 
   void forEach(void action(E element)) {}
 
   bool get isEmpty => true;
 
   int get length => 0;
 
-  E get first { throw IterableElementError.noElement(); }
+  E get first {
+    throw IterableElementError.noElement();
+  }
 
-  E get last { throw IterableElementError.noElement(); }
+  E get last {
+    throw IterableElementError.noElement();
+  }
 
-  E get single { throw IterableElementError.noElement(); }
+  E get single {
+    throw IterableElementError.noElement();
+  }
 
-  E elementAt(int index) { throw new RangeError.range(index, 0, 0, "index"); }
+  E elementAt(int index) {
+    throw new RangeError.range(index, 0, 0, "index");
+  }
 
   bool contains(Object element) => false;
 
   bool every(bool test(E element)) => true;
 
   bool any(bool test(E element)) => false;
 
-  E firstWhere(bool test(E element), { E orElse() }) {
+  E firstWhere(bool test(E element), {E orElse()}) {
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  E lastWhere(bool test(E element), { E orElse() }) {
+  E lastWhere(bool test(E element), {E orElse()}) {
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  E singleWhere(bool test(E element), { E orElse() }) {
+  E singleWhere(bool test(E element), {E orElse()}) {
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
   String join([String separator = ""]) => "";
 
   Iterable<E> where(bool test(E element)) => this;
 
   Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E element)) => const EmptyIterable();
 
   E reduce(E combine(E value, E element)) {
     throw IterableElementError.noElement();
   }
 
-  /*=T*/ fold/*<T>*/(var/*=T*/ initialValue, /*=T*/ combine(var/*=T*/ previousValue, E element)) {
+  /*=T*/ fold/*<T>*/(
+      var/*=T*/ initialValue, /*=T*/ combine(
+          var/*=T*/ previousValue, E element)) {
     return initialValue;
   }
 
   Iterable<E> skip(int count) {
     RangeError.checkNotNegative(count, "count");
     return this;
   }
 
   Iterable<E> skipWhile(bool test(E element)) => this;
 
   Iterable<E> take(int count) {
     RangeError.checkNotNegative(count, "count");
     return this;
   }
 
   Iterable<E> takeWhile(bool test(E element)) => this;
 
-  List<E> toList({ bool growable: true }) => growable ? <E>[] : new List<E>(0);
+  List<E> toList({bool growable: true}) => growable ? <E>[] : new List<E>(0);
 
   Set<E> toSet() => new Set<E>();
 }
 
 /** The always empty iterator. */
 class EmptyIterator<E> implements Iterator<E> {
   const EmptyIterator();
   bool moveNext() => false;
   E get current => null;
 }
@@ skipping 30 matching lines @@
   }
 
   static bool every/*<E>*/(Iterable/*<E>*/ iterable, bool f(/*=E*/ o)) {
     for (final e in iterable) {
       if (!f(e)) return false;
     }
     return true;
   }
 
   static dynamic/*=E*/ reduce/*<E>*/(Iterable/*<E>*/ iterable,
-                                  dynamic/*=E*/ combine(/*=E*/previousValue, /*=E*/element)) {
+      dynamic/*=E*/ combine(/*=E*/ previousValue, /*=E*/ element)) {
     Iterator/*<E>*/ iterator = iterable.iterator;
     if (!iterator.moveNext()) throw IterableElementError.noElement();
     var value = iterator.current;
     while (iterator.moveNext()) {
       value = combine(value, iterator.current);
     }
     return value;
   }
 
-  static /*=V*/ fold/*<E, V>*/(Iterable/*<E>*/ iterable,
-                               dynamic/*=V*/ initialValue,
-                               dynamic/*=V*/ combine(dynamic/*=V*/ previousValue, /*=E*/element)) {
+  static/*=V*/ fold/*<E, V>*/(
+      Iterable/*<E>*/ iterable,
+      dynamic/*=V*/ initialValue,
+      dynamic/*=V*/ combine(dynamic/*=V*/ previousValue, /*=E*/ element)) {
     for (final element in iterable) {
       initialValue = combine(initialValue, element);
     }
     return initialValue;
   }
 
   /**
    * Removes elements matching [test] from [list].
    *
    * This is performed in two steps, to avoid exposing an inconsistent state
    * to the [test] function. First the elements to retain are found, and then
    * the original list is updated to contain those elements.
    */
-  static void removeWhereList/*<E>*/(List/*<E>*/ list, bool test(var/*=E*/ element)) {
+  static void removeWhereList/*<E>*/(
+      List/*<E>*/ list, bool test(var/*=E*/ element)) {
     List/*<E>*/ retained = [];
     int length = list.length;
     for (int i = 0; i < length; i++) {
       var element = list[i];
       if (!test(element)) {
         retained.add(element);
       }
       if (length != list.length) {
         throw new ConcurrentModificationError(list);
       }
@@ skipping 18 matching lines @@
   }
 
   static dynamic/*=E*/ last/*<E>*/(Iterable/*<E>*/ iterable) {
     Iterator/*<E>*/ it = iterable.iterator;
     if (!it.moveNext()) {
       throw IterableElementError.noElement();
     }
     var/*=E*/ result;
     do {
       result = it.current;
-    } while(it.moveNext());
+    } while (it.moveNext());
     return result;
   }
 
   static dynamic/*=E*/ single/*<E>*/(Iterable/*<E>*/ iterable) {
     Iterator/*<E>*/ it = iterable.iterator;
     if (!it.moveNext()) throw IterableElementError.noElement();
     var result = it.current;
     if (it.moveNext()) throw IterableElementError.tooMany();
     return result;
   }
 
   static dynamic/*=E*/ firstWhere/*<E>*/(Iterable/*<E>*/ iterable,
-                                         bool test(dynamic/*=E*/ value),
-                                         dynamic/*=E*/ orElse()) {
+      bool test(dynamic/*=E*/ value), dynamic/*=E*/ orElse()) {
     for (var element in iterable) {
       if (test(element)) return element;
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
   static dynamic/*=E*/ lastWhere/*<E>*/(Iterable/*<E>*/ iterable,
-                           bool test(dynamic/*=E*/ value),
-                           dynamic/*=E*/ orElse()) {
+      bool test(dynamic/*=E*/ value), dynamic/*=E*/ orElse()) {
     dynamic/*=E*/ result = null;
     bool foundMatching = false;
     for (var element in iterable) {
       if (test(element)) {
         result = element;
         foundMatching = true;
       }
     }
     if (foundMatching) return result;
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
   static dynamic/*=E*/ lastWhereList/*<E>*/(List/*<E>*/ list,
-                               bool test(dynamic/*=E*/ value),
-                               dynamic/*=E*/ orElse()) {
+      bool test(dynamic/*=E*/ value), dynamic/*=E*/ orElse()) {
     // TODO(floitsch): check that arguments are of correct type?
     for (int i = list.length - 1; i >= 0; i--) {
       var element = list[i];
       if (test(element)) return element;
     }
     if (orElse != null) return orElse();
     throw IterableElementError.noElement();
   }
 
-  static dynamic/*=E*/ singleWhere/*<E>*/(Iterable/*<E>*/ iterable, bool test(dynamic/*=E*/ value)) {
+  static dynamic/*=E*/ singleWhere/*<E>*/(
+      Iterable/*<E>*/ iterable, bool test(dynamic/*=E*/ value)) {
     dynamic/*=E*/ result = null;
     bool foundMatching = false;
     for (var element in iterable) {
       if (test(element)) {
         if (foundMatching) {
           throw IterableElementError.tooMany();
         }
         result = element;
         foundMatching = true;
       }
@@ skipping 34 matching lines @@
         buffer.write(list[i]);
       }
     }
     return buffer.toString();
   }
 
   Iterable<T> where(Iterable<T> iterable, bool f(T element)) {
     return new WhereIterable<T>(iterable, f);
   }
 
-  static Iterable/*<V>*/ map/*<E, V>*/(Iterable/*<E>*/ iterable, /*=V*/ f(var/*=E*/ element)) {
+  static Iterable/*<V>*/ map/*<E, V>*/(
+      Iterable/*<E>*/ iterable, /*=V*/ f(var/*=E*/ element)) {
     return new MappedIterable/*<E, V>*/(iterable, f);
   }
 
-  static Iterable/*<V>*/ mapList/*<E, V>*/(List/*<E>*/ list, /*=V*/ f(var/*=E*/ element)) {
+  static Iterable/*<V>*/ mapList/*<E, V>*/(
+      List/*<E>*/ list, /*=V*/ f(var/*=E*/ element)) {
     return new MappedListIterable/*<E, V>*/(list, f);
   }
 
-  static Iterable/*<V>*/ expand/*<E, V>*/(Iterable/*<E>*/ iterable, Iterable/*<V>*/ f(var/*=E*/ element)) {
+  static Iterable/*<V>*/ expand/*<E, V>*/(
+      Iterable/*<E>*/ iterable, Iterable/*<V>*/ f(var/*=E*/ element)) {
     return new ExpandIterable/*<E, V>*/(iterable, f);
   }
 
   Iterable<T> takeList(List list, int n) {
     // The generic type is currently lost. It will be fixed with mixins.
     return new SubListIterable<T>(list, 0, n);
   }
 
   Iterable<T> takeWhile(Iterable iterable, bool test(var value)) {
     // The generic type is currently lost. It will be fixed with mixins.
@@ skipping 43 matching lines @@
   static void _rangeCheck(List list, int start, int end) {
     RangeError.checkValidRange(start, end, list.length);
   }
 
   Iterable<T> getRangeList(List list, int start, int end) {
     _rangeCheck(list, start, end);
     // The generic type is currently lost. It will be fixed with mixins.
     return new SubListIterable<T>(list, start, end);
   }
 
-  static void setRangeList(List list, int start, int end,
-                           Iterable from, int skipCount) {
+  static void setRangeList(
+      List list, int start, int end, Iterable from, int skipCount) {
     _rangeCheck(list, start, end);
     int length = end - start;
     if (length == 0) return;
 
     if (skipCount < 0) throw new ArgumentError(skipCount);
 
     // TODO(floitsch): Make this accept more.
     List otherList;
     int otherStart;
     if (from is List) {
       otherList = from;
       otherStart = skipCount;
     } else {
       otherList = from.skip(skipCount).toList(growable: false);
       otherStart = 0;
     }
     if (otherStart + length > otherList.length) {
       throw IterableElementError.tooFew();
     }
     Lists.copy(otherList, otherStart, list, start, length);
   }
 
-  static void replaceRangeList(List list, int start, int end,
-                               Iterable iterable) {
+  static void replaceRangeList(
+      List list, int start, int end, Iterable iterable) {
     _rangeCheck(list, start, end);
     if (iterable is! EfficientLength) {
       iterable = iterable.toList();
     }
     int removeLength = end - start;
     int insertLength = iterable.length;
     if (removeLength >= insertLength) {
       int delta = removeLength - insertLength;
       int insertEnd = start + insertLength;
       int newEnd = list.length - delta;
       list.setRange(start, insertEnd, iterable);
       if (delta != 0) {
         list.setRange(insertEnd, newEnd, list, end);
         list.length = newEnd;
       }
     } else {
       int delta = insertLength - removeLength;
       int newLength = list.length + delta;
-      int insertEnd = start + insertLength;  // aka. end + delta.
+      int insertEnd = start + insertLength; // aka. end + delta.
       list.length = newLength;
       list.setRange(insertEnd, newLength, list, end);
       list.setRange(start, insertEnd, iterable);
     }
   }
 
   static void fillRangeList(List list, int start, int end, fillValue) {
     _rangeCheck(list, start, end);
     for (int i = start; i < end; i++) {
       list[i] = fillValue;
@@ skipping 69 matching lines @@
  * Creates errors throw by [Iterable] when the element count is wrong.
  */
 abstract class IterableElementError {
   /** Error thrown thrown by, e.g., [Iterable.first] when there is no result. */
   static StateError noElement() => new StateError("No element");
   /** Error thrown by, e.g., [Iterable.single] if there are too many results. */
   static StateError tooMany() => new StateError("Too many elements");
   /** Error thrown by, e.g., [List.setRange] if there are too few elements. */
   static StateError tooFew() => new StateError("Too few elements");
 }