dartfmt pkg/compiler

pkg/compiler/lib/src/helpers/debug_collection.dart

 // Copyright (c) 2014, 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.
 
-
 typedef void DebugCallback(String methodName, var arg1, var arg2);
 
 class DebugMap<K, V> implements Map<K, V> {
   final Map<K, V> map;
   DebugCallback indexSetCallBack;
   DebugCallback putIfAbsentCallBack;
 
   DebugMap(this.map, {DebugCallback addCallback}) {
     if (addCallback != null) {
       this.addCallback = addCallback;
@@ skipping 61 matching lines @@
   Iterable<E> where(bool test(E element)) => iterable.where(test);
 
   Iterable expand(Iterable f(E element)) => iterable.expand(f);
 
   bool contains(Object element) => iterable.contains(element);
 
   void forEach(void f(E element)) => iterable.forEach(f);
 
   E reduce(E combine(E value, E element)) => iterable.reduce(combine);
 
-  dynamic fold(var initialValue,
-               dynamic combine(var previousValue, E element)) {
+  dynamic fold(
+      var initialValue, dynamic combine(var previousValue, E element)) {
     return iterable.fold(initialValue, combine);
   }
 
   bool every(bool test(E element)) => iterable.every(test);
 
   String join([String separator = ""]) => iterable.join(separator);
 
   bool any(bool test(E element)) => iterable.any(test);
 
-  List<E> toList({ bool growable: true }) {
+  List<E> toList({bool growable: true}) {
     return iterable.toList(growable: growable);
   }
 
   Set<E> toSet() => iterable.toSet();
 
   int get length => iterable.length;
 
   bool get isEmpty => iterable.isEmpty;
 
   bool get isNotEmpty => iterable.isNotEmpty;
 
   Iterable<E> take(int n) => iterable.take(n);
 
   Iterable<E> takeWhile(bool test(E value)) => iterable.takeWhile(test);
 
   Iterable<E> skip(int n) => iterable.skip(n);
 
   Iterable<E> skipWhile(bool test(E value)) => iterable.skipWhile(test);
 
   E get first => iterable.first;
 
   E get last => iterable.last;
 
   E get single => iterable.single;
 
-  E firstWhere(bool test(E element), { E orElse() }) {
+  E firstWhere(bool test(E element), {E orElse()}) {
     return iterable.firstWhere(test, orElse: orElse);
   }
 
   E lastWhere(bool test(E element), {E orElse()}) {
     return iterable.lastWhere(test, orElse: orElse);
   }
 
   E singleWhere(bool test(E element)) => iterable.singleWhere(test);
 
   E elementAt(int index) => iterable.elementAt(index);
-
 }
 
 class DebugList<E> extends DebugIterable<E> implements List<E> {
   DebugCallback addCallback;
 
   DebugList(List<E> list, {this.addCallback}) : super(list);
 
   List<E> get list => iterable;
 
   E operator [](int index) => list[index];
@@ skipping 115 matching lines @@
   Set<E> toSet() => set.toSet();
 }
 
 /// Throws an exception if the runtime type of [object] is not in
 /// [runtimeTypes].
 ///
 /// Use this to gradually build the set of actual runtime values of [object]
 /// at the call site by running test programs and adding to [runtimeTypes] when
 /// new type are found.
 void assertType(String name, List<String> runtimeTypes, var object,
-                {bool showObjects: false}) {
+    {bool showObjects: false}) {
   String runtimeType = '${object.runtimeType}';
   if (runtimeTypes != null && runtimeTypes.contains(runtimeType)) return;
   throw '$name: $runtimeType'
-        '${showObjects ? ' ($object)' : ''}';
+      '${showObjects ? ' ($object)' : ''}';
 }
 
 /// Callback for the [addCallback] of [DebugMap] that throws an exception if
 /// the runtime type of key/value pairs are not in [runtimeTypes].
 ///
 /// Use this to gradually build the set of actual runtime values of key/value
 /// pairs of a map by running test programs and adding to [runtimeTypes] when
 /// new type are found.
 class MapTypeAsserter {
   final String name;
   final Map<String, List<String>> runtimeTypes;
   final bool showObjects;
 
   const MapTypeAsserter(this.name, this.runtimeTypes,
-                       {bool this.showObjects: false});
+      {bool this.showObjects: false});
 
   void call(String methodName, var key, var value) {
     check(key, value, '$methodName: ');
   }
 
   void check(var key, var value, [String text = '']) {
     String keyType = '${key.runtimeType}';
     String valueType = '${value.runtimeType}';
     List<String> valuesTypes = runtimeTypes[keyType];
     if (valuesTypes != null && valuesTypes.contains(valueType)) return;
     throw '$name: $text$keyType => $valueType'
-          '${showObjects ? ' ($key => $value)' : ''}';
+        '${showObjects ? ' ($key => $value)' : ''}';
   }
 }
 
 /// Callback for the [addCallback] of [DebugSet] or [DebugList]  that throws an
 /// exception if the runtime type of the elements are not in [runtimeTypes].
 ///
 /// Use this to gradually build the set of actual runtime values of the elements
 /// of a collection by running test programs and adding to [runtimeTypes] when
 /// new type are found.
 class CollectionTypeAsserter {
   final String name;
   final List<String> runtimeTypes;
   final bool showObjects;
 
   const CollectionTypeAsserter(this.name, this.runtimeTypes,
-                       {bool this.showObjects: false});
+      {bool this.showObjects: false});
 
   void call(String methodName, var element, _) {
     check(element, '$methodName: ');
   }
 
   void check(var element, [String text = '']) {
     String elementType = '${element.runtimeType}';
     if (runtimeTypes.contains(elementType)) return;
     throw '$name: $text$elementType'
-          '${showObjects ? ' ($element)' : ''}';
+        '${showObjects ? ' ($element)' : ''}';
   }
 }