Bug fixes and added support for creating source edits

pkg/analysis_server/lib/src/provisional/edit/utilities/change_builder_dart.dart

 // Copyright (c) 2015, 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 'package:analysis_server/src/provisional/edit/utilities/change_builder_core.dart';
 import 'package:analysis_server/src/utilities/change_builder_dart.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/generated/resolver.dart';
+import 'package:analyzer/src/generated/source.dart';
 
 /**
  * A [ChangeBuilder] used to build changes in Dart files.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DartChangeBuilder extends ChangeBuilder {
   /**
    * Initialize a newly created change builder.
    */
   factory DartChangeBuilder(AnalysisDriver driver) = DartChangeBuilderImpl;
 }
 
 /**
  * An [EditBuilder] used to build edits in Dart files.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DartEditBuilder extends EditBuilder {
   /**
-   * The group-id used for the name of a declaration.
+   * The edits in this builder will be inside the class with the given
+   * [element].
+   *
+   * TODO(brianwilkerson) Remove this method.
    */
-  static const String NAME_GROUP_ID = 'NAME';
-
-  /**
-   * The group-id used for the return type of a function, getter or method.
-   */
-  static const String RETURN_TYPE_GROUP_ID = 'RETURN_TYPE';
-
-  /**
-   * The group-id used for the name of the superclass in a class declaration.
-   */
-  static const String SUPERCLASS_GROUP_ID = 'SUPERCLASS';
+  void set targetClassElement(ClassElement element);
 
   /**
    * Write the code for a declaration of a class with the given [name]. If a
    * list of [interfaces] is provided, then the class will implement those
    * interfaces. If [isAbstract] is `true`, then the class will be abstract. If
    * a [memberWriter] is provided, then it will be invoked to allow members to
    * be generated. (The members will automatically be preceded and followed by
    * end-of-line markers.) If a list of [mixins] is provided, then the class
    * will mix in those classes. If a [nameGroupName] is provided, then the name
    * of the class will be included in the linked edit group with that name. If a
    * [superclass] is given then it will be the superclass of the class. (If a
    * list of [mixins] is provided but no [superclass] is given then the class
    * will extend `Object`.)
    */
   void writeClassDeclaration(String name,
       {Iterable<DartType> interfaces,
       bool isAbstract: false,
       void memberWriter(),
       Iterable<DartType> mixins,
       String nameGroupName,
       DartType superclass,
       String superclassGroupName});
 
   /**
+   * Write the code for a constructor declaration in the class with the given
+   * [className]. If [isConst] is `true`, then the constructor will be marked
+   * as being a `const` constructor. If a [constructorName] is provided, then
+   * the constructor will have the given name. If both a constructor name and a
+   * [constructorNameGroupName] is provided, then the name of the constructor
+   * will be included in the linked edit group with that name. If an
+   * [argumentList] is provided then the constructor will have parameters that
+   * match the given arguments. If no argument list is given, but a list of
+   * [fieldNames] is provided, then field formal parameters will be created for
+   * each of the field names.
+   */
+  void writeConstructorDeclaration(String className,
+      {ArgumentList argumentList,
+      SimpleIdentifier constructorName,
+      String constructorNameGroupName,
+      List<String> fieldNames,
+      bool isConst: false});
+
+  /**
    * Write the code for a declaration of a field with the given [name]. If an
    * [initializerWriter] is provided, it will be invoked to write the content of
    * the initializer. (The equal sign separating the field name from the
    * initializer expression will automatically be written.) If [isConst] is
    * `true`, then the declaration will be preceded by the `const` keyword. If
    * [isFinal] is `true`, then the declaration will be preceded by the `final`
    * keyword. (If both [isConst] and [isFinal] are `true`, then only the `const`
    * keyword will be written.) If [isStatic] is `true`, then the declaration
    * will be preceded by the `static` keyword. If a [nameGroupName] is
    * provided, the name of the field will be included in the linked edit group
@@ skipping 116 matching lines @@
    * If the [groupName] is not `null`, then the name of the type (including type
    * parameters) will be included as a region in the linked edit group with that
    * name. If the [groupName] is not `null` and [addSupertypeProposals] is
    * `true`, then all of the supertypes of the [type] will be added as
    * suggestions for alternatives to the type name.
    */
   bool writeType(DartType type,
       {bool addSupertypeProposals: false,
       String groupName,
       bool required: false});
+
+  /**
+   * Write the code to declare the given [typeParameter]. The enclosing angle
+   * brackets are not automatically written.
+   */
+  void writeTypeParameter(TypeParameterElement typeParameter);
+
+  /**
+   * Write the code to declare the given list of [typeParameters]. The enclosing
+   * angle brackets are automatically written.
+   */
+  void writeTypeParameters(List<TypeParameterElement> typeParameters);
 }
 
 /**
  * A [FileEditBuilder] used to build edits for Dart files.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DartFileEditBuilder extends FileEditBuilder {
   /**
    * Create one or more edits that will convert the given function [body] from
    * being synchronous to be asynchronous. This includes adding the `async`
    * modifier to the body as well as potentially replacing the return type of
    * the function to `Future`.
    *
    * There is currently a limitation in that the function body must not be a
    * generator.
    *
    * Throws an [ArgumentError] if the function body is not both synchronous and
    * a non-generator.
    */
   void convertFunctionFromSyncToAsync(
       FunctionBody body, TypeProvider typeProvider);
 
   /**
+   * Arrange to have imports added for each of the given [libraries].
+   */
+  void importLibraries(Iterable<Source> libraries);
+
+  /**
    * Optionally create an edit to replace the given [typeAnnotation] with the
    * type `Future` (with the given type annotation as the type argument). The
    * [typeProvider] is used to check the current type, because if it is already
    * `Future` no edit will be added.
    */
   void replaceTypeWithFuture(
       TypeAnnotation typeAnnotation, TypeProvider typeProvider);
 }
 
 /**
  * A [LinkedEditBuilder] used to build linked edits for Dart files.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DartLinkedEditBuilder extends LinkedEditBuilder {
   /**
    * Add the given [type] and all of its supertypes (other than mixins) as
    * suggestions for the current linked edit group.
    */
   void addSuperTypesAsSuggestions(DartType type);
 }