Format all dart dev compiler files

pkg/dev_compiler/tool/input_sdk/patch/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.
 
 // Patch file for dart:collection classes.
 import 'dart:_foreign_helper' show JS;
-import 'dart:_js_helper' show
-    fillLiteralMap, InternalMap, NoInline, NoSideEffects, NoThrows, patch,
-    JsLinkedHashMap, LinkedHashMapCell, LinkedHashMapKeyIterable,
-    LinkedHashMapKeyIterator;
+import 'dart:_js_helper'
+    show
+        fillLiteralMap,
+        InternalMap,
+        NoInline,
+        NoSideEffects,
+        NoThrows,
+        patch,
+        JsLinkedHashMap,
+        LinkedHashMapCell,
+        LinkedHashMapKeyIterable,
+        LinkedHashMapKeyIterator;
 
 const _USE_ES6_MAPS = true;
 
 @patch
 class HashMap<K, V> {
   @patch
-  factory HashMap({ bool equals(K key1, K key2),
-                    int hashCode(K key),
-                    bool isValidKey(Object potentialKey) }) {
+  factory HashMap(
+      {bool equals(K key1, K key2),
+      int hashCode(K key),
+      bool isValidKey(Object 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>();
@@ skipping 33 matching lines @@
   var _rest;
 
   // When iterating over the hash map, it is very convenient to have a
   // list of all the keys. We cache that on the instance and clear the
   // the cache whenever the key set changes. This is also used to
   // guard against concurrent modifications.
   List/*<K>*/ _keys;
 
   _HashMap();
 
-
   int get length => _length;
   bool get isEmpty => _length == 0;
   bool get isNotEmpty => !isEmpty;
 
   Iterable<K> get keys {
     return new _HashMapKeyIterable<K>(this);
   }
 
   Iterable<V> get values {
     return new MappedIterable<K, V>(keys, (each) => this[each]);
@@ skipping 21 matching lines @@
   bool containsValue(Object value) {
     return _computeKeys().any((each) => this[each] == value);
   }
 
   void addAll(Map<K, V> other) {
     other.forEach((K key, V value) {
       this[key] = value;
     });
   }
 
-  V operator[](Object key) {
+  V operator [](Object key) {
     if (_isStringKey(key)) {
       var strings = _strings;
       return (strings == null) ? null : _getTableEntry(strings, key);
     } else if (_isNumericKey(key)) {
       var nums = _nums;
       return (nums == null) ? null : _getTableEntry(nums, key);
     } else {
       return _get(key);
     }
   }
 
   V _get(Object key) {
     var rest = _rest;
     if (rest == null) return null;
     var bucket = _getBucket(rest, key);
     int index = _findBucketIndex(bucket, key);
     return (index < 0) ? null : JS('var', '#[#]', bucket, index + 1);
   }
 
-  void operator[]=(K key, V value) {
+  void operator []=(K key, V value) {
     if (_isStringKey(key)) {
       var strings = _strings;
       if (strings == null) _strings = strings = _newHashTable();
       _addHashTableEntry(strings, key, value);
     } else if (_isNumericKey(key)) {
       var nums = _nums;
       if (nums == null) _nums = nums = _newHashTable();
       _addHashTableEntry(nums, key, value);
     } else {
       _set(key, value);
@@ skipping 236 matching lines @@
       if (identical(JS('var', '#[#]', bucket, i), key)) return i;
     }
     return -1;
   }
 }
 
 class _CustomHashMap<K, V> extends _HashMap<K, V> {
   final _Equality<K> _equals;
   final _Hasher<K> _hashCode;
   final _Predicate<Object> _validKey;
-  _CustomHashMap(this._equals, this._hashCode,
-                 bool validKey(Object potentialKey))
+  _CustomHashMap(
+      this._equals, this._hashCode, bool validKey(Object potentialKey))
       : _validKey = (validKey != null) ? validKey : ((v) => v is K);
 
-  V operator[](Object key) {
+  V operator [](Object key) {
     if (!_validKey(key)) return null;
     return super._get(key);
   }
 
-  void operator[]=(K key, V value) {
+  void operator []=(K key, V value) {
     super._set(key, value);
   }
 
   bool containsKey(Object key) {
     if (!_validKey(key)) return false;
     return super._containsKey(key);
   }
 
   V remove(Object key) {
     if (!_validKey(key)) return null;
@@ skipping 70 matching lines @@
       // get unnecessary bailout code.
       _offset = JS('int', '#', offset + 1);
       return true;
     }
   }
 }
 
 @patch
 class LinkedHashMap<K, V> {
   @patch
-  factory LinkedHashMap({ bool equals(K key1, K key2),
-                          int hashCode(K key),
-                          bool isValidKey(Object potentialKey) }) {
+  factory LinkedHashMap(
+      {bool equals(K key1, K key2),
+      int hashCode(K key),
+      bool isValidKey(Object potentialKey)}) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new JsLinkedHashMap<K, V>.es6();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _LinkedIdentityHashMap<K, V>.es6();
@@ skipping 41 matching lines @@
     if (bucket == null) return -1;
     int length = JS('int', '#.length', bucket);
     for (int i = 0; i < length; i++) {
       LinkedHashMapCell/*<K, V>*/ cell = JS('var', '#[#]', bucket, i);
       if (identical(cell.hashMapCellKey, key)) return i;
     }
     return -1;
   }
 }
 
-class _Es6LinkedIdentityHashMap<K, V>
-    extends _LinkedIdentityHashMap<K, V> implements InternalMap<K, V> {
+class _Es6LinkedIdentityHashMap<K, V> extends _LinkedIdentityHashMap<K, V>
+    implements InternalMap<K, V> {
   final _map;
   int _modifications = 0;
 
   _Es6LinkedIdentityHashMap() : _map = JS('var', 'new Map()');
 
   int get length => JS('int', '#.size', _map);
   bool get isEmpty => length == 0;
   bool get isNotEmpty => !isEmpty;
 
   Iterable<K> get keys => new _Es6MapIterable<K>(this, true);
 
-  Iterable<V> get values =>
-      new _Es6MapIterable<V>(this, false);
+  Iterable<V> get values => new _Es6MapIterable<V>(this, false);
 
   bool containsKey(Object key) {
     return JS('bool', '#.has(#)', _map, key);
   }
 
   bool containsValue(Object value) {
     return values.any((each) => each == value);
   }
 
   void addAll(Map<K, V> other) {
     other.forEach((K key, V value) {
       this[key] = value;
     });
   }
 
-  V operator[](Object key) {
+  V operator [](Object key) {
     return JS('var', '#.get(#)', _map, key);
   }
 
-  void operator[]=(K key, V value) {
+  void operator []=(K key, V value) {
     JS('var', '#.set(#, #)', _map, key, value);
     _modified();
   }
 
   V putIfAbsent(K key, V ifAbsent()) {
     if (containsKey(key)) return this[key];
     V value = ifAbsent();
     this[key] = value;
     return value;
   }
@@ skipping 109 matching lines @@
       return true;
     }
   }
 }
 
 // TODO(floitsch): use ES6 maps when available.
 class _LinkedCustomHashMap<K, V> extends JsLinkedHashMap<K, V> {
   final _Equality<K> _equals;
   final _Hasher<K> _hashCode;
   final _Predicate<Object> _validKey;
-  _LinkedCustomHashMap(this._equals, this._hashCode,
-                       bool validKey(Object potentialKey))
+  _LinkedCustomHashMap(
+      this._equals, this._hashCode, bool validKey(Object potentialKey))
       : _validKey = (validKey != null) ? validKey : ((v) => v is K);
 
-  V operator[](Object key) {
+  V operator [](Object key) {
     if (!_validKey(key)) return null;
     return super.internalGet(key);
   }
 
-  void operator[]=(K key, V value) {
+  void operator []=(K key, V value) {
     super.internalSet(key, value);
   }
 
   bool containsKey(Object key) {
     if (!_validKey(key)) return false;
     return super.internalContainsKey(key);
   }
 
   V remove(Object key) {
     if (!_validKey(key)) return null;
@@ skipping 14 matching lines @@
       LinkedHashMapCell/*<K, V>*/ cell = JS('var', '#[#]', bucket, i);
       if (_equals(cell.hashMapCellKey, key)) return i;
     }
     return -1;
   }
 }
 
 @patch
 class HashSet<E> {
   @patch
-  factory HashSet({ bool equals(E e1, E e2),
-                    int hashCode(E e),
-                    bool isValidKey(Object potentialKey) }) {
+  factory HashSet(
+      {bool equals(E e1, E e2),
+      int hashCode(E e),
+      bool isValidKey(Object 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>();
@@ skipping 309 matching lines @@
       if (identical(JS('var', '#[#]', bucket, i), element)) return i;
     }
     return -1;
   }
 }
 
 class _CustomHashSet<E> extends _HashSet<E> {
   _Equality<E> _equality;
   _Hasher<E> _hasher;
   _Predicate<Object> _validKey;
-  _CustomHashSet(this._equality, this._hasher,
-                 bool validKey(Object potentialKey))
+  _CustomHashSet(
+      this._equality, this._hasher, bool validKey(Object potentialKey))
       : _validKey = (validKey != null) ? validKey : ((x) => x is E);
 
   Set<E> _newSet() => new _CustomHashSet<E>(_equality, _hasher, _validKey);
 
   int _findBucketIndex(var bucket, var element) {
     if (bucket == null) return -1;
     int length = JS('int', '#.length', bucket);
     for (int i = 0; i < length; i++) {
       if (_equality(JS('var', '#[#]', bucket, i), element)) return i;
     }
@@ skipping 52 matching lines @@
       // get unnecessary bailout code.
       _offset = JS('int', '#', offset + 1);
       return true;
     }
   }
 }
 
 @patch
 class LinkedHashSet<E> {
   @patch
-  factory LinkedHashSet({ bool equals(E e1, E e2),
-                          int hashCode(E e),
-                          bool isValidKey(Object potentialKey) }) {
+  factory LinkedHashSet(
+      {bool equals(E e1, E e2),
+      int hashCode(E e),
+      bool isValidKey(Object potentialKey)}) {
     if (isValidKey == null) {
       if (hashCode == null) {
         if (equals == null) {
           return new _LinkedHashSet<E>();
         }
         hashCode = _defaultHashCode;
       } else {
         if (identical(identityHashCode, hashCode) &&
             identical(identical, equals)) {
           return new _LinkedIdentityHashSet<E>();
@@ skipping 165 matching lines @@
   }
 
   bool _remove(Object object) {
     var rest = _rest;
     if (rest == null) return false;
     var bucket = _getBucket(rest, object);
     int index = _findBucketIndex(bucket, object);
     if (index < 0) return false;
     // Use splice to remove the [cell] element at the index and
     // unlink it.
-    _LinkedHashSetCell/*<E>*/ cell = JS('var', '#.splice(#, 1)[0]', bucket, index);
+    _LinkedHashSetCell/*<E>*/ cell =
+        JS('var', '#.splice(#, 1)[0]', bucket, index);
     _unlinkCell(cell);
     return true;
   }
 
   void removeWhere(bool test(E element)) {
     _filterWhere(test, true);
   }
 
   void retainWhere(bool test(E element)) {
     _filterWhere(test, false);
@@ skipping 160 matching lines @@
       if (identical(cell._element, element)) return i;
     }
     return -1;
   }
 }
 
 class _LinkedCustomHashSet<E> extends _LinkedHashSet<E> {
   _Equality<E> _equality;
   _Hasher<E> _hasher;
   _Predicate<Object> _validKey;
-  _LinkedCustomHashSet(this._equality, this._hasher,
-                       bool validKey(Object potentialKey))
+  _LinkedCustomHashSet(
+      this._equality, this._hasher, bool validKey(Object potentialKey))
       : _validKey = (validKey != null) ? validKey : ((x) => x is E);
 
   Set<E> _newSet() =>
       new _LinkedCustomHashSet<E>(_equality, _hasher, _validKey);
 
   int _findBucketIndex(var bucket, var element) {
     if (bucket == null) return -1;
     int length = JS('int', '#.length', bucket);
     for (int i = 0; i < length; i++) {
       _LinkedHashSetCell/*<E>*/ cell = JS('var', '#[#]', bucket, i);
@@ skipping 71 matching lines @@
     } else if (_cell == null) {
       _current = null;
       return false;
     } else {
       _current = _cell._element;
       _cell = _cell._next;
       return true;
     }
   }
 }