Impements 'names', 'offsets' and 'lengths' for ExtractMethodRefactoring.

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.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/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 
 const String _TOKEN_SEPARATOR = '\uFFFF';
 
@@ skipping 35 matching lines @@
 
   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;
@@ skipping 91 matching lines @@
   Future<RefactoringStatus> checkInitialConditions() {
     RefactoringStatus result = new RefactoringStatus();
     // selection
     result.addStatus(_checkSelection());
     if (result.hasFatalError) {
       return new Future.value(result);
     }
     // prepare parts
     result.addStatus(_initializeParameters());
     _initializeReturnType();
+    _initializeGetter();
+    // occurrences
     _initializeOccurrences();
-    _initializeGetter();
+    _prepareOffsetsLengths();
+    // names
+    _prepareExcludedNames();
+    _prepareNames();
     // closure cannot have parameters
     if (_selectionFunctionExpression != null && !_parameters.isEmpty) {
       String message = format(
           'Cannot extract closure as method, it references {0} external variable(s).',
           _parameters.length);
       RefactoringStatus result = new RefactoringStatus.fatal(message);
       return new Future.value(result);
     }
     return new Future.value(result);
   }
@@ skipping 244 matching lines @@
           return new RefactoringStatus();
         }
       }
     }
     // invalid selection
     return new RefactoringStatus.fatal(
         'Can only extract a single expression or a set of statements.');
   }
 
   /**
-   * @return the selected [DartExpression] source, with applying new parameter names.
+   * Returns the selected [Expression] source, with applying new parameter
+   * names.
    */
   String _getMethodBodySource() {
     String source = utils.getRangeText(selectionRange);
     // prepare operations to replace variables with parameters
     List<SourceEdit> replaceEdits = [];
     for (RefactoringMethodParameter parameter in _parametersMap.values) {
       List<SourceRange> ranges = _parameterReferencesMap[parameter.id];
       if (ranges != null) {
         for (SourceRange range in ranges) {
           replaceEdits.add(
@@ skipping 172 matching lines @@
   /**
    * Checks if [element] is referenced after [selectionRange].
    */
   bool _isUsedAfterSelection(VariableElement element) {
     var visitor = new _IsUsedAfterSelectionVisitor(this, element);
     _parentMember.accept(visitor);
     return visitor.result;
   }
 
   /**
+   * Prepare names that are used in the enclosing function, so should not be
+   * proposed as names of the extracted method.
+   */
+  void _prepareExcludedNames() {
+    _excludedNames.clear();
+    ExecutableElement enclosingExecutable =
+        getEnclosingExecutableElement(_parentMember);
+    if (enclosingExecutable != null) {
+      visitChildren(enclosingExecutable, (Element element) {
+        if (element is LocalElement) {
+          SourceRange elementRange = element.visibleRange;
+          if (elementRange != null) {
+            _excludedNames.add(element.displayName);
+          }
+        }
+        return true;
+      });
+    }
+  }
+
+  void _prepareNames() {
+    names.clear();
+    if (_selectionExpression != null) {
+      names.addAll(
+          getVariableNameSuggestionsForExpression(
+              _selectionExpression.staticType,
+              _selectionExpression,
+              _excludedNames));
+    }
+  }
+
+  void _prepareOffsetsLengths() {
+    offsets.clear();
+    lengths.clear();
+    for (_Occurrence occurrence in _occurrences) {
+      offsets.add(occurrence.range.offset);
+      lengths.add(occurrence.range.length);
+    }
+  }
+
+  /**
    * Checks if [node] has a [MethodInvocation].
    */
   static bool _hasMethodInvocation(AstNode node) {
     var visitor = new _HasMethodInvocationVisitor();
     node.accept(visitor);
     return visitor.result;
   }
 }
 
 
@@ skipping 393 matching lines @@
 
 /**
  * Generalized version of some source, in which references to the specific
  * variables are replaced with pattern variables, with back mapping from the
  * pattern to the original variable names.
  */
 class _SourcePattern {
   String patternSource;
   Map<String, String> originalToPatternNames = {};
 }