Format all dart dev compiler files

pkg/dev_compiler/tool/input_sdk/patch/convert_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:convert library.
 
 import 'dart:_js_helper' show argumentErrorValue, patch;
 import 'dart:_foreign_helper' show JS;
 import 'dart:_interceptors' show JSExtendableArray;
 import 'dart:_internal' show MappedIterable, ListIterable;
@@ skipping 15 matching lines @@
  *
  * Throws [FormatException] if the input is not valid JSON text.
  */
 @patch
 _parseJson(String source, reviver(key, value)) {
   if (source is! String) throw argumentErrorValue(source);
 
   var parsed;
   try {
     parsed = JS('=Object|JSExtendableArray|Null|bool|num|String',
-                'JSON.parse(#)',
-                source);
+        'JSON.parse(#)', source);
   } catch (e) {
     throw new FormatException(JS('String', 'String(#)', e));
   }
 
   if (reviver == null) {
     return _convertJsonToDartLazy(parsed);
   } else {
     return _convertJsonToDart(parsed, reviver);
   }
 }
@@ skipping 33 matching lines @@
     _JsonMap map = new _JsonMap(e);
     var processed = map._processed;
     List<String> keys = map._computeKeys();
     for (int i = 0; i < keys.length; i++) {
       String key = keys[i];
       var revived = reviver(key, walk(JS('', '#[#]', e, key)));
       JS('', '#[#]=#', processed, key, revived);
     }
 
     // Update the JSON map structure so future access is cheaper.
-    map._original = processed;  // Don't keep two objects around.
+    map._original = processed; // Don't keep two objects around.
     return map;
   }
 
   return reviver(null, walk(json));
 }
 
 _convertJsonToDartLazy(object) {
   // JavaScript null and undefined are represented as null.
   if (object == null) return null;
 
@@ skipping 31 matching lines @@
   // We keep track of the map entries that we have already
   // processed by adding them to a separate JavaScript object.
   var _processed = _newJavaScriptObject();
 
   // If the data slot isn't null, it represents either the list
   // of keys (for non-upgraded JSON maps) or the upgraded map.
   var _data = null;
 
   _JsonMap(this._original);
 
-  operator[](key) {
+  operator [](key) {
     if (_isUpgraded) {
       return _upgradedMap[key];
-    } else if (key is !String) {
+    } else if (key is! String) {
       return null;
     } else {
       var result = _getProperty(_processed, key);
       if (_isUnprocessed(result)) result = _process(key);
       return result;
     }
   }
 
-  int get length => _isUpgraded
-      ? _upgradedMap.length
-      : _computeKeys().length;
+  int get length => _isUpgraded ? _upgradedMap.length : _computeKeys().length;
 
   bool get isEmpty => length == 0;
   bool get isNotEmpty => length > 0;
 
   Iterable get keys {
     if (_isUpgraded) return _upgradedMap.keys;
     return new _JsonMapKeyIterable(this);
   }
 
   Iterable get values {
     if (_isUpgraded) return _upgradedMap.values;
     return new MappedIterable(_computeKeys(), (each) => this[each]);
   }
 
-  operator[]=(key, value) {
+  operator []=(key, value) {
     if (_isUpgraded) {
       _upgradedMap[key] = value;
     } else if (containsKey(key)) {
       var processed = _processed;
       _setProperty(processed, key, value);
       var original = _original;
       if (!identical(original, processed)) {
-        _setProperty(original, key, null);  // Reclaim memory.
+        _setProperty(original, key, null); // Reclaim memory.
       }
     } else {
       _upgrade()[key] = value;
     }
   }
 
   void addAll(Map other) {
     other.forEach((key, value) {
       this[key] = value;
     });
   }
 
   bool containsValue(value) {
     if (_isUpgraded) return _upgradedMap.containsValue(value);
     List<String> keys = _computeKeys();
     for (int i = 0; i < keys.length; i++) {
       String key = keys[i];
       if (this[key] == value) return true;
     }
     return false;
   }
 
   bool containsKey(key) {
     if (_isUpgraded) return _upgradedMap.containsKey(key);
-    if (key is !String) return false;
+    if (key is! String) return false;
     return _hasProperty(_original, key);
   }
 
   putIfAbsent(key, ifAbsent()) {
     if (containsKey(key)) return this[key];
     var value = ifAbsent();
     this[key] = value;
     return value;
   }
 
@@ skipping 37 matching lines @@
       // Check if invoking the callback function changed
       // the key set. If so, throw an exception.
       if (!identical(keys, _data)) {
         throw new ConcurrentModificationError(this);
       }
     }
   }
 
   String toString() => Maps.mapToString(this);
 
-
   // ------------------------------------------
   // Private helper methods.
   // ------------------------------------------
 
   bool get _isUpgraded => _processed == null;
 
   Map get _upgradedMap {
     assert(_isUpgraded);
     // 'cast' the union type to LinkedHashMap.  It would be even better if we
     // could 'cast' to the implementation type, since LinkedHashMap includes
@@ skipping 38 matching lines @@
     assert(_isUpgraded);
     return result;
   }
 
   _process(String key) {
     if (!_hasProperty(_original, key)) return null;
     var result = _convertJsonToDartLazy(_getProperty(_original, key));
     return _setProperty(_processed, key, result);
   }
 
-
   // ------------------------------------------
   // Private JavaScript helper methods.
   // ------------------------------------------
 
-  static bool _hasProperty(object, String key)
-      => JS('bool', 'Object.prototype.hasOwnProperty.call(#,#)', object, key);
-  static _getProperty(object, String key)
-      => JS('', '#[#]', object, key);
-  static _setProperty(object, String key, value)
-      => JS('', '#[#]=#', object, key, value);
-  static List _getPropertyNames(object)
-      => JS('JSExtendableArray', 'Object.keys(#)', object);
-  static bool _isUnprocessed(object)
-      => JS('bool', 'typeof(#)=="undefined"', object);
-  static _newJavaScriptObject()
-      => JS('=Object', 'Object.create(null)');
+  static bool _hasProperty(object, String key) =>
+      JS('bool', 'Object.prototype.hasOwnProperty.call(#,#)', object, key);
+  static _getProperty(object, String key) => JS('', '#[#]', object, key);
+  static _setProperty(object, String key, value) =>
+      JS('', '#[#]=#', object, key, value);
+  static List _getPropertyNames(object) =>
+      JS('JSExtendableArray', 'Object.keys(#)', object);
+  static bool _isUnprocessed(object) =>
+      JS('bool', 'typeof(#)=="undefined"', object);
+  static _newJavaScriptObject() => JS('=Object', 'Object.create(null)');
 }
 
 class _JsonMapKeyIterable extends ListIterable {
   final _JsonMap _parent;
 
   _JsonMapKeyIterable(this._parent);
 
   int get length => _parent.length;
 
   String elementAt(int index) {
-    return _parent._isUpgraded ? _parent.keys.elementAt(index)
-                               : _parent._computeKeys()[index];
+    return _parent._isUpgraded
+        ? _parent.keys.elementAt(index)
+        : _parent._computeKeys()[index];
   }
 
   /// Although [ListIterable] defines its own iterator, we return the iterator
   /// of the underlying list [_keys] in order to propagate
   /// [ConcurrentModificationError]s.
   Iterator get iterator {
-    return _parent._isUpgraded ? _parent.keys.iterator
-                               : _parent._computeKeys().iterator;
+    return _parent._isUpgraded
+        ? _parent.keys.iterator
+        : _parent._computeKeys().iterator;
   }
 
   /// Delegate to [parent.containsKey] to ensure the performance expected
   /// from [Map.keys.containsKey].
   bool contains(Object key) => _parent.containsKey(key);
 }
 
