Remove the use of CorrectionUtilities

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.
 
 import 'dart:async';
 
 import 'package:analysis_server/protocol/protocol_generated.dart'
     hide Element, ElementKind;
 import 'package:analysis_server/src/provisional/edit/utilities/change_builder_core.dart';
 import 'package:analysis_server/src/provisional/edit/utilities/change_builder_dart.dart';
 import 'package:analysis_server/src/services/correction/name_suggestion.dart';
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analysis_server/src/utilities/change_builder_core.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/engine.dart' hide AnalysisResult;
 import 'package:analyzer/src/generated/resolver.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 {
   /**
@@ skipping 12 matching lines @@
     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 {
   /**
-   * A utility class used to help build the source code.
-   */
-  final CorrectionUtils utils;
-
-  /**
    * Initialize a newly created builder to build a source edit.
    */
   DartEditBuilderImpl(
       DartFileEditBuilderImpl sourceFileEditBuilder, int offset, int length)
-      : utils = sourceFileEditBuilder.utils,
-        super(sourceFileEditBuilder, offset, length);
+      : super(sourceFileEditBuilder, offset, length);
 
   DartFileEditBuilderImpl get dartFileEditBuilder => fileEditBuilder;
 
   @override
-  void set targetClassElement(ClassElement element) {
-    utils.targetClassElement = element;
-  }
-
-  @override
   LinkedEditBuilderImpl createLinkedEditBuilder() {
     return new DartLinkedEditBuilderImpl(this);
   }
 
   /**
    * Returns the indentation with the given [level].
    */
   String getIndent(int level) => '  ' * level;
 
