Fix new line breaks on }

test/dart_codegen/expect/_internal/iterable.dart

 part of dart._internal;
  abstract class EfficientLength {int get length;
 }
  abstract class ListIterable<E> extends IterableBase<E> 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++) {
+ for (int i = 0; i < length; i++) {
   action(elementAt(i));
    if (length != this.length) {
     throw new ConcurrentModificationError(this);
     }
   }
 }
  bool get isEmpty => length == 0;
  E get first {
 if (length == 0) throw IterableElementError.noElement();
  return elementAt(0);
 }
  E get last {
 if (length == 0) throw IterableElementError.noElement();
  return elementAt(length - 1);
 }
  E get single {
 if (length == 0) throw IterableElementError.noElement();
  if (length > 1) throw IterableElementError.tooMany();
  return elementAt(0);
 }
  bool contains(Object element) {
 int length = this.length;
- for (int i = 0;
- i < length;
- i++) {
+ for (int i = 0; i < length; i++) {
   if (elementAt(i) == element) return true;
    if (length != this.length) {
     throw new ConcurrentModificationError(this);
     }
   }
  return false;
 }
  bool every(bool test(E element)) {
 int length = this.length;
- for (int i = 0;
- i < length;
- i++) {
+ for (int i = 0; i < length; i++) {
   if (!test(elementAt(i))) return false;
    if (length != this.length) {
     throw new ConcurrentModificationError(this);
     }
   }
  return true;
 }
  bool any(bool test(E element)) {
 int length = this.length;
- for (int i = 0;
- i < length;
- i++) {
+ 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()}
 ) {
 int length = this.length;
- for (int i = 0;
- i < length;
- i++) {
+ 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()}
 ) {
 int length = this.length;
- for (int i = length - 1;
- i >= 0;
- i--) {
+ 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();
 }
  E singleWhere(bool test(E element)) {
 int length = this.length;
  E match = ((__x0) => DDC$RT.cast(__x0, Null, E, "CastLiteral", """line 125, column 15 of dart:_internal/iterable.dart: """, __x0 is E, false))(null);
  bool matchFound = false;
- for (int i = 0;
- i < length;
- i++) {
+ for (int i = 0; i < length; i++) {
   E element = elementAt(i);
    if (test(element)) {
     if (matchFound) {
       throw IterableElementError.tooMany();
       }
      matchFound = true;
      match = element;
     }
    if (length != this.length) {
     throw new ConcurrentModificationError(this);
     }
   }
  if (matchFound) return match;
  throw IterableElementError.noElement();
 }
  String join([String separator = ""]) {
 int length = this.length;
  if (!separator.isEmpty) {
   if (length == 0) return "";
-   String first = "${elementAt(0)}
-";
- if (length != this.length) {
-  throw new ConcurrentModificationError(this);
-  }
- StringBuffer buffer = new StringBuffer(first);
- for (int i = 1;
- i < length;
- i++) {
-  buffer.write(separator);
-   buffer.write(elementAt(i));
+   String first = "${elementAt(0)}";
    if (length != this.length) {
     throw new ConcurrentModificationError(this);
     }
+   StringBuffer buffer = new StringBuffer(first);
+   for (int i = 1; i < length; i++) {
+    buffer.write(separator);
+     buffer.write(elementAt(i));
+     if (length != this.length) {
+      throw new ConcurrentModificationError(this);
+      }
+    }
+   return buffer.toString();
   }
- return buffer.toString();
-}
  else {
-StringBuffer buffer = new StringBuffer();
- for (int i = 0;
- i < length;
- i++) {
-  buffer.write(elementAt(i));
-   if (length != this.length) {
-    throw new ConcurrentModificationError(this);
+  StringBuffer buffer = new StringBuffer();
+   for (int i = 0; i < length; i++) {
+    buffer.write(elementAt(i));
+     if (length != this.length) {
+      throw new ConcurrentModificationError(this);
+      }
     }
+   return buffer.toString();
   }
- return buffer.toString();
-}
 }
  Iterable<E> where(bool test(E element)) => super.where(test);
  Iterable map(f(E element)) => new MappedListIterable(this, f);
  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);
+ for (int i = 1; i < length; i++) {
+  value = combine(value, elementAt(i));
+   if (length != this.length) {
+    throw new ConcurrentModificationError(this);
+    }
   }
-}
  return value;
 }
  fold(var initialValue, combine(var 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);
+ 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> result;
  if (growable) {
-result = new List<E>()..length = length;
-}
+  result = new List<E>()..length = length;
+  }
  else {
-result = new List<E>(length);
-}
- for (int i = 0;
- i < length;
- i++) {
-result[i] = elementAt(i);
-}
+  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));
-}
+ for (int i = 0; i < length; i++) {
+  result.add(elementAt(i));
+  }
  return result;
 }
 }
  class SubListIterable<E> extends ListIterable<E> {final Iterable<E> _iterable;
  final int _start;
  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");
-}
+  throw new RangeError.range(_start, 0, _endOrLength, "start");
+  }
 }
 }
  int get _endIndex {
 int length = _iterable.length;
  if (_endOrLength == null || _endOrLength > length) return length;
  return _endOrLength;
 }
  int get _startIndex {
 int length = _iterable.length;
  if (_start > length) return length;
@@ skipping 35 matching lines @@
 }
  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);
