Remove unintentional dependency on analysis_server

pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart

 // Copyright (c) 2017, 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:async';
 
-import 'package:analysis_server/protocol/protocol_generated.dart'
-    hide Element, ElementKind;
-import 'package:analysis_server/src/services/correction/name_suggestion.dart';
-import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.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/dart/ast/utilities.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer_plugin/protocol/protocol_generated.dart'
+    hide Element, ElementKind;
 import 'package:analyzer_plugin/src/utilities/change_builder/change_builder_core.dart';
+import 'package:analyzer_plugin/src/utilities/string_utilities.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_dart.dart';
 import 'package:analyzer_plugin/utilities/range_factory.dart';
+import 'package:charcode/ascii.dart';
+import 'package:path/path.dart' as path;
 
 /**
  * A [ChangeBuilder] used to build changes in Dart files.
  */
 class DartChangeBuilderImpl extends ChangeBuilderImpl
     implements DartChangeBuilder {
   /**
    * The analysis driver in which the files being edited were analyzed.
    */
   final AnalysisDriver driver;
 
   /**
    * Initialize a newly created change builder.
    */
   DartChangeBuilderImpl(this.driver);
 
   @override
   Future<DartFileEditBuilderImpl> createFileEditBuilder(
       String path, int fileStamp) async {
     AnalysisResult result = await driver.getResult(path);
     return new DartFileEditBuilderImpl(this, path, fileStamp, result.unit);
   }
 }
 
 /**
  * An [EditBuilder] used to build edits in Dart files.
  */
 class DartEditBuilderImpl extends EditBuilderImpl implements DartEditBuilder {
+  List<String> _KNOWN_METHOD_NAME_PREFIXES = ['get', 'is', 'to'];
+
   /**
    * Initialize a newly created builder to build a source edit.
    */
   DartEditBuilderImpl(
       DartFileEditBuilderImpl sourceFileEditBuilder, int offset, int length)
       : super(sourceFileEditBuilder, offset, length);
 
   DartFileEditBuilderImpl get dartFileEditBuilder => fileEditBuilder;
 
   @override
@@ skipping 474 matching lines @@
           write(prefix);
         }
         first = false;
       } else {
         write(', ');
       }
       writeType(type);
     }
   }
 
+  /**
+   * Adds [toAdd] items which are not excluded.
+   */
+  void _addAll(
+      Set<String> excluded, Set<String> result, Iterable<String> toAdd) {
+    for (String item in toAdd) {
+      // add name based on "item", but not "excluded"
+      for (int suffix = 1;; suffix++) {
+        // prepare name, just "item" or "item2", "item3", etc
+        String name = item;
+        if (suffix > 1) {
+          name += suffix.toString();
+        }
+        // add once found not excluded
+        if (!excluded.contains(name)) {
+          result.add(name);
+          break;
+        }
+      }
+    }
+  }
+
+  /**
+   * Adds to [result] either [c] or the first ASCII character after it.
+   */
+  void _addSingleCharacterName(
+      Set<String> excluded, Set<String> result, int c) {
+    while (c < $z) {
+      String name = new String.fromCharCode(c);
+      // may be done
+      if (!excluded.contains(name)) {
+        result.add(name);
+        break;
+      }
+      // next character
+      c = c + 1;
+    }
+  }
+
   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);
       }
     }
   }
 
