Run dartfmt on all files under runtime.

runtime/lib/string_buffer_patch.dart

 // Copyright (c) 2012, 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' show Uint16List;
 
-@patch class StringBuffer {
+@patch
+class StringBuffer {
   static const int _BUFFER_SIZE = 64;
   static const int _PARTS_TO_COMPACT = 128;
   static const int _PARTS_TO_COMPACT_SIZE_LIMIT = _PARTS_TO_COMPACT * 8;
 
   /**
    * When strings are written to the string buffer, we add them to a
    * list of string parts.
    */
   List<String> _parts;
 
@@ skipping 25 matching lines @@
    * Collects the approximate maximal magnitude of the code units added
    * to the buffer.
    *
    * The value of each added code unit is or'ed with this variable, so the
    * most significant bit set in any code unit is also set in this value.
    * If below 256, the string in the buffer is a Latin-1 string.
    */
   int _bufferCodeUnitMagnitude = 0;
 
   /// Creates the string buffer with an initial content.
-  @patch StringBuffer([Object content = ""]) {
+  @patch
+  StringBuffer([Object content = ""]) {
     write(content);
   }
 
-  @patch int get length => _partsCodeUnits + _bufferPosition;
+  @patch
+  int get length => _partsCodeUnits + _bufferPosition;
 
-  @patch void write(Object obj) {
+  @patch
+  void write(Object obj) {
     String str = '$obj';
     if (str.isEmpty) return;
     _consumeBuffer();
     _addPart(str);
   }
 
-  @patch void writeCharCode(int charCode) {
+  @patch
+  void writeCharCode(int charCode) {
     if (charCode <= 0xFFFF) {
       if (charCode < 0) {
         throw new RangeError.range(charCode, 0, 0x10FFFF);
       }
       _ensureCapacity(1);
       _buffer[_bufferPosition++] = charCode;
       _bufferCodeUnitMagnitude |= charCode;
     } else {
       if (charCode > 0x10FFFF) {
         throw new RangeError.range(charCode, 0, 0x10FFFF);
       }
       _ensureCapacity(2);
       int bits = charCode - 0x10000;
       _buffer[_bufferPosition++] = 0xD800 | (bits >> 10);
       _buffer[_bufferPosition++] = 0xDC00 | (bits & 0x3FF);
       _bufferCodeUnitMagnitude |= 0xFFFF;
     }
   }
 
-  @patch void writeAll(Iterable objects, [String separator = ""]) {
+  @patch
+  void writeAll(Iterable objects, [String separator = ""]) {
     Iterator iterator = objects.iterator;
     if (!iterator.moveNext()) return;
     if (separator.isEmpty) {
       do {
         write(iterator.current);
       } while (iterator.moveNext());
     } else {
       write(iterator.current);
       while (iterator.moveNext()) {
         write(separator);
         write(iterator.current);
       }
     }
   }
 
-  @patch void writeln([Object obj = ""]) {
+  @patch
+  void writeln([Object obj = ""]) {
     write(obj);
     write("\n");
   }
 
   /** Makes the buffer empty. */
-  @patch void clear() {
+  @patch
+  void clear() {
     _parts = null;
     _partsCodeUnits = _bufferPosition = _bufferCodeUnitMagnitude = 0;
   }
 
   /** Returns the contents of buffer as a string. */
-  @patch String toString() {
+  @patch
+  String toString() {
     _consumeBuffer();
-    return (_partsCodeUnits == 0) ?
-        "" :
-        _StringBase._concatRange(_parts, 0, _parts.length);
+    return (_partsCodeUnits == 0)
+        ? ""
+        : _StringBase._concatRange(_parts, 0, _parts.length);
   }
 
   /** Ensures that the buffer has enough capacity to add n code units. */
   void _ensureCapacity(int n) {
     if (_buffer == null) {
       _buffer = new Uint16List(_BUFFER_SIZE);
     } else if (_bufferPosition + n > _buffer.length) {
       _consumeBuffer();
     }
   }
@@ skipping 33 matching lines @@
   }
 
   /**
    * Compacts the last N parts if their average size allows us to save a
    * lot of memory by turning them all into a single part.
    */
   void _compact() {
     if (_partsCodeUnitsSinceCompaction < _PARTS_TO_COMPACT_SIZE_LIMIT) {
       String compacted = _StringBase._concatRange(
           _parts,
-          _partsCompactionIndex,                     // Start
-          _partsCompactionIndex + _PARTS_TO_COMPACT  // End
-      );
+          _partsCompactionIndex, // Start
+          _partsCompactionIndex + _PARTS_TO_COMPACT // End
+          );
       _parts.length = _parts.length - _PARTS_TO_COMPACT;
       _parts.add(compacted);
     }
     _partsCodeUnitsSinceCompaction = 0;
     _partsCompactionIndex = _parts.length;
   }
 
   /**
    * Create a [String] from the UFT-16 code units in buffer.
    */
   static String _create(Uint16List buffer, int length, bool isLatin1)
       native "StringBuffer_createStringFromUint16Array";
 }