Parameters and validation for the 'Extract Method' refactoring.

pkg/analysis_server/lib/src/services/refactoring/rename_class_member.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.rename_class_member;
 
 import 'dart:async';
 
-import 'package:analysis_server/src/protocol.dart' hide Element;
+import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind;
 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/rename.dart';
 import 'package:analysis_server/src/services/search/hierarchy.dart';
 import 'package:analysis_server/src/services/search/search_engine.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/rename.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 
 
 /**
+ * Checks if creating a method with the given [name] in [classElement] will
+ * cause any conflicts.
+ */
+Future<RefactoringStatus> validateCreateMethod(SearchEngine searchEngine,
+    ClassElement classElement, String name) {
+  return new _ClassMemberValidator.forCreate(
+      searchEngine,
+      classElement,
+      name).validate();
+}
+
+
+/**
  * A [Refactoring] for renaming class member [Element]s.
  */
 class RenameClassMemberRefactoringImpl extends RenameRefactoringImpl {
-  _RenameClassMemberValidator _validator;
+  _ClassMemberValidator _validator;
 
   RenameClassMemberRefactoringImpl(SearchEngine searchEngine, Element element)
       : super(searchEngine, element);
 
   @override
   String get refactoringName {
     if (element is TypeParameterElement) {
       return "Rename Type Parameter";
     }
     if (element is FieldElement) {
       return "Rename Field";
     }
     return "Rename Method";
   }
 
   @override
   Future<RefactoringStatus> checkFinalConditions() {
     _validator =
-        new _RenameClassMemberValidator(searchEngine, element, newName);
+        new _ClassMemberValidator.forRename(searchEngine, element, newName);
     return _validator.validate();
   }
 
   @override
   Future<RefactoringStatus> checkInitialConditions() {
     RefactoringStatus result = new RefactoringStatus();
     if (element is MethodElement && (element as MethodElement).isOperator) {
       result.addFatalError('Cannot rename operator.');
     }
     return new Future.value(result);
@@ skipping 59 matching lines @@
 
   String _newPotentialId() {
     String id = potentialEditIds.length.toString();
     potentialEditIds.add(id);
     return id;
   }
 }
 
 
 /**
- * Helper to check if renaming of an [Element] to the given name will cause any
- * problems.
+ * Helper to check if the created or renamed [Element] will cause any conflicts.
  */
-class _RenameClassMemberValidator {
+class _ClassMemberValidator {
   final SearchEngine searchEngine;
   final Element element;
-  final String oldName;
-  final String newName;
+  final ClassElement elementClass;
+  final ElementKind elementKind;
+  final String name;
+  final bool isRename;
 
-  Set<Element> elements = new Set();
-  List<SearchMatch> references = [];
+  Set<Element> elements = new Set<Element>();
+  List<SearchMatch> references = <SearchMatch>[];
 
-  _RenameClassMemberValidator(this.searchEngine, Element element, this.newName)
-      : element = element,
-        oldName = element.displayName;
+  _ClassMemberValidator.forCreate(this.searchEngine, this.elementClass,
+      this.name)
+      : isRename = false,
+        element = null,
+        elementKind = ElementKind.METHOD;
+
+  _ClassMemberValidator.forRename(this.searchEngine, Element element, this.name)
+      : isRename = true,
+        element = element,
+        elementClass = element.enclosingElement,
+        elementKind = element.kind;
 
   Future<RefactoringStatus> validate() {
     RefactoringStatus result = new RefactoringStatus();
-    ClassElement elementClass = element.enclosingElement;
     // check if there is a member with "newName" in the same ClassElement
-    for (Element newNameMember in getChildren(elementClass, newName)) {
+    for (Element newNameMember in getChildren(elementClass, name)) {
       result.addError(
           format(
               "Class '{0}' already declares {1} with name '{2}'.",
               elementClass.displayName,
               getElementKindName(newNameMember),
-              newName),
+              name),
           new Location.fromElement(newNameMember));
     }
     // do chained computations
     Set<ClassElement> superClasses = getSuperClasses(elementClass);
     Set<ClassElement> subClasses;
     return _prepareReferences().then((_) {
       return getSubClasses(searchEngine, elementClass).then((_subs) {
         subClasses = _subs;
       });
     }).then((_) {
       // check shadowing in hierarchy
-      return searchEngine.searchElementDeclarations(newName).then((decls) {
+      return searchEngine.searchElementDeclarations(name).then((decls) {
         for (SearchMatch decl in decls) {
           Element nameElement = getSyntheticAccessorVariable(decl.element);
           Element nameClass = nameElement.enclosingElement;
           // renamed Element shadows member of superclass
           if (superClasses.contains(nameClass)) {
             result.addError(
                 format(
-                    "Renamed {0} will shadow {1} '{2}'.",
-                    getElementKindName(element),
+                    isRename ?
+                        "Renamed {0} will shadow {1} '{2}'." :
+                        "Created {0} will shadow {1} '{2}'.",
+                    elementKind.displayName,
                     getElementKindName(nameElement),
                     getElementQualifiedName(nameElement)),
                 new Location.fromElement(nameElement));
           }
           // renamed Element is shadowed by member of subclass
-          if (subClasses.contains(nameClass)) {
+          if (isRename && subClasses.contains(nameClass)) {
             result.addError(
                 format(
                     "Renamed {0} will be shadowed by {1} '{2}'.",
-                    getElementKindName(element),
+                    elementKind.displayName,
                     getElementKindName(nameElement),
                     getElementQualifiedName(nameElement)),
                 new Location.fromElement(nameElement));
           }
           // renamed Element is shadowed by local
           if (nameElement is LocalElement) {
             LocalElement localElement = nameElement;
             ClassElement enclosingClass =
                 nameElement.getAncestor((element) => element is ClassElement);
             if (enclosingClass == elementClass ||
                 subClasses.contains(enclosingClass)) {
               for (SearchMatch reference in references) {
                 if (isReferenceInLocalRange(localElement, reference)) {
                   result.addError(
                       format(
                           "Usage of renamed {0} will be shadowed by {1} '{2}'.",
-                          getElementKindName(element),
+                          elementKind.displayName,
                           getElementKindName(localElement),
                           localElement.displayName),
                       new Location.fromMatch(reference));
                 }
               }
             }
           }
         }
       });
     }).then((_) => result);
@@ skipping 12 matching lines @@
     } else {
       elements = new Set.from([element]);
       return new Future.value();
     }
   }
 
   /**
    * Fills [references] with all references to [elements].
    */
   Future _prepareReferences() {
+    if (!isRename) {
+      return new Future.value();
+    }
     return _prepareElements().then((_) {
       return Future.forEach(elements, (Element element) {
         return searchEngine.searchReferences(element).then((references) {
           this.references.addAll(references);
         });
       });
     });
   }
 }