-//  /**
-//   * Arrange to have imports added for each of the given [libraries].
-//   */
-//  void importLibraries(Iterable<Source> libraries) {
-//    dartFileEditBuilder.importLibraries(libraries);
-//  }
-
   /**
    * Arrange to have an import added for the given [library].
    */
   void importLibrary(Source library) {
     dartFileEditBuilder.librariesToImport.add(library);
   }
 
   @override
   void writeClassDeclaration(String name,
       {Iterable<DartType> interfaces,
@@ skipping 369 matching lines @@
       }
       writeParameterMatchingArgument(argument, i, usedNames);
     }
     if (hasNamedParameters) {
       write('}');
     }
   }
 
   @override
   void writeParameterSource(DartType type, String name) {
-    String parameterSource = utils.getParameterSource(
-        type, name, dartFileEditBuilder.librariesToImport);
+    _EnclosingElementFinder finder = new _EnclosingElementFinder();
+    finder.find(dartFileEditBuilder.unit, offset);
+    String parameterSource = _getParameterSource(
+        type, name, finder.enclosingClass, finder.enclosingExecutable);
     write(parameterSource);
   }
 
   @override
   bool writeType(DartType type,
       {bool addSupertypeProposals: false,
       String groupName,
       bool required: false}) {
     if (type != null && !type.isDynamic) {
-      String typeSource =
-          utils.getTypeSource(type, dartFileEditBuilder.librariesToImport);
+      _EnclosingElementFinder finder = new _EnclosingElementFinder();
+      finder.find(dartFileEditBuilder.unit, offset);
+      String typeSource = _getTypeSource(
+          type, finder.enclosingClass, finder.enclosingExecutable);
       if (typeSource != 'dynamic') {
         if (groupName != null) {
           addLinkedEdit(groupName, (LinkedEditBuilder builder) {
             write(typeSource);
             if (addSupertypeProposals) {
               _addSuperTypeProposals(builder, type, new Set<DartType>());
             }
           });
         } else {
           write(typeSource);
@@ skipping 64 matching lines @@
       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);
       }
     }
   }
 
   /**
+   * 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);
+      if (definedNames.containsValue(element)) {
+        return imp;
+      }
+    }
+    return null;
+  }
+
+  /**
    * 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);
     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].
+   */
+  String _getParameterSource(DartType type, String name,
+      ClassElement enclosingClass, ExecutableElement enclosingExecutable) {
+    // no type
+    if (type == null || type.isDynamic) {
+      return name;
+    }
+    // function type
+    if (type is FunctionType && type.element.isSynthetic) {
+      FunctionType functionType = type;
+      StringBuffer sb = new StringBuffer();
+      // return type
+      DartType returnType = functionType.returnType;
+      if (returnType != null && !returnType.isDynamic) {
+        String returnTypeSource =
+            _getTypeSource(returnType, enclosingClass, enclosingExecutable);
+        sb.write(returnTypeSource);
+        sb.write(' ');
+      }
+      // parameter name
+      sb.write(name);
+      // parameters
+      sb.write('(');
+      List<ParameterElement> fParameters = functionType.parameters;
+      for (int i = 0; i < fParameters.length; i++) {
+        ParameterElement fParameter = fParameters[i];
+        if (i != 0) {
+          sb.write(", ");
+        }
+        sb.write(_getParameterSource(fParameter.type, fParameter.name,
+            enclosingClass, enclosingExecutable));
+      }
+      sb.write(')');
+      // done
+      return sb.toString();
+    }
+    // simple type
+    String typeSource =
+        _getTypeSource(type, enclosingClass, enclosingExecutable);
+    return '$typeSource $name';
+  }
+
+  /**
+   * Returns the source to reference [type] in this [CompilationUnit].
+   *
+   * Fills [librariesToImport] with [LibraryElement]s whose elements are
+   * used by the generated source, but not imported.
+   */
+  String _getTypeSource(DartType type, ClassElement enclosingClass,
+      ExecutableElement enclosingExecutable,
+      {StringBuffer parametersBuffer}) {
+    StringBuffer sb = new StringBuffer();
+    // type parameter
+    if (!_isTypeVisible(type, enclosingClass, enclosingExecutable)) {
+      return 'dynamic';
+    }
+    // just a Function, not FunctionTypeAliasElement
+    if (type is FunctionType && type.element is! FunctionTypeAliasElement) {
+      if (parametersBuffer == null) {
+        return "Function";
+      }
+      parametersBuffer.write('(');
+      for (ParameterElement parameter in type.parameters) {
+        String parameterType =
+            _getTypeSource(parameter.type, enclosingClass, enclosingExecutable);
+        if (parametersBuffer.length != 1) {
+          parametersBuffer.write(', ');
+        }
+        parametersBuffer.write(parameterType);
+        parametersBuffer.write(' ');
+        parametersBuffer.write(parameter.name);
+      }
+      parametersBuffer.write(')');
+      return _getTypeSource(
+          type.returnType, enclosingClass, enclosingExecutable);
+    }
+    // <Bottom>, Null
+    if (type.isBottom || type.isDartCoreNull) {
+      return 'dynamic';
+    }
+    // prepare element
+    Element element = type.element;
+    if (element == null) {
+      String source = type.toString();
+      source = source.replaceAll('<dynamic>', '');
+      source = source.replaceAll('<dynamic, dynamic>', '');
+      return source;
+    }
+    // check if imported
+    LibraryElement definingLibrary = element.library;
+    LibraryElement importingLibrary = dartFileEditBuilder.unit.element.library;
+    if (definingLibrary != null && definingLibrary != importingLibrary) {
+      // no source, if private
+      if (element.isPrivate) {
+        return null;
+      }
+      // ensure import
+      ImportElement importElement =
+          _getImportElement(element, importingLibrary);
+      if (importElement != null) {
+        if (importElement.prefix != null) {
+          sb.write(importElement.prefix.displayName);
+          sb.write(".");
+        }
+      } else {
+        importLibrary(definingLibrary.source);
+      }
+    }
+    // append simple name
+    String name = element.displayName;
+    sb.write(name);
+    // may be type arguments
+    if (type is ParameterizedType) {
+      List<DartType> arguments = type.typeArguments;
+      // check if has arguments
+      bool hasArguments = false;
+      bool allArgumentsVisible = true;
+      for (DartType argument in arguments) {
+        hasArguments = hasArguments || !argument.isDynamic;
+        allArgumentsVisible = allArgumentsVisible &&
+            _isTypeVisible(argument, enclosingClass, enclosingExecutable);
+      }
+      // append type arguments
+      if (hasArguments && allArgumentsVisible) {
+        sb.write("<");
+        for (int i = 0; i < arguments.length; i++) {
+          DartType argument = arguments[i];
+          if (i != 0) {
+            sb.write(", ");
+          }
+          String argumentSrc =
+              _getTypeSource(argument, enclosingClass, enclosingExecutable);
+          if (argumentSrc != null) {
+            sb.write(argumentSrc);
+          } else {
+            return null;
+          }
+        }
+        sb.write(">");
+      }
+    }
+    // done
+    return sb.toString();
+  }
+
+  /**
+   * 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
+      // need the most closely enclosing element.)
+      return identical(parameterParent, enclosingExecutable) ||
+          identical(parameterParent, enclosingClass);
+    }
+    return true;
+  }
 }
 
 /**
  * A [FileEditBuilder] used to build edits for Dart files.
  */
 class DartFileEditBuilderImpl extends FileEditBuilderImpl
     implements DartFileEditBuilder {
   /**
    * The compilation unit to which the code will be added.
    */
   CompilationUnit unit;
 
   /**
-   * A utility class used to help build the source code.
-   */
-  CorrectionUtils utils;
-
-  /**
    * A set containing the sources of the libraries that need to be imported in
    * order to make visible the names used in generated code.
    */
   Set<Source> librariesToImport = new Set<Source>();
 
   /**
+   * The content of the file being edited.
+   */
+  String _content;
+
+  /**
    * Initialize a newly created builder to build a source file edit within the
    * change being built by the given [changeBuilder]. The file being edited has
    * the given [source] and [timeStamp], and the given fully resolved [unit].
    */
   DartFileEditBuilderImpl(DartChangeBuilderImpl changeBuilder, String path,
       int timeStamp, this.unit)
-      : super(changeBuilder, path, timeStamp) {
-    utils = new CorrectionUtils(unit);
-  }
+      : super(changeBuilder, path, timeStamp);
 
   @override
   void convertFunctionFromSyncToAsync(
       FunctionBody body, TypeProvider typeProvider) {
     if (body == null && body.keyword != null) {
       throw new ArgumentError(
           'The function must have a synchronous, non-generator body.');
     }
     addInsertion(body.offset, (EditBuilder builder) {
       builder.write('async ');
     });
     _replaceReturnTypeWithFuture(body, typeProvider);
   }
 
   @override
   DartEditBuilderImpl createEditBuilder(int offset, int length) {
     return new DartEditBuilderImpl(this, offset, length);
   }
 
   @override
   void finalize() {
     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
-    String futureTypeCode = utils.getTypeSource(futureType, librariesToImport);
-    String nodeCode = utils.getNodeText(typeAnnotation);
-    // wrap the existing type with Future
-    String returnTypeCode =
-        nodeCode == 'void' ? futureTypeCode : '$futureTypeCode<$nodeCode>';
     addReplacement(rangeNode(typeAnnotation), (EditBuilder builder) {
-      builder.write(returnTypeCode);
+      if (!(builder as DartEditBuilder).writeType(futureType)) {
+        builder.write('void');
+      }
     });
   }
 
   /**
+   * 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.
+   */
+  String _getText(int offset, int length) {
+    return getContent().substring(offset, offset + length);
+  }
+
+  /**
    * Create an edit to replace the return type of the innermost function
    * containing the given [node] with the type `Future`. The [typeProvider] is
    * used to check the current return type, because if it is already `Future` no
    * edit will be added.
    */
   void _replaceReturnTypeWithFuture(AstNode node, TypeProvider typeProvider) {
     while (node != null) {
       node = node.parent;
       if (node is FunctionDeclaration) {
         replaceTypeWithFuture(node.returnType, typeProvider);
@@ skipping 30 matching lines @@
   void _addSuperTypesAsSuggestions(DartType type, Set<DartType> alreadyAdded) {
     if (type is InterfaceType && alreadyAdded.add(type)) {
       addSuggestion(LinkedEditSuggestionKind.TYPE, type.displayName);
       _addSuperTypesAsSuggestions(type.superclass, alreadyAdded);
       for (InterfaceType interfaceType in type.interfaces) {
         _addSuperTypesAsSuggestions(interfaceType, alreadyAdded);
       }
     }
   }
 }
+
+class _EnclosingElementFinder {
+  ClassElement enclosingClass;
+  ExecutableElement enclosingExecutable;
+
+  _EnclosingElementFinder();
+
+  void find(AstNode target, int offset) {
+    AstNode node = new NodeLocator2(offset).searchWithin(target);
+    while (node != null) {
+      if (node is ClassDeclaration) {
+        enclosingClass = node.element;
+      } else if (node is ConstructorDeclaration) {
+        enclosingExecutable = node.element;
+      } else if (node is MethodDeclaration) {
+        enclosingExecutable = node.element;
+      } else if (node is FunctionDeclaration) {
+        enclosingExecutable = node.element;
+      }
+      node = node.parent;
+    }
+  }
+}