More source utilities

pkg/analysis_server/lib/src/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.
 
 library analysis_server.src.utilities.change_builder_dart;
 
 import 'package:analysis_server/src/protocol.dart' hide ElementKind;
 import 'package:analysis_server/src/services/correction/name_suggestion.dart';
 import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analysis_server/src/utilities/change_builder_core.dart';
 import 'package:analysis_server/utilities/change_builder_core.dart';
 import 'package:analysis_server/utilities/change_builder_dart.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
  * A [ChangeBuilder] used to build changes in Dart files.
  */
 class DartChangeBuilderImpl extends ChangeBuilderImpl
     implements DartChangeBuilder {
   /**
    * The analysis context in which the files being edited were analyzed.
    */
   final AnalysisContext context;
 
   /**
    * Initialize a newly created change builder.
    */
   DartChangeBuilderImpl(this.context);
 
   @override
   DartFileEditBuilderImpl createFileEditBuilder(Source source, int fileStamp) {
     return new DartFileEditBuilderImpl(this, source, fileStamp);
   }
 }
 
 /**
  * An [EditBuilder] used to build edits in Dart files.
  */
 class DartEditBuilderImpl extends EditBuilderImpl implements DartEditBuilder {
   /**
-   * The string used when writing the 'abstract' modifier.
-   */
-  static const String ABSTRACT_MODIFIER = 'abstract ';
-
-  /**
-   * The string used when writing the 'const' modifier.
-   */
-  static const String CONST_MODIFIER = 'const ';
-
-  /**
    * A utility class used to help build the source code.
    */
   final CorrectionUtils utils;
 
-//  /**
-//   * The string used when writing the 'final' modifier.
-//   */
-//  static const String FINAL_MODIFIER = 'final ';
-//
-//  /**
-//   * The string used when writing the 'static' modifier.
-//   */
-//  static const String STATIC_MODIFIER = 'static ';
-
   /**
    * Initialize a newly created builder to build a source edit.
    */
   DartEditBuilderImpl(
       DartFileEditBuilderImpl sourceFileEditBuilder, int offset, int length)
       : utils = sourceFileEditBuilder.utils,
         super(sourceFileEditBuilder, offset, length);
 
   DartFileEditBuilderImpl get dartFileEditBuilder => fileEditBuilder;
 
   @override
-  void writeClassDeclaration(String name, {Iterator<DartType> interfaces,
-      bool isAbstract: false, void memberWriter(), Iterator<DartType> mixins, DartType superclass}) {
+  void writeClassDeclaration(String name, {Iterable<DartType> interfaces,
+      bool isAbstract: false, void memberWriter(), Iterable<DartType> mixins,
+      String nameGroupName, DartType superclass}) {

[scheglov, 2015/05/04 04:41:27]

The "nameGroupName" parameter is not used.

[Brian Wilkerson, 2015/05/04 15:03:37]

Done

     // TODO(brianwilkerson) Add support for type parameters
     // Map<String, DartType>, List<TypeParameter>?
-    //
-    // TODO(brianwilkerson) Make additional optional parameters visible in the
-    // public API.
     if (isAbstract) {
-      write(ABSTRACT_MODIFIER);
+      write(Keyword.ABSTRACT.syntax);

[scheglov, 2015/05/04 04:41:27]

I don't see why we need to use token literals.
We write "class ", " with ", " extends Object", " = " and ", " as a string
literals anyway.
I doubt that we are going to change lexemes for keywords and other tokens.

[Brian Wilkerson, 2015/05/04 15:03:37]

True. Perhaps it's overkill, but it seemed cleaner to me.

+      ;

[scheglov, 2015/05/04 04:41:27]

Empty statement.

[Brian Wilkerson, 2015/05/04 15:03:37]

Removed

+      write(' ');
     }
     write('class ');
     addLinkedEdit(DartEditBuilder.NAME_GROUP_ID, (LinkedEditBuilder builder) {
       write(name);
     });
     if (superclass != null) {
       write(' extends ');
       writeType(superclass, groupName: DartEditBuilder.SUPERCLASS_GROUP_ID);
+    } else if (mixins != null && mixins.isNotEmpty) {
+      write(' extends Object ');
     }
     writeTypes(mixins, prefix: ' with ');
     writeTypes(interfaces, prefix: ' implements ');
     writeln(' {');
     if (memberWriter != null) {
+      writeln();
       memberWriter();
+      writeln();
     }
     write('}');
   }
 
-  /**
-   * Write the code for a comma-separated list of [types], optionally prefixed
-   * by a [prefix]. If the list of [types] is `null` or does not return any
-   * types, then nothing will be written.
-   */
-  void writeTypes(Iterator<DartType> types, {String prefix}) {
-    if (types == null) {
-      return;
-    }
-    bool first = true;
-    while (types.moveNext()) {
-      if (first) {
-        if (prefix != null) {
-          write(prefix);
-        }
-        first = false;
-      } else {
-        write(', ');
-      }
-      writeType(types.current);
-    }
-  }
-
+  //@override
   void writeConstructorDeclaration(ClassElement classElement,
       {ArgumentList argumentList, SimpleIdentifier constructorName,
       bool isConst: false}) {
     // TODO(brianwilkerson) Clean up the API and add it to the public API.
     //
     // TODO(brianwilkerson) Support passing a list of final fields rather than
     // an argument list.
     if (isConst) {
-      write(CONST_MODIFIER);
+      write(Keyword.CONST.syntax);
+      write(' ');
     }
     write(classElement.name);
     write('.');
     if (constructorName != null) {
       addLinkedEdit(DartEditBuilder.NAME_GROUP_ID, (LinkedEditBuilder builder) {
         write(constructorName.name);
       });
       CompilationUnit unit = constructorName
           .getAncestor((AstNode node) => node is CompilationUnit);
       if (unit != null) {
@@ skipping 10 matching lines @@
     if (argumentList != null) {
       writeParametersMatchingArguments(argumentList);
     } else {
       write('()');
     }
     writeln(' {');
     write('  }');
   }
 
   @override
+  void writeFieldDeclaration(String name, {void initializerWriter(),
+      bool isConst: false, bool isFinal: false, bool isStatic: false,
+      String nameGroupName, DartType type, String typeGroupName}) {
+    if (isStatic) {
+      write(Keyword.STATIC.syntax);
+      write(' ');
+    }
+    bool typeRequired = true;
+    if (isConst) {
+      write(Keyword.CONST.syntax);
+      typeRequired = false;
+    } else if (isFinal) {
+      write(Keyword.FINAL.syntax);
+      typeRequired = false;
+    }
+    if (type != null) {
+      writeType(type, groupName: typeGroupName);
+    } else if (typeRequired) {
+      write(Keyword.VAR.syntax);
+    }
+    write(' ');
+    if (nameGroupName != null) {
+      addLinkedEdit(nameGroupName, (LinkedEditBuilder builder) {
+        write(name);
+      });
+    } else {
+      write(name);
+    }
+    if (initializerWriter != null) {
+      write(' = ');
+      initializerWriter();
+    }
+    write(';');
+  }
+
+  @override
+  void writeGetterDeclaration(String name, {void bodyWriter(),
+      bool isStatic: false, String nameGroupName, DartType returnType,
+      String returnTypeGroupName}) {
+    if (isStatic) {
+      write(Keyword.STATIC.syntax);
+      write(' ');
+    }
+    if (returnType != null) {
+      writeType(returnType, groupName: returnTypeGroupName);
+      write(' ');
+    }
+    write(Keyword.GET.syntax);
+    write(' ');
+    if (nameGroupName != null) {
+      addLinkedEdit(nameGroupName, (LinkedEditBuilder builder) {
+        write(name);
+      });
+    } else {
+      write(name);
+    }
+    if (bodyWriter == null) {
+      write(' => null;');
+    } else {
+      write(' ');
+      bodyWriter();
+    }
+  }
+
+  @override
   void writeOverrideOfInheritedMember(ExecutableElement member) {
     // prepare environment
     String prefix = utils.getIndent(1);
     // may be property
     String prefix2 = utils.getIndent(2);
     ElementKind elementKind = member.kind;
     bool isGetter = elementKind == ElementKind.GETTER;
     bool isSetter = elementKind == ElementKind.SETTER;
     bool isMethod = elementKind == ElementKind.METHOD;
     bool isOperator = isMethod && (member as MethodElement).isOperator;
     write(prefix);
     if (isGetter) {
       writeln('// TODO: implement ${member.displayName}');
       write(prefix);
     }
     // @override
     writeln('@override');
     write(prefix);
     // return type
     // REVIEW: Added groupId
     bool shouldReturn = writeType(member.type.returnType,
         groupName: DartEditBuilder.RETURN_TYPE_GROUP_ID);
     write(' ');
     if (isGetter) {
-      write('get ');
+      write(Keyword.GET.syntax);
+      write(' ');
     } else if (isSetter) {
-      write('set ');
+      write(Keyword.SET.syntax);
+      write(' ');
     } else if (isOperator) {
-      write('operator ');
+      write(Keyword.OPERATOR.syntax);
+      write(' ');
     }
     // name
     write(member.displayName);
     // parameters + body
     if (isGetter) {
       writeln(' => null;');
     } else {
       List<ParameterElement> parameters = member.parameters;
       writeParameters(parameters);
       writeln(' {');
@@ skipping 115 matching lines @@
           write(typeSource);
           if (addSupertypeProposals) {
             _addSuperTypeProposals(builder, type, new Set<DartType>());
           }
         });
       } else {
         write(typeSource);
       }
       return true;
     } else if (required) {
-      write('var');
+      write(Keyword.VAR.syntax);
     }
     return false;
   }
 
+  /**
+   * Write the code for a comma-separated list of [types], optionally prefixed
+   * by a [prefix]. If the list of [types] is `null` or does not return any
+   * types, then nothing will be written.
+   */
+  void writeTypes(Iterable<DartType> types, {String prefix}) {
+    if (types == null || types.isEmpty) {
+      return;
+    }
+    bool first = true;
+    for (DartType type in types) {
+      if (first) {
+        if (prefix != null) {
+          write(prefix);
+        }
+        first = false;
+      } else {
+        write(', ');
+      }
+      writeType(type);
+    }
+  }
+
   void _addSuperTypeProposals(
       LinkedEditBuilder builder, DartType type, Set<DartType> alreadyAdded) {
     if (type != null &&
         type.element is ClassElement &&
         alreadyAdded.add(type)) {
       ClassElement element = type.element as ClassElement;
       builder.addSuggestion(LinkedEditSuggestionKind.TYPE, element.name);
       _addSuperTypeProposals(builder, element.supertype, alreadyAdded);
       for (InterfaceType interfaceType in element.interfaces) {
         _addSuperTypeProposals(builder, interfaceType, alreadyAdded);
@@ skipping 55 matching lines @@
     }
     unit = context.resolveCompilationUnit2(source, librariesContaining[0]);
     utils = new CorrectionUtils(unit);
   }
 
   @override
   DartEditBuilderImpl createEditBuilder(int offset, int length) {
     return new DartEditBuilderImpl(this, offset, length);
   }
 }