Finish 'Extract Local' refactoring.

pkg/analysis_server/lib/src/services/refactoring/extract_local.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_local;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol2.dart' show SourceEdit;
 import 'package:analysis_server/src/services/correction/change.dart';
+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/status.dart';
 import 'package:analysis_server/src/services/correction/strings.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/search/element_visitors.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 31 matching lines @@
   final List<SourceRange> occurrences = <SourceRange>[];
   final Set<String> excludedVariableNames = new Set<String>();
 
   ExtractLocalRefactoringImpl(this.unit, this.selectionOffset,
       this.selectionLength) {
     file = unit.element.source.fullName;
     selectionRange = new SourceRange(selectionOffset, selectionLength);
     utils = new CorrectionUtils(unit);
   }
 
-  String get declarationKeyword {
+  @override
+  String get refactoringName => 'Extract Local Variable';
+
+  String get _declarationKeyword {
     if (_isPartOfConstantExpression(rootExpression)) {
       return "const";
     } else {
       return "var";
     }
   }
 
   @override
-  String get refactoringName => 'Extract Local Variable';
-
-  @override
   Future<RefactoringStatus> checkFinalConditions() {
     RefactoringStatus result = new RefactoringStatus();
     if (excludedVariableNames.contains(name)) {
       result.addWarning(
           format(
               "A variable with name '{0}' is already defined in the visible scope.",
               name));
     }
     return new Future.value(result);
   }
 
   @override
   Future<RefactoringStatus> checkInitialConditions() {
     RefactoringStatus result = new RefactoringStatus();
     // selection
     result.addStatus(_checkSelection());
+    if (result.hasFatalError) {
+      return new Future.value(result);
+    }
     // occurrences
-    if (!result.hasFatalError) {
-      _prepareOccurrences();
-      _prepareExcludedNames();
-    }
-    // suggested names
+    _prepareOccurrences();
+    _prepareOffsetsLengths();
+    // names
+    _prepareExcludedNames();
     _prepareNames();
     // done
     return new Future.value(result);
   }
 
   @override
   RefactoringStatus checkName() {
     return validateVariableName(name);
   }
 
   @override
   Future<Change> createChange() {
     Change change = new Change(refactoringName);
     // prepare occurrences
     List<SourceRange> occurrences;
     if (extractAll) {
       occurrences = this.occurrences;
     } else {
       occurrences = [selectionRange];
     }
     // If the whole expression of a statement is selected, like '1 + 2',
     // then convert it into a variable declaration statement.
     if (wholeStatementExpression && occurrences.length == 1) {
-      String keyword = declarationKeyword;
+      String keyword = _declarationKeyword;
       String declarationSource = '$keyword $name = ';
       SourceEdit edit =
           new SourceEdit(singleExpression.offset, 0, declarationSource);
       change.addEdit(file, edit);
       return new Future.value(change);
     }
     // add variable declaration
     {
       String declarationSource;
       if (stringLiteralPart != null) {
         declarationSource = "var ${name} = '${stringLiteralPart}';";
       } else {
-        String keyword = declarationKeyword;
+        String keyword = _declarationKeyword;
         String initializerSource = utils.getRangeText(selectionRange);
         declarationSource = "${keyword} ${name} = ${initializerSource};";
       }
       // prepare location for declaration
       Statement targetStatement = _findTargetStatement(occurrences);
       String prefix = utils.getNodePrefix(targetStatement);
       // insert variable declaration
       String eol = utils.endOfLine;
       SourceEdit edit = new SourceEdit(
           targetStatement.offset,
@@ skipping 89 matching lines @@
   List<AstNode> _findNodes(List<SourceRange> ranges) {
     List<AstNode> nodes = <AstNode>[];
     for (SourceRange range in ranges) {
       AstNode node = new NodeLocator.con1(range.offset).searchWithin(unit);
       nodes.add(node);
     }
     return nodes;
   }
 
   /**
-   * @return the [Statement] such that variable declaration added before it will be visible in
-   *         all given occurrences.
+   * Returns the [Statement] such that variable declaration added before it is
+   * visible at all given occurrences.
    */
   Statement _findTargetStatement(List<SourceRange> occurrences) {
     List<AstNode> nodes = _findNodes(occurrences);
     List<AstNode> firstParents = getParents(nodes[0]);
     AstNode commonParent = getNearestCommonAncestor(nodes);
     if (commonParent is Block) {
       int commonIndex = firstParents.indexOf(commonParent);
       return firstParents[commonIndex + 1] as Statement;
     } else {
       return commonParent.getAncestor((node) => node is Statement);
     }
   }
 
   /**
-   * @return `true` if it is OK to extract the node with the given [SourceRange].
+   * Checks if it is OK to extract the node with the given [SourceRange].
    */
   bool _isExtractable(SourceRange range) {
     _ExtractExpressionAnalyzer analyzer = new _ExtractExpressionAnalyzer(range);
     utils.unit.accept(analyzer);
     return analyzer.status.isOK;
   }
 
   bool _isPartOfConstantExpression(AstNode node) {
     if (node is TypedLiteral) {
       return node.constKeyword != null;
     }
     if (node is InstanceCreationExpression) {
       InstanceCreationExpression creation = node;
       return creation.isConst;
     }
     if (node is ArgumentList ||
         node is ConditionalExpression ||
         node is BinaryExpression ||
         node is ParenthesizedExpression ||
         node is PrefixExpression ||
         node is Literal ||
         node is MapLiteralEntry) {
       return _isPartOfConstantExpression(node.parent);
     }
     return false;
   }
 
   void _prepareExcludedNames() {
     excludedVariableNames.clear();
-    // TODO(scheglov) clean up?
     AstNode enclosingNode =
         new NodeLocator.con1(selectionOffset).searchWithin(unit);
     Block enclosingBlock = enclosingNode.getAncestor((node) => node is Block);
     if (enclosingBlock != null) {
       SourceRange newVariableVisibleRange =
           rangeStartEnd(selectionRange, enclosingBlock.end);
       ExecutableElement enclosingExecutable =
           getEnclosingExecutableElement(enclosingNode);
       if (enclosingExecutable != null) {
         visitChildren(enclosingExecutable, (Element element) {
           if (element is LocalElement) {
             SourceRange elementRange = element.visibleRange;
             if (elementRange != null &&
                 elementRange.intersects(newVariableVisibleRange)) {
               excludedVariableNames.add(element.displayName);
             }
           }
           return true;
         });
       }
     }
   }
 
   void _prepareNames() {
     names.clear();
-    // TODO(scheglov) implement
-//    Set<String> excluded = excludedVariableNames;
-//    if (_stringLiteralPart != null) {
-//      return getVariableNameSuggestions(_stringLiteralPart, excluded);
-//    } else if (_singleExpression != null) {
-//      _guessedNames = CorrectionUtils.getVariableNameSuggestions2(_singleExpression.staticType, _singleExpression, excluded);
-//    } else {
-//      _guessedNames = ArrayUtils.EMPTY_STRING_ARRAY;
-//    }
+    if (stringLiteralPart != null) {
+      names.addAll(
+          getVariableNameSuggestionsForText(stringLiteralPart, excludedVariableNames));
+    } else if (singleExpression != null) {
+      names.addAll(
+          getVariableNameSuggestionsForExpression(
+              singleExpression.staticType,
+              singleExpression,
+              excludedVariableNames));
+    }
   }
 
   /**
-   * @return all occurrences of the source which matches given selection, sorted by offset. First
-   *         [SourceRange] is same as the given selection. May be empty, but not
-   *         <code>null</code>.
+   * Prepares all occurrences of the source which matches given selection,
+   * sorted by offsets.
    */
-  List<SourceRange> _prepareOccurrences() {
+  void _prepareOccurrences() {
+    occurrences.clear();
     // prepare selection
     String selectionSource;
     {
       String rawSelectionSource = utils.getRangeText(selectionRange);
       List<Token> selectionTokens = TokenUtils.getTokens(rawSelectionSource);
       selectionSource = selectionTokens.join(_TOKEN_SEPARATOR);
     }
     // prepare enclosing function
     AstNode enclosingFunction;
     {
       AstNode selectionNode =
           new NodeLocator.con1(selectionOffset).searchWithin(unit);
       enclosingFunction = getEnclosingExecutableNode(selectionNode);
     }
     // visit function
     enclosingFunction.accept(
         new _OccurrencesVisitor(this, occurrences, selectionSource));
-    // done
-    return occurrences;
+  }
+
+  void _prepareOffsetsLengths() {
+    offsets.clear();
+    lengths.clear();
+    for (SourceRange occurrence in occurrences) {
+      offsets.add(occurrence.offset);
+      lengths.add(occurrence.length);
+    }
   }
 }
 
 
 /**
  * [SelectionAnalyzer] for [ExtractLocalRefactoringImpl].
  */
 class _ExtractExpressionAnalyzer extends SelectionAnalyzer {
   final RefactoringStatus status = new RefactoringStatus();
 
@@ skipping 44 matching lines @@
   }
 
   /**
    * Records fatal error with given message and [RefactoringStatusContext].
    */
   void _invalidSelection(String message, RefactoringStatusContext context) {
     status.addFatalError(message, context);
     reset();
   }
 
-  bool _isFirstSelectedNode(AstNode node) => identical(firstSelectedNode, node);
+  bool _isFirstSelectedNode(AstNode node) => node == firstSelectedNode;
 }
 
 
 class _HasStatementVisitor extends GeneralizingAstVisitor {
   final List<bool> result;
 
   _HasStatementVisitor(this.result);
 
   @override
   visitStatement(Statement node) {
     result[0] = true;
   }
 }
 
 
 class _OccurrencesVisitor extends GeneralizingAstVisitor<Object> {
   final ExtractLocalRefactoringImpl ref;
-
-  List<SourceRange> occurrences;
-
-  String selectionSource;
+  final List<SourceRange> occurrences;
+  final String selectionSource;
 
   _OccurrencesVisitor(this.ref, this.occurrences, this.selectionSource);
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     if (!_hasStatements(node)) {
       _tryToFindOccurrenceFragment(node);
       return null;
     }
     return super.visitBinaryExpression(node);
@@ skipping 75 matching lines @@
       Token startToken = nodeTokens[startTokenIndex];
       Token endToken = nodeTokens[endTokenIndex];
       // add occurrence range
       int occuStart = nodeOffset + startToken.offset;
       int occuEnd = nodeOffset + endToken.end;
       SourceRange occuRange = rangeStartEnd(occuStart, occuEnd);
       _addOccurrence(occuRange);
     }
   }
 }