- for (int i = 0;
- i < length;
- i++) {
+ for (int i = 0; i < length; i++) {
 result[i] = _iterable.elementAt(start + i);
  if (_iterable.length < end) throw new ConcurrentModificationError(this);
 }
  return DDC$RT.cast(result, DDC$RT.type((List<dynamic> _) {
 }
 ), DDC$RT.type((List<E> _) {
 }
 ), "CastDynamic", """line 310, column 12 of dart:_internal/iterable.dart: """, result is List<E>, false);
 }
 }
@@ skipping 210 matching lines @@
 int length = _iterable.length - _skipCount;
  if (length >= 0) return length;
  return 0;
 }
 }
  class SkipIterator<E> extends Iterator<E> {final Iterator<E> _iterator;
  int _skipCount;
  SkipIterator(this._iterator, this._skipCount) {
 assert (_skipCount is int && _skipCount >= 0);}
  bool moveNext() {
-for (int i = 0;
- i < _skipCount;
- i++) _iterator.moveNext();
+for (int i = 0; i < _skipCount; i++) _iterator.moveNext();
  _skipCount = 0;
  return _iterator.moveNext();
 }
  E get current => _iterator.current;
 }
  class SkipWhileIterable<E> extends IterableBase<E> {final Iterable<E> _iterable;
  final _ElementPredicate _f;
  SkipWhileIterable(this._iterable, bool this._f(E element));
  Iterator<E> get iterator {
 return new SkipWhileIterator<E>(_iterable.iterator, _f);
@@ skipping 119 matching lines @@
 }
  static dynamic fold(Iterable iterable, dynamic initialValue, dynamic combine(dynamic previousValue, element)) {
 for (final element in iterable) {
 initialValue = combine(initialValue, element);
 }
  return initialValue;
 }
  static void removeWhereList(List list, bool test(var element)) {
 List retained = [];
  int length = list.length;
- for (int i = 0;
- i < length;
- i++) {
+ 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);
 }
 }
  if (retained.length == length) return; list.length = retained.length;
- for (int i = 0;
- i < retained.length;
- i++) {
+ for (int i = 0; i < retained.length; i++) {
 list[i] = retained[i];
 }
 }
  static bool isEmpty(Iterable iterable) {
 return !iterable.iterator.moveNext();
 }
  static dynamic first(Iterable iterable) {
 Iterator it = iterable.iterator;
  if (!it.moveNext()) {
 throw IterableElementError.noElement();
@@ skipping 32 matching lines @@
 if (test(element)) {
 result = element;
  foundMatching = true;
 }
 }
  if (foundMatching) return result;
  if (orElse != null) return orElse();
  throw IterableElementError.noElement();
 }
  static dynamic lastWhereList(List list, bool test(dynamic value), dynamic orElse()) {
-for (int i = list.length - 1;
- i >= 0;
- i--) {
+for (int i = list.length - 1; i >= 0; i--) {
 dynamic element = list[i];
  if (test(element)) return element;
 }
  if (orElse != null) return orElse();
  throw IterableElementError.noElement();
 }
  static dynamic singleWhere(Iterable iterable, bool test(dynamic value)) {
 dynamic result = null;
  bool foundMatching = false;
  for (dynamic element in iterable) {
@@ skipping 18 matching lines @@
 }
  throw new RangeError.index(index, iterable, "index", null, elementIndex);
 }
  static String join(Iterable iterable, [String separator]) {
 StringBuffer buffer = new StringBuffer();
  buffer.writeAll(iterable, separator);
  return buffer.toString();
 }
  static String joinList(List list, [String separator]) {
 if (list.isEmpty) return "";
- if (list.length == 1) return "${list[0]}
-";
+ if (list.length == 1) return "${list[0]}";
  StringBuffer buffer = new StringBuffer();
  if (separator.isEmpty) {
-for (int i = 0;
- i < list.length;
- i++) {
+for (int i = 0; i < list.length; i++) {
 buffer.write(list[i]);
 }
 }
  else {
 buffer.write(list[0]);
- for (int i = 1;
- i < list.length;
- i++) {
+ for (int i = 1; i < list.length; i++) {
 buffer.write(separator);
  buffer.write(list[i]);
 }
 }
  return buffer.toString();
 }
  Iterable<T> where(Iterable iterable, bool f(var element)) {
 return new WhereIterable<T>(iterable, f);
 }
  static Iterable map(Iterable iterable, f(var element)) {
@@ skipping 97 matching lines @@
 int delta = insertLength - removeLength;
  int newLength = list.length + delta;
  int insertEnd = start + insertLength;
  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++) {
+ for (int i = start; i < end; i++) {
 list[i] = fillValue;
 }
 }
  static void insertAllList(List list, int index, Iterable iterable) {
 RangeError.checkValueInInterval(index, 0, list.length, "index");
  if (iterable is! EfficientLength) {
 iterable = iterable.toList(growable: false);
 }
  int insertionLength = iterable.length;
  list.length += insertionLength;
@@ skipping 48 matching lines @@
 }
  return result;
 }
 }
  abstract class IterableElementError {static StateError noElement() => new StateError("No element");
  static StateError tooMany() => new StateError("Too many elements");
  static StateError tooFew() => new StateError("Too few elements");
 }
  typedef int __t12(dynamic __u13, dynamic __u14);
  typedef int __t15(Comparable<dynamic> __u16, Comparable<dynamic> __u17);