Parameters and validation for the '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.dart' hide Element;
 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/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";
+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) {
   List<Token> selectionTokens = TokenUtils.getTokens(src);
   return StringUtils.join(selectionTokens, _TOKEN_SEPARATOR);
 }
@@ skipping 62 matching lines @@
       if (_selectionExpression is AssignmentExpression) {
         return false;
       }
     }
     if (_selectionStatements != null) {
       return returnType != null;
     }
     return true;
   }
 
-  /**
-   * @return the selected [DartExpression] source, with applying new parameter names.
-   */
-  String get methodBodySource {
-    String source = utils.getRangeText(selectionRange);
-    // prepare ReplaceEdit operations to replace variables with parameters
-    // TODO: implement parameters
-    List<SourceEdit> replaceEdits = [];
-//    for (Parameter parameter in _parametersMap.values) {
-//      List<SourceRange> ranges = _parameterReferencesMap[parameter.oldName];
-//      if (ranges != null) {
-//        for (SourceRange range in ranges) {
-//          replaceEdits.add(new SourceEdit(range.offset - selectionRange.offset, range.length, parameter.newName));
-//        }
-//      }
-//    }
-    // apply replacements
-    source = SourceEdit.applySequence(source, replaceEdits);
-    // change indentation
-    if (_selectionFunctionExpression != null) {
-      AstNode baseNode =
-          _selectionFunctionExpression.getAncestor((node) => node is Statement);
-      if (baseNode != null) {
-        String baseIndent = utils.getNodePrefix(baseNode);
-        String targetIndent = utils.getNodePrefix(_parentMember);
-        source = utils.replaceSourceIndent(source, baseIndent, targetIndent);
-        source = source.trim();
-      }
-    }
-    if (_selectionStatements != null) {
-      String selectionIndent = utils.getNodePrefix(_selectionStatements[0]);
-      String targetIndent = utils.getNodePrefix(_parentMember) + '  ';
-      source = utils.replaceSourceIndent(source, selectionIndent, targetIndent);
-    }
-    // done
-    return source;
-  }
-
   @override
   List<RefactoringMethodParameter> get parameters => _parameters;
 
   @override
   void set parameters(List<RefactoringMethodParameter> parameters) {
-    // TODO: implement parameters
+    _parameters = parameters.toList();
   }
 
   @override
   String get refactoringName {
     AstNode node = new NodeLocator.con1(selectionOffset).searchWithin(unit);
     if (node != null &&
         node.getAncestor((node) => node is ClassDeclaration) != null) {
       return 'Extract Method';
     }
     return 'Extract Function';
   }
 
   String get signature {
     StringBuffer sb = new StringBuffer();
     if (createGetter) {
-      sb.write("get ");
+      sb.write('get ');
       sb.write(name);
     } else {
       sb.write(name);
-      sb.write("(");
+      sb.write('(');
       // add all parameters
       bool firstParameter = true;
       for (RefactoringMethodParameter parameter in _parameters) {
         // may be comma
         if (firstParameter) {
           firstParameter = false;
         } else {
           sb.write(', ');
         }
         // type
         {
           String typeSource = parameter.type;
           if ('dynamic' != typeSource && '' != typeSource) {
             sb.write(typeSource);
-            sb.write(" ");
+            sb.write(' ');
           }
         }
         // name
         sb.write(parameter.name);
       }
-      sb.write(")");
+      sb.write(')');
     }
     // done
     return sb.toString();
   }
 
   @override
   Future<RefactoringStatus> checkFinalConditions() {
     RefactoringStatus result = new RefactoringStatus();
+    result.addStatus(validateMethodName(name));
+    result.addStatus(_checkParameterNames());
+    // TODO: implement checkFinalConditions
+    return _checkPossibleConflicts().then((status) {
+      result.addStatus(status);
+      return result;
+    });
     return new Future.value(result);
-    // TODO: implement checkFinalConditions
   }
 
