Issue 20827. Import required type in 'Extract Method' refactoring.

pkg/analysis_server/lib/src/services/refactoring/extract_method.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.refactoring.extract_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/name_suggestion.dart';
 import 'package:analysis_server/src/services/correction/selection_analyzer.dart';
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/correction/statement_analyzer.dart';
 import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analysis_server/src/services/refactoring/naming_conventions.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring_internal.dart';
 import 'package:analysis_server/src/services/refactoring/rename_class_member.dart';
 import 'package:analysis_server/src/services/refactoring/rename_unit_member.dart';
 import 'package:analysis_server/src/services/search/element_visitors.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/java_core.dart';
+import 'package:analyzer/src/generated/resolver.dart' show ExitDetector;
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/generated/resolver.dart' show ExitDetector;
 
 
 const String _TOKEN_SEPARATOR = '\uFFFF';
 
 
 /**
  * Returns the "normalized" version of the given source, which is reconstructed
  * from tokens, so ignores all the comments and spaces.
  */
 String _getNormalizedSource(String src) {
@@ skipping 21 matching lines @@
     ExtractMethodRefactoring {
   static const ERROR_EXITS =
       'Selected statements contain a return statement, but not all possible '
           'execuion flows exit. Semantics may not be preserved.';
 
   final SearchEngine searchEngine;
   final CompilationUnit unit;
   final int selectionOffset;
   final int selectionLength;
   CompilationUnitElement unitElement;
+  LibraryElement libraryElement;
   SourceRange selectionRange;
   CorrectionUtils utils;
+  Set<LibraryElement> librariesToImport = new Set<LibraryElement>();
 
   String returnType;
   String name;
   bool extractAll = true;
   bool createGetter = false;
   final List<String> names = <String>[];
   final List<int> offsets = <int>[];
   final List<int> lengths = <int>[];
 
   Set<String> _usedNames = new Set<String>();
   Set<String> _excludedNames = new Set<String>();
   List<RefactoringMethodParameter> _parameters = <RefactoringMethodParameter>[];
   Map<String, RefactoringMethodParameter> _parametersMap = <String,
       RefactoringMethodParameter>{};
   Map<String, List<SourceRange>> _parameterReferencesMap = <String,
       List<SourceRange>>{};
   DartType _returnType;
   String _returnVariableName;
   AstNode _parentMember;
   Expression _selectionExpression;
   FunctionExpression _selectionFunctionExpression;
   List<Statement> _selectionStatements;
   List<_Occurrence> _occurrences = [];
   bool _staticContext = false;
 
   ExtractMethodRefactoringImpl(this.searchEngine, this.unit,
       this.selectionOffset, this.selectionLength) {
     unitElement = unit.element;
+    libraryElement = unitElement.library;
     selectionRange = new SourceRange(selectionOffset, selectionLength);
     utils = new CorrectionUtils(unit);
   }
 
   bool get canCreateGetter {
     if (!parameters.isEmpty) {
       return false;
     }
     if (_selectionExpression != null) {
       if (_selectionExpression is AssignmentExpression) {
@@ skipping 97 matching lines @@
     }
     return new Future.value(result);
   }
 
   @override
   RefactoringStatus checkName() {
     return validateMethodName(name);
   }
 
   @override
-  Future<SourceChange> createChange() {
+  Future<SourceChange> createChange() async {
     SourceChange change = new SourceChange(refactoringName);
     // replace occurrences with method invocation
     for (_Occurrence occurence in _occurrences) {
       SourceRange range = occurence.range;
       // may be replacement of duplicates disabled
       if (!extractAll && !occurence.isSelection) {
         continue;
       }
       // prepare invocation source
       String invocationSource;
@@ skipping 74 matching lines @@
         // closure
         if (_selectionFunctionExpression != null) {
           declarationSource = '${name}${returnExpressionSource}';
           if (_selectionFunctionExpression.body is ExpressionFunctionBody) {
             declarationSource += ';';
           }
         }
         // expression
         if (_selectionExpression != null) {
           // add return type
-          Set<LibraryElement> librariesToImport = new Set<LibraryElement>();
-          // TODO(scheglov) use librariesToImport
-          String returnTypeName =
-              utils.getExpressionTypeSource(_selectionExpression, librariesToImport);
-          if (returnTypeName != null && returnTypeName != 'dynamic') {
-            annotations += '${returnTypeName} ';
+          if (returnType.isNotEmpty) {
+            annotations += '$returnType ';
           }
           // just return expression
           declarationSource =
               '${annotations}${signature} => ${returnExpressionSource};';
         }
         // statements
         if (_selectionStatements != null) {
           if (returnType.isNotEmpty) {
             annotations += returnType + ' ';
           }
           declarationSource = '${annotations}${signature} {${eol}';
           declarationSource += returnExpressionSource;
           if (_returnVariableName != null) {
             declarationSource +=
                 '${prefix}  return ${_returnVariableName};$eol';
           }
           declarationSource += '${prefix}}';
         }
       }
       // insert declaration
       if (declarationSource != null) {
         int offset = _parentMember.end;
         SourceEdit edit =
             new SourceEdit(offset, 0, '${eol}${eol}${prefix}${declarationSource}');
         doSourceChange_addElementEdit(change, unitElement, edit);
       }
     }
     // done
-    return new Future.value(change);
+    addLibraryImports(change, libraryElement, librariesToImport);
+    return change;
   }
 
   @override
   bool requiresPreview() => false;
 
   /**
    * Adds a new reference to the parameter with the given name.
    */
   void _addParameterReference(String name, SourceRange range) {
     List<SourceRange> references = _parameterReferencesMap[name];
@@ skipping 20 matching lines @@
             format("'{0}' is already used as a name in the selected code", parameter.name));
         return result;
       }
     }
     return result;
   }
 
   /**
    * Checks if created method will shadow or will be shadowed by other elements.
    */
-  Future<RefactoringStatus> _checkPossibleConflicts() {
+  Future<RefactoringStatus> _checkPossibleConflicts() async {
     RefactoringStatus result = new RefactoringStatus();
     AstNode parent = _parentMember.parent;
     // top-level function
     if (parent is CompilationUnit) {
       LibraryElement libraryElement = parent.element.library;
       return validateCreateFunction(searchEngine, libraryElement, name);
     }
     // method of class
     if (parent is ClassDeclaration) {
       ClassElement classElement = parent.element;
@@ skipping 107 matching lines @@
     String originalSource = utils.getText(range.offset, range.length);
     _SourcePattern pattern = new _SourcePattern();
     List<SourceEdit> replaceEdits = <SourceEdit>[];
     unit.accept(new _GetSourcePatternVisitor(range, pattern, replaceEdits));
     replaceEdits = replaceEdits.reversed.toList();
     String source = SourceEdit.applySequence(originalSource, replaceEdits);
     pattern.normalizedSource = _getNormalizedSource(source);
     return pattern;
   }
 
+  String _getTypeCode(DartType type) {
+    return utils.getTypeSource(type, librariesToImport);
+  }
+
   /**
    * Initializes [createGetter] flag.
    */
   void _initializeGetter() {
     createGetter = false;
     // maybe we cannot at all
     if (!canCreateGetter) {
       return;
     }
     // OK, just expression
@@ skipping 94 matching lines @@
               sb.toString().trim()));
     }
     // done
     return result;
   }
 
   void _initializeReturnType() {
     if (_returnType == null) {
       returnType = 'void';
     } else {
-      Set<LibraryElement> librariesToImport = new Set<LibraryElement>();
-      // TODO(scheglov) use librariesToImport
-      returnType = utils.getTypeSource(_returnType, librariesToImport);
+      returnType = _getTypeCode(_returnType);
     }
     if (returnType == 'dynamic') {
       returnType = '';
     }
   }
 
   /**
    * Checks if the given [VariableElement] is declared in [selectionRange].
    */
   bool _isDeclaredInSelection(VariableElement element) {
@@ skipping 383 matching lines @@
           return null;
         }
         // if declared outside, add parameter
         if (!ref._isDeclaredInSelection(variableElement)) {
           String variableName = variableElement.displayName;
           // add parameter
           RefactoringMethodParameter parameter =
               ref._parametersMap[variableName];
           if (parameter == null) {
             DartType parameterType = node.bestType;
-            Set<LibraryElement> librariesToImport = new Set<LibraryElement>();
-            // TODO(scheglov) use librariesToImport
-            String parameterTypeName =
-                ref.utils.getTypeSource(parameterType, librariesToImport);
+            String parameterTypeCode = ref._getTypeCode(parameterType);
             parameter = new RefactoringMethodParameter(
                 RefactoringMethodParameterKind.REQUIRED,
-                parameterTypeName,
+                parameterTypeCode,
                 variableName,
                 id: variableName);
             ref._parameters.add(parameter);
             ref._parametersMap[variableName] = parameter;
           }
           // add reference to parameter
           ref._addParameterReference(variableName, nodeRange);
         }
         // remember, if assigned and used after selection
         if (isLeftHandOfAssignment(node) &&
@@ skipping 129 matching lines @@
       return false;
     }
     for (int i = 0; i < parameterTypes.length; i++) {
       if (other.parameterTypes[i] != parameterTypes[i]) {
         return false;
       }
     }
     return true;
   }
 }