Use metadata annotation @patch for patch classes

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.
 
-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);
   }
 
   /** Ensures that the buffer has enough capacity to add n code units. */
   void _ensureCapacity(int n) {
     if (_buffer == null) {
       _buffer = new Uint16List(_BUFFER_SIZE);
@@ skipping 53 matching lines @@
     _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";
 }