cleanup patch generation to preseve comments and remove @patch

test/generated_sdk/lib/core/list.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.
 
 part of dart.core;
 
 /**
  * An indexable collection of objects with a length.
  *
  * Subclasses of this class implement different kinds of lists.
@@ skipping 34 matching lines @@
  * does not detect it.
  *
  * It is generally not allowed to modify the list's length (adding or removing
  * elements) while an operation on the list is being performed,
  * for example during a call to [forEach] or [sort].
  * Changing the list's length while it is being iterated, either by iterating it
  * directly or through iterating an [Iterable] that is backed by the list, will
  * break the iteration.
  */
 abstract class List<E> implements Iterable<E>, EfficientLength {
-  @patch
+  /**
+   * Creates a list of the given length.
+   *
+   * The created list is fixed-length if [length] is provided.
+   *
+   *     List fixedLengthList = new List(3);
+   *     fixedLengthList.length;     // 3
+   *     fixedLengthList.length = 1; // Error
+   *
+   * The list has length 0 and is growable if [length] is omitted.
+   *
+   *     List growableList = new List();
+   *     growableList.length; // 0;
+   *     growableList.length = 3;
+   *
+   * To create a growable list with a given length, just assign the length
+   * right after creation:
+   *
+   *     List growableList = new List()..length = 500;
+   *
+   * The [length] must not be negative or null, if it is provided.
+   */
   factory List([int length = const _ListConstructorSentinel()]) {
     if (length == const _ListConstructorSentinel()) {
       return new JSArray<E>.emptyGrowable();
     }
     return new JSArray<E>.fixed(length);
   }
 
-  @patch
+  /**
+   * Creates a fixed-length list of the given length, and initializes the
+   * value at each position with [fill]:
+   *
+   *     new List<int>.filled(3, 0); // [0, 0, 0]
+   *
+   * The [length] must not be negative or null.
+   */
   factory List.filled(int length, E fill) {
     List result = new JSArray<E>.fixed(length);
     if (length != 0 && fill != null) {
       for (int i = 0; i < result.length; i++) {
         result[i] = fill;
       }
     }
     return result;
   }
 
-  @patch
+  /**
+   * Creates a list containing all [elements].
+   *
+   * The [Iterator] of [elements] provides the order of the elements.
+   *
+   * This constructor returns a growable list when [growable] is true;
+   * otherwise, it returns a fixed-length list.
+   */
   factory List.from(Iterable elements, { bool growable: true }) {
     List<E> list = new List<E>();
     for (E e in elements) {
       list.add(e);
     }
     if (growable) return list;
     return makeListFixedLength(list);
   }
 
   /**
@@ skipping 351 matching lines @@
    * as values. The `Map.keys` [Iterable] iterates the indices of this list
    * in numerical order.
    *
    *     List<String> words = ['fee', 'fi', 'fo', 'fum'];
    *     Map<int, String> map = words.asMap();
    *     map[0] + map[1];   // 'feefi';
    *     map.keys.toList(); // [0, 1, 2, 3]
    */
   Map<int, E> asMap();
 }