Add libraries in corrections using SourceInfo instance of LibraryElement.

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/plugin/protocol/protocol.dart'
     show SourceChange, SourceEdit;
@@ skipping 11 matching lines @@
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.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) {
+void addLibraryImports(
+    SourceChange change, LibraryElement targetLibrary, Set<Source> libraries) {
   CorrectionUtils libUtils;
   try {
     CompilationUnitElement unitElement = targetLibrary.definingCompilationUnit;
     CompilationUnit unitAst = getParsedUnit(unitElement);
     libUtils = new CorrectionUtils(unitAst);
   } catch (e) {
     throw new CancelCorrectionException(exception: e);
   }
   String eol = libUtils.endOfLine;
   // Prepare information about existing imports.
   LibraryDirective libraryDirective;
   List<_ImportDirectiveInfo> importDirectives = <_ImportDirectiveInfo>[];
   for (Directive directive in libUtils.unit.directives) {
     if (directive is LibraryDirective) {
       libraryDirective = directive;
     } else if (directive is ImportDirective) {
       importDirectives.add(new _ImportDirectiveInfo(
           directive.uriContent, directive.offset, directive.end));
     }
   }
 
   // Prepare all URIs to import.
   List<String> uriList = libraries
-      .map((library) => getLibrarySourceUri(targetLibrary, library.source))
+      .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;
@@ skipping 292 matching lines @@
 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;
+  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 = dirname(from.source.fullName);
-  String relativeFile = relative(whatFile, from: fromFolder);
+  String relativeFile = relative(whatPath, 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) {
@@ skipping 368 matching lines @@
       return visitor.names;
     }
     return conflicts;
   }
 
   /**
    * 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, Set<LibraryElement> librariesToImport) {
+      Expression expression, Set<Source> librariesToImport) {
     if (expression == null) {
       return null;
     }
     DartType type = expression.bestType;
     if (type.isDynamic) {
       return null;
     }
     return getTypeSource(type, librariesToImport);
   }
 
@@ skipping 268 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, Set<LibraryElement> librariesToImport) {
+      DartType type, String name, Set<Source> librariesToImport) {
     // 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;
@@ skipping 46 matching lines @@
   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, Set<LibraryElement> librariesToImport,
+  String getTypeSource(DartType type, Set<Source> librariesToImport,
       {StringBuffer parametersBuffer}) {
     StringBuffer sb = new StringBuffer();
     // type parameter
     if (!_isTypeVisible(type)) {
       return 'dynamic';
     }
     // just a Function, not FunctionTypeAliasElement
     if (type is FunctionType && type.element is! FunctionTypeAliasElement) {
       if (parametersBuffer == null) {
         return "Function";
@@ skipping 31 matching lines @@
         return null;
       }
       // ensure import
       ImportElement importElement = _getImportElement(element);
       if (importElement != null) {
         if (importElement.prefix != null) {
           sb.write(importElement.prefix.displayName);
           sb.write(".");
         }
       } else {
-        librariesToImport.add(library);
+        librariesToImport.add(library.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;
@@ skipping 474 matching lines @@
       _InvertedCondition expr, int newOperatorPrecedence) {
     if (expr._precedence < newOperatorPrecedence) {
       return "(${expr._source})";
     }
     return expr._source;
   }
 
   static _InvertedCondition _simple(String source) =>
       new _InvertedCondition(2147483647, source);
 }