Issue 20827. Extract library importing helper and use it fox Quick Fixes.

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/protocol_server.dart' show
+    doSourceChange_addElementEdit;
 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';
 
 
 /**
+ * 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<LibraryElement> libraries) {
+  CompilationUnit libUnit = targetLibrary.definingCompilationUnit.node;
+  // prepare new import location
+  int offset = 0;
+  String prefix;
+  String suffix;
+  {
+    // if no directives
+    prefix = '';
+    CorrectionUtils libraryUtils = new CorrectionUtils(libUnit);
+    String eol = libraryUtils.endOfLine;
+    suffix = eol;
+    // after last directive in library
+    for (Directive directive in libUnit.directives) {
+      if (directive is LibraryDirective || directive is ImportDirective) {
+        offset = directive.end;
+        prefix = eol;
+        suffix = '';
+      }
+    }
+    // if still at the beginning of the file, skip shebang and line comments
+    if (offset == 0) {
+      CorrectionUtils_InsertDesc desc = libraryUtils.getInsertDescTop();
+      offset = desc.offset;
+      prefix = desc.prefix;
+      suffix = desc.suffix + eol;
+    }
+  }
+  // insert imports
+  for (LibraryElement library in libraries) {
+    String importPath = getLibrarySourceUri(targetLibrary, library.source);
+    String importCode = "${prefix}import '$importPath';$suffix";
+    doSourceChange_addElementEdit(
+        change,
+        targetLibrary,
+        new SourceEdit(offset, 0, importCode));
+  }
+}
+
+
+/**
  * @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;
     }
   }
   return true;
@@ skipping 51 matching lines @@
     while (commentToken != null) {
       ranges.add(rangeToken(commentToken));
       commentToken = commentToken.next;
     }
     token = token.next;
   }
   return ranges;
 }
 
 
+
 String getDefaultValueCode(DartType type) {
   if (type != null) {
     String typeName = type.displayName;
     if (typeName == "bool") {
       return "false";
     }
     if (typeName == "int") {
       return "0";
     }
     if (typeName == "double") {
       return "0.0";
     }
     if (typeName == "String") {
       return "''";
     }
   }
   // no better guess
   return "null";
 }
 
-
-
 /**
  * Return the name of the [Element] kind.
  */
 String getElementKindName(Element element) {
   return element.kind.displayName;
 }
 
+
 /**
  * Returns the name to display in the UI for the given [Element].
  */
 String getElementQualifiedName(Element element) {
   ElementKind kind = element.kind;
   if (kind == ElementKind.FIELD || kind == ElementKind.METHOD) {
     return '${element.enclosingElement.displayName}.${element.displayName}';
   } else {
     return element.displayName;
   }
@@ skipping 46 matching lines @@
     }
     if (node is MethodDeclaration) {
       return node.element;
     }
     node = node.parent;
   }
   return null;
 }
 
 
+
 /**
  * @return the enclosing executable [AstNode].
  */
 AstNode getEnclosingExecutableNode(AstNode node) {
   while (node != null) {
     if (node is FunctionDeclaration) {
       return node;
     }
     if (node is ConstructorDeclaration) {
       return node;
@@ skipping 751 matching lines @@
     }
     // 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
-    if (element.library != _library) {
+    LibraryElement library = element.library;
+    if (library != null && library != _library) {
       ImportElement importElement = _getImportElement(element);
       if (importElement != null) {
         if (importElement.prefix != null) {
           sb.write(importElement.prefix.displayName);
           sb.write(".");
         }
       } else {
-        librariesToImport.add(element.library);
+        librariesToImport.add(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;
@@ skipping 14 matching lines @@
           sb.write(argumentSrc);
         }
         sb.write(">");
       }
     }
     // done
     return sb.toString();
   }
 
   /**
-   * Checks if [type] is visible at [targetOffset].
-   */
-  bool _isTypeVisible(DartType type) {
-    if (type is TypeParameterType) {
-      TypeParameterElement parameterElement = type.element;
-      Element parameterClassElement = parameterElement.enclosingElement;
-      return identical(parameterClassElement, targetClassElement);
-    }
-    return true;
-  }
-
-  /**
    * Indents given source left or right.
    */
   String indentSourceLeftRight(String source, bool right) {
     StringBuffer sb = new StringBuffer();
     String indent = getIndent(1);
     String eol = endOfLine;
     List<String> lines = source.split(eol);
     for (int i = 0; i < lines.length; i++) {
       String line = lines[i];
       // last line, stop if empty
@@ skipping 226 matching lines @@
       }
       return _invertCondition0(innerExpresion);
     }
     DartType type = expression.bestType;
     if (type.displayName == "bool") {
       return _InvertedCondition._simple("!${getNodeText(expression)}");
     }
     return _InvertedCondition._simple(getNodeText(expression));
   }
 
+  /**
+   * Checks if [type] is visible at [targetOffset].
+   */
+  bool _isTypeVisible(DartType type) {
+    if (type is TypeParameterType) {
+      TypeParameterElement parameterElement = type.element;
+      Element parameterClassElement = parameterElement.enclosingElement;
+      return identical(parameterClassElement, targetClassElement);
+    }
+    return true;
+  }
+
   bool _selectionIncludesNonWhitespaceOutsideOperands(SourceRange selection,
       List<Expression> operands) {
     return _selectionIncludesNonWhitespaceOutsideRange(
         selection,
         rangeNodes(operands));
   }
 
   /**
    * @return <code>true</code> if "selection" covers "range" and there are any non-whitespace tokens
    *         between "selection" and "range" start/end.
@@ skipping 201 matching lines @@
 
   @override
   Object visitExpression(Expression node) {
     if (node is BinaryExpression && node.operator.type == groupOperatorType) {
       return super.visitNode(node);
     }
     operands.add(node);
     return null;
   }
 }