+
   @override
   Future<RefactoringStatus> checkInitialConditions() {
     RefactoringStatus result = new RefactoringStatus();
     // selection
     result.addStatus(_checkSelection());
     if (result.hasFatalError) {
       return new Future.value(result);
     }
     // prepare parts
     result.addStatus(_initializeParameters());
@@ skipping 50 matching lines @@
             // assign the return value
             sb.write(occurrenceName);
             sb.write(' = ');
           } else {
             sb.write('return ');
           }
         }
         // invocation itself
         sb.write(name);
         if (!createGetter) {
-          sb.write("(");
+          sb.write('(');
           bool firstParameter = true;
           for (RefactoringMethodParameter parameter in _parameters) {
             // may be comma
             if (firstParameter) {
               firstParameter = false;
             } else {
               sb.write(', ');
             }
             // argument name
             {
@@ skipping 13 matching lines @@
       // add replace edit
       SourceEdit edit = new SourceEdit.range(range, invocationSource);
       change.addEdit(file, edit);
     }
     // add method declaration
     {
       // prepare environment
       String prefix = utils.getNodePrefix(_parentMember);
       String eol = utils.endOfLine;
       // prepare annotations
-      String annotations = "";
+      String annotations = '';
       {
         // may be "static"
         if (_staticContext) {
           annotations = 'static ';
         }
       }
       // prepare declaration source
       String declarationSource = null;
       {
-        String returnExpressionSource = methodBodySource;
+        String returnExpressionSource = _getMethodBodySource();
         // closure
         if (_selectionFunctionExpression != null) {
-          declarationSource = "${name}${returnExpressionSource}";
+          declarationSource = '${name}${returnExpressionSource}';
           if (_selectionFunctionExpression.body is ExpressionFunctionBody) {
             declarationSource += ';';
           }
         }
         // expression
         if (_selectionExpression != null) {
           // add return type
           String returnTypeName =
               utils.getExpressionTypeSource(_selectionExpression);
-          if (returnTypeName != null && returnTypeName != "dynamic") {
-            annotations += "${returnTypeName} ";
+          if (returnTypeName != null && returnTypeName != 'dynamic') {
+            annotations += '${returnTypeName} ';
           }
           // just return expression
           declarationSource =
-              "${annotations}${signature} => ${returnExpressionSource};";
+              '${annotations}${signature} => ${returnExpressionSource};';
         }
         // statements
         if (_selectionStatements != null) {
           if (returnType != null) {
             if (returnType.isNotEmpty) {
               annotations += returnType + ' ';
             }
           } else {
             annotations += 'void ';
           }
-          declarationSource = "${annotations}${signature} {${eol}";
+          declarationSource = '${annotations}${signature} {${eol}';
           declarationSource += returnExpressionSource;
           if (_returnVariableName != null) {
             declarationSource +=
                 '${prefix}  return ${_returnVariableName};$eol';
           }
           declarationSource += '${prefix}}';
         }
       }
       // insert declaration
       if (declarationSource != null) {
@@ skipping 15 matching lines @@
    */
   void _addParameterReference(String name, SourceRange range) {
     List<SourceRange> references = _parameterReferencesMap[name];
     if (references == null) {
       references = [];
       _parameterReferencesMap[name] = references;
     }
     references.add(range);
   }
 
+  RefactoringStatus _checkParameterNames() {
+    RefactoringStatus result = new RefactoringStatus();
+    for (RefactoringMethodParameter parameter in _parameters) {
+      result.addStatus(validateParameterName(parameter.name));
+      for (RefactoringMethodParameter other in _parameters) {
+        if (!identical(parameter, other) && other.name == parameter.name) {
+          result.addError(
+              format("Parameter '{0}' already exists", parameter.name));
+          return result;
+        }
+      }
+      if (_usedNames.contains(parameter.name)) {
+        result.addError(
+            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() {
+    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;
+      return validateCreateMethod(searchEngine, classElement, name);
+    }
+    // OK
+    return new Future.value(result);
+  }
+
   /**
    * Checks if [selectionRange] selects [Expression] which can be extracted, and
    * location of this [DartExpression] in AST allows extracting.
    */
   RefactoringStatus _checkSelection() {
     _ExtractMethodAnalyzer selectionAnalyzer =
         new _ExtractMethodAnalyzer(unit, selectionRange);
     unit.accept(selectionAnalyzer);
     // may be fatal error
     {
@@ skipping 37 matching lines @@
           _selectionStatements = selectedStatements;
           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.
+   */
+  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(
+              new SourceEdit(
+                  range.offset - selectionRange.offset,
+                  range.length,
+                  parameter.name));
+        }
+      }
+    }
+    replaceEdits.sort((a, b) => b.offset - a.offset);
+    // apply replacements
+    source = SourceEdit.applySequence(source, replaceEdits);
+    // change indentation
+    if (_selectionFunctionExpression != null) {
+      AstNode baseNode =
+          _selectionFunctionExpression.getAncestor((node) => node is Statement);
+      if (baseNode != null) {
+        String baseIndent = utils.getNodePrefix(baseNode);
+        String targetIndent = utils.getNodePrefix(_parentMember);
+        source = utils.replaceSourceIndent(source, baseIndent, targetIndent);
+        source = source.trim();
+      }
+    }
+    if (_selectionStatements != null) {
+      String selectionIndent = utils.getNodePrefix(_selectionStatements[0]);
+      String targetIndent = utils.getNodePrefix(_parentMember) + '  ';
+      source = utils.replaceSourceIndent(source, selectionIndent, targetIndent);
+    }
+    // done
+    return source;
+  }
+
   _SourcePattern _getSourcePattern(SourceRange range) {
     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();
     pattern.patternSource =
         SourceEdit.applySequence(originalSource, replaceEdits);
     return pattern;
   }
@@ skipping 25 matching lines @@
         // don't allow cycles
         statement.accept(new _ResetCanCreateGetterVisitor(this));
       }
     }
   }
 
   /**
    * Fills [_occurrences] field.
    */
   void _initializeOccurrences() {
+    _occurrences.clear();
     // prepare selection
     _SourcePattern selectionPattern = _getSourcePattern(selectionRange);
     String selectionSource =
         _getNormalizedSource(selectionPattern.patternSource);
     Map<String, String> patternToSelectionName =
         _inverseMap(selectionPattern.originalToPatternNames);
     // prepare an enclosing parent - class or unit
     AstNode enclosingMemberParent = _parentMember.parent;
     // visit nodes which will able to access extracted method
     enclosingMemberParent.accept(
@@ skipping 23 matching lines @@
         if (expression != null) {
           _returnType = expression.bestType;
         }
       }
     }
     // may be single variable to return
     if (assignedUsedVariables.length == 1) {
       // we cannot both return variable and have explicit return statement
       if (_returnType != null) {
         result.addFatalError(
-            "Ambiguous return value: Selected block contains assignment(s) to "
-                "local variables and return statement.");
+            'Ambiguous return value: Selected block contains assignment(s) to '
+                'local variables and return statement.');
         return result;
       }
       // prepare to return an assigned variable
       VariableElement returnVariable = assignedUsedVariables[0];
       _returnType = returnVariable.type;
       _returnVariableName = returnVariable.displayName;
     }
     // fatal, if multiple variables assigned and used after selection
     if (assignedUsedVariables.length > 1) {
       StringBuffer sb = new StringBuffer();
       for (VariableElement variable in assignedUsedVariables) {
         sb.write(variable.displayName);
-        sb.write("\n");
+        sb.write('\n');
       }
       result.addFatalError(
           format(
-              "Ambiguous return value: Selected block contains more than one "
-                  "assignment to local variables. Affected variables are:\n\n{0}",
+              'Ambiguous return value: Selected block contains more than one '
+                  'assignment to local variables. Affected variables are:\n\n{0}',
               sb.toString().trim()));
     }
     // done
     return result;
   }
 
   void _initializeReturnType() {
     if (_returnType == null) {
       returnType = null;
     } else {
@@ skipping 50 matching lines @@
   @override
   void handleNextSelectedNode(AstNode node) {
     super.handleNextSelectedNode(node);
     _checkParent(node);
   }
 
   @override
   void handleSelectionEndsIn(AstNode node) {
     super.handleSelectionEndsIn(node);
     invalidSelection(
-        "The selection does not cover a set of statements or an expression. "
-            "Extend selection to a valid range.");
+        'The selection does not cover a set of statements or an expression. '
+            'Extend selection to a valid range.');
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     super.visitAssignmentExpression(node);
     Expression lhs = node.leftHandSide;
     if (_isFirstSelectedNode(lhs)) {
       invalidSelection(
           'Cannot extract the left-hand side of an assignment.',
           new Location.fromNode(lhs));
@@ skipping 24 matching lines @@
     }
     return null;
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     super.visitSimpleIdentifier(node);
     if (_isFirstSelectedNode(node)) {
       // name of declaration
       if (node.inDeclarationContext()) {
-        invalidSelection("Cannot extract the name part of a declaration.");
+        invalidSelection('Cannot extract the name part of a declaration.');
       }
       // method name
       Element element = node.bestElement;
       if (element is FunctionElement || element is MethodElement) {
-        invalidSelection("Cannot extract a single method name.");
+        invalidSelection('Cannot extract a single method name.');
       }
       // name in property access
       if (node.parent is PrefixedIdentifier &&
           (node.parent as PrefixedIdentifier).identifier == node) {
-        invalidSelection("Can not extract name part of a property access.");
+        invalidSelection('Can not extract name part of a property access.');
       }
     }
     return null;
   }
 
   @override
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
     if (_isFirstSelectedNode(node)) {
-      invalidSelection("Cannot extract a single type reference.");
+      invalidSelection('Cannot extract a single type reference.');
     }
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     if (_isFirstSelectedNode(node)) {
       invalidSelection(
-          "Cannot extract a variable declaration fragment. "
-              "Select whole declaration statement.",
+          'Cannot extract a variable declaration fragment. '
+              'Select whole declaration statement.',
           new Location.fromNode(node));
     }
     return null;
   }
 
   void _checkParent(AstNode node) {
     AstNode firstParent = firstSelectedNode.parent;
     do {
       node = node.parent;
       if (identical(node, firstParent)) {
         return;
       }
     } while (node != null);
     invalidSelection(
-        "Not all selected statements are enclosed by the same parent statement.");
+        'Not all selected statements are enclosed by the same parent statement.');
   }
 
   bool _isFirstSelectedNode(AstNode node) => identical(firstSelectedNode, node);
 }
 
 
 class _GetSourcePatternVisitor extends GeneralizingAstVisitor {
   final SourceRange partRange;
   final _SourcePattern pattern;
   final List<SourceEdit> replaceEdits;
@@ skipping 273 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 = {};
 }