Issue 20827. Add imports as needed the 'Add type annotation' Quick Assist.

pkg/analysis_server/lib/src/services/correction/util.dart

 // Copyright (c) 2014, 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 services.src.correction.util;
 
 import 'dart:math';
 
 import 'package:analysis_server/src/protocol.dart' show SourceChange,
     SourceEdit;
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/correction/strings.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/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:path/path.dart';
 
 
 /**
  * @return <code>true</code> if given [List]s are identical at given position.
  */
 bool allListsIdentical(List<List> lists, int position) {
   Object element = lists[0][position];
   for (List list in lists) {
     if (list[position] != element) {
       return false;
@@ skipping 16 matching lines @@
     if (parent is PropertyAccess && parent.propertyName == node) {
       node = parent;
       continue;
     }
     return node;
   }
 }
 
 
 /**
+ * Attempts to convert the given absolute path into an absolute URI, such as
+ * "dart" or "package" URI.
+ *
+ * [context] - the [AnalysisContext] to work in.
+ * [path] - the absolute path, not `null`.
+ *
+ * Returns the absolute (non-file) URI or `null`.
+ */
+String findAbsoluteUri(AnalysisContext context, String path) {
+  Source fileSource = new NonExistingSource(path, UriKind.FILE_URI);
+  Uri uri = context.sourceFactory.restoreUri(fileSource);
+  if (uri == null) {
+    return null;
+  }
+  return uri.toString();
+}
+
+
+/**
  * TODO(scheglov) replace with nodes once there will be [CompilationUnit#getComments].
  *
  * Returns [SourceRange]s of all comments in [unit].
  */
 List<SourceRange> getCommentRanges(CompilationUnit unit) {
   List<SourceRange> ranges = <SourceRange>[];
   Token token = unit.beginToken;
   while (token != null && token.type != TokenType.EOF) {
     Token commentToken = token.precedingComments;
     while (commentToken != null) {
@@ skipping 150 matching lines @@
 /**
  * Returns the namespace of the given [ImportElement].
  */
 Map<String, Element> getImportNamespace(ImportElement imp) {
   NamespaceBuilder builder = new NamespaceBuilder();
   Namespace namespace = builder.createImportNamespaceForDirective(imp);
   return namespace.definedNames;
 }
 
 /**
+ * Computes the best URI to import [what] into [from].
+ */
+String getLibrarySourceUri(LibraryElement from, Source what) {
+  String whatFile = 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 = dirname(from.source.fullName);
+  String relativeFile = relative(whatFile, from: fromFolder);
+  return split(relativeFile).join('/');
+}
+
+/**
  * Returns the line prefix from the given source, i.e. basically just a
  * whitespace prefix of the given [String].
  */
 String getLinePrefix(String line) {
   int index = 0;
   while (index < line.length) {
     int c = line.codeUnitAt(index);
     if (!isWhitespace(c)) {
       break;
     }
     index++;
   }
   return line.substring(0, index);
 }
 
+
 /**
  * @return the [LocalVariableElement] or [ParameterElement] if given
  *         [SimpleIdentifier] is the reference to local variable or parameter, or
  *         <code>null</code> in the other case.
  */
 VariableElement getLocalOrParameterVariableElement(SimpleIdentifier node) {
   Element element = node.staticElement;
   if (element is LocalVariableElement) {
     return element;
   }
@@ skipping 133 matching lines @@
   }
   if (parent is PropertyAccess) {
     PropertyAccess access = parent;
     if (access.propertyName == node) {
       return access.realTarget;
     }
   }
   return null;
 }
 
-
 /**
  * Returns the given [Statement] if not a [Block], or the first child
  * [Statement] if a [Block], or `null` if more than one child.
  */
 Statement getSingleStatement(Statement statement) {
   if (statement is Block) {
     List<Statement> blockStatements = statement.statements;
     if (blockStatements.length != 1) {
       return null;
     }
     return blockStatements[0];
   }
   return statement;
 }
 
+
 /**
  * Returns the [String] content of the given [Source].
  */
 String getSourceContent(AnalysisContext context, Source source) {
   return context.getContents(source).data;
 }
 
 
 /**
  * Returns the given [Statement] if not a [Block], or all the children
@@ skipping 115 matching lines @@
   /**
    * Returns the [AstNode] that encloses the given offset.
    */
   AstNode findNode(int offset) =>
       new NodeLocator.con1(offset).searchWithin(unit);
 
   /**
    * Returns the actual type source of the given [Expression], may be `null`
    * if can not be resolved, should be treated as the `dynamic` type.
    */
-  String getExpressionTypeSource(Expression expression) {
+  String getExpressionTypeSource(Expression expression,
+      Set<LibraryElement> librariesToImport) {
     if (expression == null) {
       return null;
     }
     DartType type = expression.bestType;
     if (type.isDynamic) {
       return null;
     }
-    return getTypeSource(type);
+    return getTypeSource(type, librariesToImport);
   }
 
   /**
    * Returns the indentation with the given level.
    */
   String getIndent(int level) => repeat('  ', level);
 
   /**
    * Returns a [InsertDesc] describing where to insert a new library-related
    * directive.
@@ skipping 255 matching lines @@
   /**
    * Returns the text of the given [AstNode] in the unit.
    */
   String getNodeText(AstNode node) {
     return getText(node.offset, node.length);
   }
 
   /**
    * @return the source for the parameter with the given type and name.
    */
-  String getParameterSource(DartType type, String name) {
+  String getParameterSource(DartType type, String name,
+      Set<LibraryElement> librariesToImport) {
     // no type
     if (type == null || type.isDynamic) {
       return name;
     }
     // function type
     if (type is FunctionType) {
       FunctionType functionType = type;
       StringBuffer sb = new StringBuffer();
       // return type
       DartType returnType = functionType.returnType;
       if (returnType != null && !returnType.isDynamic) {
-        sb.write(getTypeSource(returnType));
+        sb.write(getTypeSource(returnType, librariesToImport));
         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));
+        sb.write(
+            getParameterSource(fParameter.type, fParameter.name, librariesToImport));
       }
       sb.write(')');
       // done
       return sb.toString();
     }
     // simple type
-    return "${getTypeSource(type)} ${name}";
+    String typeSource = getTypeSource(type, librariesToImport);
+    return '$typeSource $name';
   }
 
   /**
    * Returns the line prefix consisting of spaces and tabs on the left from the
    * given offset.
    */
   String getPrefix(int endIndex) {
     int startIndex = getLineContentStart(endIndex);
     return _buffer.substring(startIndex, endIndex);
   }
 
   /**
    * Returns the text of the given range in the unit.
    */
   String getRangeText(SourceRange range) {
     return getText(range.offset, range.length);
   }
 
   /**
    * Returns the text of the given range in the unit.
    */
   String getText(int offset, int length) {
     return _buffer.substring(offset, offset + length);
   }
 
   /**
    * 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) {
+  String getTypeSource(DartType type, Set<LibraryElement> librariesToImport) {
     StringBuffer sb = new StringBuffer();
     // just a Function, not FunctionTypeAliasElement
     if (type is FunctionType && type.element is! FunctionTypeAliasElement) {
       return "Function";
     }
     // prepare element
     Element element = type.element;
     if (element == null) {
       String source = type.toString();
       source = source.replaceAll('<dynamic>', '');
       source = source.replaceAll('<dynamic, dynamic>', '');
       return source;
     }
-    // append prefix
+    // check if imported
     {
-      ImportElement imp = _getImportElement(element);
-      if (imp != null && imp.prefix != null) {
-        sb.write(imp.prefix.displayName);
-        sb.write(".");
+      ImportElement importElement = _getImportElement(element);
+      if (importElement != null) {
+        if (importElement.prefix != null) {
+          sb.write(importElement.prefix.displayName);
+          sb.write(".");
+        }
+      } else {
+        librariesToImport.add(element.library);
       }
     }
     // 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;
       for (DartType argument in arguments) {
         if (!argument.isDynamic) {
           hasArguments = true;
           break;
         }
       }
       // append type arguments
       if (hasArguments) {
         sb.write("<");
         for (int i = 0; i < arguments.length; i++) {
           DartType argument = arguments[i];
           if (i != 0) {
             sb.write(", ");
           }
-          sb.write(getTypeSource(argument));
+          String argumentSrc = getTypeSource(argument, librariesToImport);
+          sb.write(argumentSrc);
         }
         sb.write(">");
       }
     }
     // done
     return sb.toString();
   }
 
   /**
    * Indents given source left or right.
@@ skipping 456 matching lines @@
 
   @override
   Object visitExpression(Expression node) {
     if (node is BinaryExpression && node.operator.type == groupOperatorType) {
       return super.visitNode(node);
     }
     operands.add(node);
     return null;
   }
 }