+  String _getBaseNameFromExpression(Expression expression) {
+    String name = null;
+    // e as Type
+    if (expression is AsExpression) {
+      AsExpression asExpression = expression as AsExpression;
+      expression = asExpression.expression;
+    }
+    // analyze expressions
+    if (expression is SimpleIdentifier) {
+      SimpleIdentifier node = expression;
+      return node.name;
+    } else if (expression is PrefixedIdentifier) {
+      PrefixedIdentifier node = expression;
+      return node.identifier.name;
+    } else if (expression is PropertyAccess) {
+      PropertyAccess node = expression;
+      return node.propertyName.name;
+    } else if (expression is MethodInvocation) {
+      name = expression.methodName.name;
+    } else if (expression is InstanceCreationExpression) {
+      InstanceCreationExpression creation = expression;
+      ConstructorName constructorName = creation.constructorName;
+      TypeName typeName = constructorName.type;
+      if (typeName != null) {
+        Identifier typeNameIdentifier = typeName.name;
+        // new ClassName()
+        if (typeNameIdentifier is SimpleIdentifier) {
+          return typeNameIdentifier.name;
+        }
+        // new prefix.name();
+        if (typeNameIdentifier is PrefixedIdentifier) {
+          PrefixedIdentifier prefixed = typeNameIdentifier;
+          // new prefix.ClassName()
+          if (prefixed.prefix.staticElement is PrefixElement) {
+            return prefixed.identifier.name;
+          }
+          // new ClassName.constructorName()
+          return prefixed.prefix.name;
+        }
+      }
+    }
+    // strip known prefixes
+    if (name != null) {
+      for (int i = 0; i < _KNOWN_METHOD_NAME_PREFIXES.length; i++) {
+        String prefix = _KNOWN_METHOD_NAME_PREFIXES[i];
+        if (name.startsWith(prefix)) {
+          if (name == prefix) {
+            return null;
+          } else if (isUpperCase(name.codeUnitAt(prefix.length))) {
+            return name.substring(prefix.length);
+          }
+        }
+      }
+    }
+    // done
+    return name;
+  }
+
+  String _getBaseNameFromLocationInParent(Expression expression) {
+    // value in named expression
+    if (expression.parent is NamedExpression) {
+      NamedExpression namedExpression = expression.parent as NamedExpression;
+      if (namedExpression.expression == expression) {
+        return namedExpression.name.label.name;
+      }
+    }
+    // positional argument
+    ParameterElement parameter = expression.propagatedParameterElement;
+    if (parameter == null) {
+      parameter = expression.staticParameterElement;
+    }
+    if (parameter != null) {
+      return parameter.displayName;
+    }
+
+    // unknown
+    return null;
+  }
+
+  /**
+   * Returns all variants of names by removing leading words one by one.
+   */
+  List<String> _getCamelWordCombinations(String name) {
+    List<String> result = [];
+    List<String> parts = getCamelWords(name);
+    for (int i = 0; i < parts.length; i++) {
+      String s1 = parts[i].toLowerCase();
+      String s2 = parts.skip(i + 1).join();
+      String suggestion = '$s1$s2';
+      result.add(suggestion);
+    }
+    return result;
+  }
+
   /**
    * Return the import element used to import the given [element] into the given
    * [library], or `null` if the element was not imported, such as when the
    * element is declared in the same library.
    */
   ImportElement _getImportElement(Element element, LibraryElement library) {
-    for (ImportElement imp in library.imports) {
-      Map<String, Element> definedNames = getImportNamespace(imp);
+    for (ImportElement importElement in library.imports) {
+      Map<String, Element> definedNames = _getImportNamespace(importElement);
       if (definedNames.containsValue(element)) {
-        return imp;
+        return importElement;
       }
     }
     return null;
   }
 
   /**
+   * Return the namespace added by the given import [element].
+   */
+  Map<String, Element> _getImportNamespace(ImportElement element) {
+    NamespaceBuilder builder = new NamespaceBuilder();
+    Namespace namespace = builder.createImportNamespaceForDirective(element);
+    return namespace.definedNames;
+  }
+
+  /**
    * Return a list containing the suggested names for a parameter with the given
    * [type] whose value in one location is computed by the given [expression].
    * The list will not contain any names in the set of [excluded] names. The
    * [index] is the index of the argument, used to create a name if no better
    * name could be created. The first name in the list will be the best name.
    */
   List<String> _getParameterNameSuggestions(
       Set<String> usedNames, DartType type, Expression expression, int index) {
     List<String> suggestions =
-        getVariableNameSuggestionsForExpression(type, expression, usedNames);
+        _getVariableNameSuggestionsForExpression(type, expression, usedNames);
     if (suggestions.length != 0) {
       return suggestions;
     }
     // TODO(brianwilkerson) Verify that the name below is not in the set of used names.
     return <String>['param$index'];
   }
 
   /**
    * Return the source for the parameter with the given [type] and [name].
    */
@@ skipping 135 matching lines @@
           }
         }
         sb.write(">");
       }
     }
     // done
     return sb.toString();
   }
 
   /**
+   * Returns possible names for a variable with the given expected type and
+   * expression assigned.
+   */
+  List<String> _getVariableNameSuggestionsForExpression(DartType expectedType,
+      Expression assignedExpression, Set<String> excluded) {
+    Set<String> res = new Set();
+    // use expression
+    if (assignedExpression != null) {
+      String nameFromExpression =
+          _getBaseNameFromExpression(assignedExpression);
+      if (nameFromExpression != null) {
+        nameFromExpression = removeStart(nameFromExpression, '_');
+        _addAll(excluded, res, _getCamelWordCombinations(nameFromExpression));
+      }
+      String nameFromParent =
+          _getBaseNameFromLocationInParent(assignedExpression);
+      if (nameFromParent != null) {
+        _addAll(excluded, res, _getCamelWordCombinations(nameFromParent));
+      }
+    }
+    // use type
+    if (expectedType != null && !expectedType.isDynamic) {
+      String typeName = expectedType.name;
+      if ('int' == typeName) {
+        _addSingleCharacterName(excluded, res, $i);
+      } else if ('double' == typeName) {
+        _addSingleCharacterName(excluded, res, $d);
+      } else if ('String' == typeName) {
+        _addSingleCharacterName(excluded, res, $s);
+      } else {
+        _addAll(excluded, res, _getCamelWordCombinations(typeName));
+      }
+      res.remove(typeName);
+    }
+    // done
+    return new List.from(res);
+  }
+
+  /**
    * Checks if [type] is visible in either the [enclosingExecutable] or
    * [enclosingClass].
    */
   bool _isTypeVisible(DartType type, ClassElement enclosingClass,
       ExecutableElement enclosingExecutable) {
     if (type is TypeParameterType) {
       TypeParameterElement parameterElement = type.element;
       Element parameterParent = parameterElement.enclosingElement;
       // TODO(brianwilkerson) This needs to compare the parameterParent with
       // each of the parents of the enclosingElement. (That means that we only
@@ skipping 48 matching lines @@
     _replaceReturnTypeWithFuture(body, typeProvider);
   }
 
   @override
   DartEditBuilderImpl createEditBuilder(int offset, int length) {
     return new DartEditBuilderImpl(this, offset, length);
   }
 
   @override
   void finalize() {
-    addLibraryImports(
+    _addLibraryImports(
         changeBuilder.sourceChange, unit.element.library, librariesToImport);
   }
 
-//  /**
-//   * Return the content of the file being edited.
-//   */
-//  String getContent() {
-//    if (_content == null) {
-//      CompilationUnitElement unitElement = unit.element;
-//      AnalysisContext context = unitElement.context;
-//      if (context == null) {
-//        throw new CancelCorrectionException();
-//      }
-//      _content = context.getContents(unitElement.source).data;
-//    }
-//    return _content;
-//  }
-
   @override
   void importLibraries(Iterable<Source> libraries) {
     librariesToImport.addAll(libraries);
   }
 
   @override
   void replaceTypeWithFuture(
       TypeAnnotation typeAnnotation, TypeProvider typeProvider) {
     InterfaceType futureType = typeProvider.futureType;
     //
     // Check whether the type needs to be replaced.
     //
     DartType type = typeAnnotation?.type;
     if (type == null ||
         type.isDynamic ||
         type is InterfaceType && type.element == futureType.element) {
       return;
     }
     futureType = futureType.instantiate(<DartType>[type]);
     // prepare code for the types
     addReplacement(range.node(typeAnnotation), (EditBuilder builder) {
       if (!(builder as DartEditBuilder).writeType(futureType)) {
         builder.write('void');
       }
     });
   }
 
+  /**
+   * Adds edits to the given [change] that ensure that all the [libraries] are
+   * imported into the given [targetLibrary].
+   */
+  void _addLibraryImports(SourceChange change, LibraryElement targetLibrary,
+      Set<Source> libraries) {
+    // Prepare information about existing imports.
+    LibraryDirective libraryDirective;
+    List<ImportDirective> importDirectives = <ImportDirective>[];
+    for (Directive directive in unit.directives) {
+      if (directive is LibraryDirective) {
+        libraryDirective = directive;
+      } else if (directive is ImportDirective) {
+        importDirectives.add(directive);
+      }
+    }
+
+    // Prepare all URIs to import.
+    List<String> uriList = libraries
+        .map((library) => _getLibrarySourceUri(targetLibrary, library))
+        .toList();
+    uriList.sort((a, b) => a.compareTo(b));
+
+    // Insert imports: between existing imports.
+    if (importDirectives.isNotEmpty) {
+      bool isFirstPackage = true;
+      for (String importUri in uriList) {
+        bool inserted = false;
+        bool isPackage = importUri.startsWith('package:');
+        bool isAfterDart = false;
+        for (ImportDirective existingImport in importDirectives) {
+          if (existingImport.uriContent.startsWith('dart:')) {
+            isAfterDart = true;
+          }
+          if (existingImport.uriContent.startsWith('package:')) {
+            isFirstPackage = false;
+          }
+          if (importUri.compareTo(existingImport.uriContent) < 0) {
+            addInsertion(existingImport.offset, (EditBuilder builder) {
+              builder.write("import '");
+              builder.write(importUri);
+              builder.writeln("';");
+            });
+            inserted = true;
+            break;
+          }
+        }
+        if (!inserted) {
+          addInsertion(importDirectives.last.end, (EditBuilder builder) {
+            if (isPackage && isFirstPackage && isAfterDart) {
+              builder.writeln();
+            }
+            builder.writeln();
+            builder.write("import '");
+            builder.write(importUri);
+            builder.write("';");
+          });
+        }
+        if (isPackage) {
+          isFirstPackage = false;
+        }
+      }
+      return;
+    }
+
+    // Insert imports: after the library directive.
+    if (libraryDirective != null) {
+      for (int i = 0; i < uriList.length; i++) {
+        String importUri = uriList[i];
+        addInsertion(libraryDirective.end, (EditBuilder builder) {
+          if (i == 0) {
+            builder.writeln();
+          }
+          builder.writeln();
+          builder.write("import '");
+          builder.write(importUri);
+          builder.writeln("';");
+        });
+      }
+      return;
+    }
+
+    // If still at the beginning of the file, skip shebang and line comments.
+    _InsertionDescription desc = _getInsertDescTop();
+    int offset = desc.offset;
+    for (int i = 0; i < uriList.length; i++) {
+      String importUri = uriList[i];
+      addInsertion(offset, (EditBuilder builder) {
+        if (i == 0 && desc.insertEmptyLineBefore) {
+          builder.writeln();
+        }
+        builder.write("import '");
+        builder.write(importUri);
+        builder.writeln("';");
+        if (i == uriList.length - 1 && desc.insertEmptyLineAfter) {
+          builder.writeln();
+        }
+      });
+    }
+  }
+
+  /**
+   * Returns a [InsertDesc] describing where to insert a new directive or a
+   * top-level declaration at the top of the file.
+   */
+  _InsertionDescription _getInsertDescTop() {
+    // skip leading line comments
+    int offset = 0;
+    bool insertEmptyLineBefore = false;
+    bool insertEmptyLineAfter = false;
+    String source = unit.element.context.getContents(unit.element.source).data;
+    var lineInfo = unit.lineInfo;
+    // skip hash-bang
+    if (offset < source.length - 2) {
+      String linePrefix = _getText(source, offset, 2);
+      if (linePrefix == "#!") {
+        insertEmptyLineBefore = true;
+        offset = lineInfo.getOffsetOfLineAfter(offset);
+        // skip empty lines to first line comment
+        int emptyOffset = offset;
+        while (emptyOffset < source.length - 2) {
+          int nextLineOffset = lineInfo.getOffsetOfLineAfter(emptyOffset);
+          String line = source.substring(emptyOffset, nextLineOffset);
+          if (line.trim().isEmpty) {
+            emptyOffset = nextLineOffset;
+            continue;
+          } else if (line.startsWith("//")) {
+            offset = emptyOffset;
+            break;
+          } else {
+            break;
+          }
+        }
+      }
+    }
+    // skip line comments
+    while (offset < source.length - 2) {
+      String linePrefix = _getText(source, offset, 2);
+      if (linePrefix == "//") {
+        insertEmptyLineBefore = true;
+        offset = lineInfo.getOffsetOfLineAfter(offset);
+      } else {
+        break;
+      }
+    }
+    // determine if empty line is required after
+    int currentLine = lineInfo.getLocation(offset).lineNumber;
+    if (currentLine < lineInfo.lineCount) {
+      int nextLineOffset = lineInfo.getOffsetOfLine(currentLine + 1);
+      String insertLine = source.substring(offset, nextLineOffset);
+      if (!insertLine.trim().isEmpty) {
+        insertEmptyLineAfter = true;
+      }
+    }
+    return new _InsertionDescription(
+        offset, insertEmptyLineBefore, insertEmptyLineAfter);
+  }
+
+//  /**
+//   * Return the content of the file being edited.
+//   */
+//  String getContent() {
+//    if (_content == null) {
+//      CompilationUnitElement unitElement = unit.element;
+//      AnalysisContext context = unitElement.context;
+//      if (context == null) {
+//        throw new CancelCorrectionException();
+//      }
+//      _content = context.getContents(unitElement.source).data;
+//    }
+//    return _content;
+//  }
+
+  /**
+   * Computes the best URI to import [what] into [from].
+   */
+  String _getLibrarySourceUri(LibraryElement from, Source what) {
+    String whatPath = what.fullName;
+    // check if an absolute URI (such as 'dart:' or 'package:')
+    Uri whatUri = what.uri;
+    String whatUriScheme = whatUri.scheme;
+    if (whatUriScheme != '' && whatUriScheme != 'file') {
+      return whatUri.toString();
+    }
+    // compute a relative URI
+    String fromFolder = path.dirname(from.source.fullName);
+    String relativeFile = path.relative(whatPath, from: fromFolder);
+    return path.split(relativeFile).join('/');
+  }
+
+  /**
+   * Returns the text of the given range in the unit.
+   */
+  String _getText(String content, int offset, int length) {
+    return content.substring(offset, offset + length);
+  }
+
 //  /**
 //   * Returns the text of the given [AstNode] in the unit.
 //   */
 //  String _getNodeText(AstNode node) {
 //    return _getText(node.offset, node.length);
 //  }
 //
 //  /**
 //   * Returns the text of the given range in the unit.
 //   */
@@ skipping 68 matching lines @@
         enclosingExecutable = node.element;
       } else if (node is MethodDeclaration) {
         enclosingExecutable = node.element;
       } else if (node is FunctionDeclaration) {
         enclosingExecutable = node.element;
       }
       node = node.parent;
     }
   }
 }
+
+class _InsertionDescription {
+  final int offset;
+  final bool insertEmptyLineBefore;
+  final bool insertEmptyLineAfter;
+  _InsertionDescription(
+      this.offset, this.insertEmptyLineBefore, this.insertEmptyLineAfter);
+}