Run dartfmt on all files under runtime.

runtime/lib/collection_patch.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.
 
 import 'dart:typed_data';
 import 'dart:_internal' as internal;
 
-@patch class HashMap<K, V> {
-  @patch factory HashMap({ bool equals(K key1, K key2),
-                           int hashCode(K key),
-                           bool isValidKey(potentialKey) }) {
+@patch
+class HashMap<K, V> {
+  @patch
+  factory HashMap(
+      {bool equals(K key1, K key2),
+      int hashCode(K key),
+      bool isValidKey(potentialKey)}) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _HashMap<K, V>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _IdentityHashMap<K, V>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
 
-  @patch factory HashMap.identity() = _IdentityHashMap<K, V>;
+  @patch
+  factory HashMap.identity() = _IdentityHashMap<K, V>;
 
   Set<K> _newKeySet();
 }
 
-
 const int _MODIFICATION_COUNT_MASK = 0x3fffffff;
 
 class _HashMap<K, V> implements HashMap<K, V> {
   static const int _INITIAL_CAPACITY = 8;
 
-
   int _elementCount = 0;
   List<_HashMapEntry> _buckets = new List(_INITIAL_CAPACITY);
   int _modificationCount = 0;
 
   int get length => _elementCount;
   bool get isEmpty => _elementCount == 0;
   bool get isNotEmpty => _elementCount != 0;
 
   Iterable<K> get keys => new _HashMapKeyIterable<K>(this);
   Iterable<V> get values => new _HashMapValueIterable<V>(this);
@@ skipping 16 matching lines @@
     for (int i = 0; i < length; i++) {
       _HashMapEntry entry = buckets[i];
       while (entry != null) {
         if (entry.value == value) return true;
         entry = entry.next;
       }
     }
     return false;
   }
 
-  V operator[](Object key) {
+  V operator [](Object key) {
     int hashCode = key.hashCode;
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && entry.key == key) {
         return entry.value;
       }
       entry = entry.next;
     }
@@ skipping 82 matching lines @@
   }
 
   void clear() {
     _buckets = new List(_INITIAL_CAPACITY);
     if (_elementCount > 0) {
       _elementCount = 0;
       _modificationCount = (_modificationCount + 1) & _MODIFICATION_COUNT_MASK;
     }
   }
 
-  void _removeEntry(_HashMapEntry entry,
-                    _HashMapEntry previousInBucket,
-                    int bucketIndex) {
+  void _removeEntry(
+      _HashMapEntry entry, _HashMapEntry previousInBucket, int bucketIndex) {
     if (previousInBucket == null) {
       _buckets[bucketIndex] = entry.next;
     } else {
       previousInBucket.next = entry.next;
     }
   }
 
-  void _addEntry(List buckets, int index, int length,
-                 K key, V value, int hashCode) {
+  void _addEntry(
+      List buckets, int index, int length, K key, V value, int hashCode) {
     _HashMapEntry entry =
         new _HashMapEntry(key, value, hashCode, buckets[index]);
     buckets[index] = entry;
     int newElements = _elementCount + 1;
     _elementCount = newElements;
     // If we end up with more than 75% non-empty entries, we
     // resize the backing store.
     if ((newElements << 2) > ((length << 1) + length)) _resize();
     _modificationCount = (_modificationCount + 1) & _MODIFICATION_COUNT_MASK;
   }
@@ skipping 22 matching lines @@
   Set<K> _newKeySet() => new _HashSet<K>();
 }
 
 class _CustomHashMap<K, V> extends _HashMap<K, V> {
   final _Equality<K> _equals;
   final _Hasher<K> _hashCode;
   final _Predicate _validKey;
   _CustomHashMap(this._equals, this._hashCode, validKey)
       : _validKey = (validKey != null) ? validKey : new _TypeTest<K>().test;
 
-
   bool containsKey(Object key) {
     if (!_validKey(key)) return false;
     int hashCode = _hashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && _equals(entry.key, key)) return true;
       entry = entry.next;
     }
     return false;
   }
 
-  V operator[](Object key) {
+  V operator [](Object key) {
     if (!_validKey(key)) return null;
     int hashCode = _hashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && _equals(entry.key, key)) {
         return entry.value;
       }
       entry = entry.next;
@@ skipping 60 matching lines @@
     }
     return null;
   }
 
   String toString() => Maps.mapToString(this);
 
   Set<K> _newKeySet() => new _CustomHashSet<K>(_equals, _hashCode, _validKey);
 }
 
 class _IdentityHashMap<K, V> extends _HashMap<K, V> {
-
   bool containsKey(Object key) {
     int hashCode = identityHashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && identical(entry.key, key)) return true;
       entry = entry.next;
     }
     return false;
   }
 