-@patch class JsonDecoder {
+@patch
+class JsonDecoder {
   @patch
   StringConversionSink startChunkedConversion(Sink<Object> sink) {
     return new _JsonDecoderSink(_reviver, sink);
   }
 }
 
 /**
  * Implements the chunked conversion from a JSON string to its corresponding
  * object.
  *
  * The sink only creates one object, but its input can be chunked.
  */
 // TODO(floitsch): don't accumulate everything before starting to decode.
 class _JsonDecoderSink extends _StringSinkConversionSink {
   final _Reviver _reviver;
   final Sink<Object> _sink;
 
-  _JsonDecoderSink(this._reviver, this._sink)
-      : super(new StringBuffer());
+  _JsonDecoderSink(this._reviver, this._sink) : super(new StringBuffer());
 
   void close() {
     super.close();
     StringBuffer buffer = _stringSink;
     String accumulated = buffer.toString();
     buffer.clear();
     Object decoded = _parseJson(accumulated, _reviver);
     _sink.add(decoded);
     _sink.close();
   }
 }
 
-@patch class Utf8Decoder {
+@patch
+class Utf8Decoder {
   @patch
-  Converter<List<int>, dynamic/*=T*/> fuse/*<T>*/(
-      Converter<String, dynamic/*=T*/> next) {
+  Converter<List<int>, dynamic/*=T*/ > fuse/*<T>*/(
+      Converter<String, dynamic/*=T*/ > next) {
     return super.fuse/*<T>*/(next);
   }
 
   // Currently not intercepting UTF8 decoding.
   @patch
-  static String _convertIntercepted(bool allowMalformed, List<int> codeUnits,
-                                    int start, int end) {
-    return null;  // This call was not intercepted.
+  static String _convertIntercepted(
+      bool allowMalformed, List<int> codeUnits, int start, int end) {
+    return null; // This call was not intercepted.
   }
 }