-  V operator[](Object key) {
+  V operator [](Object key) {
     int hashCode = identityHashCode(key);
     List buckets = _buckets;
     int index = hashCode & (buckets.length - 1);
     _HashMapEntry entry = buckets[index];
     while (entry != null) {
       if (hashCode == entry.hashCode && identical(entry.key, key)) {
         return entry.value;
       }
       entry = entry.next;
     }
@@ skipping 57 matching lines @@
       entry = next;
     }
     return null;
   }
 
   String toString() => Maps.mapToString(this);
 
   Set<K> _newKeySet() => new _IdentityHashSet<K>();
 }
 
-
 class _HashMapEntry {
   final key;
   var value;
   final int hashCode;
   _HashMapEntry next;
   _HashMapEntry(this.key, this.value, this.hashCode, this.next);
 }
 
 abstract class _HashMapIterable<E> extends EfficientLengthIterable<E> {
   final HashMap _map;
   _HashMapIterable(this._map);
   int get length => _map.length;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
 }
 
 class _HashMapKeyIterable<K> extends _HashMapIterable<K> {
   _HashMapKeyIterable(HashMap map) : super(map);
   Iterator<K> get iterator => new _HashMapKeyIterator<K>(_map);
   bool contains(Object key) => _map.containsKey(key);
   void forEach(void action(K key)) {
     _map.forEach((K key, _) {
       action(key);
     });
   }
+
   Set<K> toSet() => _map._newKeySet()..addAll(this);
 }
 
 class _HashMapValueIterable<V> extends _HashMapIterable<V> {
   _HashMapValueIterable(HashMap map) : super(map);
   Iterator<V> get iterator => new _HashMapValueIterator<V>(_map);
   bool contains(Object value) => _map.containsValue(value);
   void forEach(void action(V value)) {
     _map.forEach((_, V value) {
       action(value);
     });
   }
 }
 
 abstract class _HashMapIterator<E> implements Iterator<E> {
   final HashMap _map;
   final int _stamp;
 
   int _index = 0;
   _HashMapEntry _entry;
 
   _HashMapIterator(HashMap map)
-     : _map = map, _stamp = map._modificationCount;
+      : _map = map,
+        _stamp = map._modificationCount;
 
   bool moveNext() {
     if (_stamp != _map._modificationCount) {
       throw new ConcurrentModificationError(_map);
     }
     _HashMapEntry entry = _entry;
     if (entry != null) {
       _HashMapEntry next = entry.next;
       if (next != null) {
         _entry = next;
@@ skipping 25 matching lines @@
 }
 
 class _HashMapValueIterator<V> extends _HashMapIterator<V> {
   _HashMapValueIterator(HashMap map) : super(map);
   V get current {
     _HashMapEntry entry = _entry;
     return (entry == null) ? null : entry.value;
   }
 }
 
-@patch class HashSet<E> {
-  @patch factory HashSet({ bool equals(E e1, E e2),
-                           int hashCode(E e),
-                           bool isValidKey(potentialKey) }) {
+@patch
+class HashSet<E> {
+  @patch
+  factory HashSet(
+      {bool equals(E e1, E e2),
+      int hashCode(E e),
+      bool isValidKey(potentialKey)}) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _HashSet<E>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _IdentityHashSet<E>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CustomHashSet<E>(equals, hashCode, isValidKey);
   }
 
-  @patch factory HashSet.identity() = _IdentityHashSet<E>;
+  @patch
+  factory HashSet.identity() = _IdentityHashSet<E>;
 }
 
 class _HashSet<E> extends _HashSetBase<E> implements HashSet<E> {
   static const int _INITIAL_CAPACITY = 8;
 
   List<_HashSetEntry> _buckets = new List(_INITIAL_CAPACITY);
   int _elementCount = 0;
   int _modificationCount = 0;
 
   bool _equals(e1, e2) => e1 == e2;
@@ skipping 78 matching lines @@
   bool remove(Object object) => _remove(object, _hashCode(object));
 
   void removeAll(Iterable<Object> objectsToRemove) {
     for (Object object in objectsToRemove) {
       _remove(object, _hashCode(object));
     }
   }
 
   void _filterWhere(bool test(E element), bool removeMatching) {
     int length = _buckets.length;
-    for (int index =  0; index < length; index++) {
+    for (int index = 0; index < length; index++) {
       _HashSetEntry entry = _buckets[index];
       _HashSetEntry previous = null;
       while (entry != null) {
         int modificationCount = _modificationCount;
         bool testResult = test(entry.key);
         if (modificationCount != _modificationCount) {
           throw new ConcurrentModificationError(this);
         }
         if (testResult == removeMatching) {
           _HashSetEntry next = entry.remove();
@@ skipping 125 matching lines @@
 }
 
 class _HashSetIterator<E> implements Iterator<E> {
   final _HashSet _set;
   final int _modificationCount;
   int _index = 0;
   _HashSetEntry _next;
   E _current;
 
   _HashSetIterator(_HashSet hashSet)
-      : _set = hashSet, _modificationCount = hashSet._modificationCount;
+      : _set = hashSet,
+        _modificationCount = hashSet._modificationCount;
 
   bool moveNext() {
     if (_modificationCount != _set._modificationCount) {
       throw new ConcurrentModificationError(_set);
     }
     if (_next != null) {
       _current = _next.key;
       _next = _next.next;
       return true;
     }
@@ skipping 14 matching lines @@
   E get current => _current;
 }
 
 class _LinkedHashMapEntry extends _HashMapEntry {
   /// Double-linked list of entries of a linked hash map.
   /// The _LinkedHashMap itself is the head of the list, so the type is "var".
   /// Both are initialized to `this` when initialized.
   var _nextEntry;
   var _previousEntry;
   _LinkedHashMapEntry(key, value, int hashCode, _LinkedHashMapEntry next,
-                      this._previousEntry, this._nextEntry)
+      this._previousEntry, this._nextEntry)
       : super(key, value, hashCode, next) {
     _previousEntry._nextEntry = this;
     _nextEntry._previousEntry = this;
   }
 }
 
 class _LinkedHashMapKeyIterable<K> extends EfficientLengthIterable<K> {
   LinkedHashMap<K, dynamic> _map;
   _LinkedHashMapKeyIterable(this._map);
   Iterator<K> get iterator => new _LinkedHashMapKeyIterator<K>(_map);
@@ skipping 46 matching lines @@
 class _LinkedHashMapKeyIterator<K> extends _LinkedHashMapIterator<K> {
   _LinkedHashMapKeyIterator(LinkedHashMap map) : super(map);
   K _getValue(_LinkedHashMapEntry entry) => entry.key;
 }
 
 class _LinkedHashMapValueIterator<V> extends _LinkedHashMapIterator<V> {
   _LinkedHashMapValueIterator(LinkedHashMap map) : super(map);
   V _getValue(_LinkedHashMapEntry entry) => entry.value;
 }
 
-
 /**
  * A hash-based map that iterates keys and values in key insertion order.
  */
-@patch class LinkedHashMap<K, V> {
+@patch
+class LinkedHashMap<K, V> {
   /// Holds a double-linked list of entries in insertion order.
   /// The fields have the same name as the ones in [_LinkedHashMapEntry],
   /// and this map is itself used as the head entry of the list.
   /// Set to `this` when initialized, representing the empty list (containing
   /// only the head entry itself).
   var _nextEntry;
   var _previousEntry;
 
-  @patch factory LinkedHashMap({ bool equals(K key1, K key2),
-                                       int hashCode(K key),
-                                       bool isValidKey(potentialKey) }) {
+  @patch
+  factory LinkedHashMap(
+      {bool equals(K key1, K key2),
+      int hashCode(K key),
+      bool isValidKey(potentialKey)}) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _InternalLinkedHashMap<K, V>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _CompactLinkedIdentityHashMap<K, V>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CompactLinkedCustomHashMap<K, V>(equals, hashCode, isValidKey);
   }
 
-  @patch factory LinkedHashMap.identity() =
-      _CompactLinkedIdentityHashMap<K, V>;
+  @patch
+  factory LinkedHashMap.identity() = _CompactLinkedIdentityHashMap<K, V>;
 }
 
-@patch class LinkedHashSet<E> {
-  @patch factory LinkedHashSet({ bool equals(E e1, E e2),
-                                       int hashCode(E e),
-                                       bool isValidKey(potentialKey) }) {
+@patch
+class LinkedHashSet<E> {
+  @patch
+  factory LinkedHashSet(
+      {bool equals(E e1, E e2),
+      int hashCode(E e),
+      bool isValidKey(potentialKey)}) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _CompactLinkedHashSet<E>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _CompactLinkedIdentityHashSet<E>();
         }
         if (equals == null) {
           equals = _defaultEquals;
         }
       }
     } else {
       if (hashCode == null) {
         hashCode = _defaultHashCode;
       }
       if (equals == null) {
         equals = _defaultEquals;
       }
     }
     return new _CompactLinkedCustomHashSet<E>(equals, hashCode, isValidKey);
   }
 
-  @patch factory LinkedHashSet.identity() =
-      _CompactLinkedIdentityHashSet<E>;
+  @patch
+  factory LinkedHashSet.identity() = _CompactLinkedIdentityHashSet<E>;
 }