Remove SearchEngine.searchElementDeclarations().

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_server.dart'
     hide Element, ElementKind;
@@ skipping 174 matching lines @@
     } else {
       if (elementClass.name == name) {
         result.addError(
             format(
                 "Created {0} has the same name as the declaring class '{1}'.",
                 elementKind.displayName,
                 name),
             newLocation_fromElement(elementClass));
       }
     }
-    // check shadowing in hierarchy
+    // usage of the renamed Element is shadowed by a local element
+    {
+      _MatchShadowedByLocal conflict = _getShadowingLocalElement();
+      if (conflict != null) {
+        LocalElement localElement = conflict.localElement;
+        result.addError(
+            format(
+                "Usage of renamed {0} will be shadowed by {1} '{2}'.",
+                elementKind.displayName,
+                getElementKindName(localElement),
+                localElement.displayName),
+            newLocation_fromMatch(conflict.match));
+      }
+    }
+    // check shadowing in the hierarchy
     List<SearchMatch> declarations =
-        await searchEngine.searchElementDeclarations(name);
+        await searchEngine.searchMemberDeclarations(name);
     for (SearchMatch declaration in declarations) {
       Element nameElement = getSyntheticAccessorVariable(declaration.element);
       Element nameClass = nameElement.enclosingElement;
-      // renamed Element shadows member of superclass
+      // the renamed Element shadows a member of a superclass
       if (superClasses.contains(nameClass)) {
         result.addError(
             format(
                 isRename
                     ? "Renamed {0} will shadow {1} '{2}'."
                     : "Created {0} will shadow {1} '{2}'.",
                 elementKind.displayName,
                 getElementKindName(nameElement),
                 getElementQualifiedName(nameElement)),
             newLocation_fromElement(nameElement));
       }
-      // renamed Element is shadowed by member of subclass
+      // the renamed Element is shadowed by a member of a subclass
       if (isRename && subClasses.contains(nameClass)) {
         result.addError(
             format(
                 "Renamed {0} will be shadowed by {1} '{2}'.",
                 elementKind.displayName,
                 getElementKindName(nameElement),
                 getElementQualifiedName(nameElement)),
             newLocation_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}'.",
-                      elementKind.displayName,
-                      getElementKindName(localElement),
-                      localElement.displayName),
-                  newLocation_fromMatch(reference));
-            }
-          }
-        }
-      }
     }
     // visibility
     if (isRename) {
       _validateWillBeInvisible();
     }
     // done
     return result;
   }
 
+  _MatchShadowedByLocal _getShadowingLocalElement() {
+    for (SearchMatch match in references) {
+      // qualified reference cannot be shadowed by a local element
+      if (match.isQualified) {
+        continue;
+      }
+      // check local elements of the enclosing executable
+      Element containingElement = match.element;
+      if (containingElement is ExecutableElement) {
+        Iterable<LocalElement> localElements = <Iterable<LocalElement>>[
+          containingElement.functions,
+          containingElement.localVariables,
+          containingElement.parameters
+        ].expand((Iterable<LocalElement> x) => x);
+        for (LocalElement localElement in localElements) {
+          if (localElement.displayName == name &&
+              localElement.visibleRange.intersects(match.sourceRange)) {
+            return new _MatchShadowedByLocal(match, localElement);
+          }
+        }
+      }
+    }
+    return null;
+  }
+
   /**
    * Fills [elements] with [Element]s to rename.
    */
   Future _prepareElements() async {
     if (element is ClassMemberElement) {
       elements = await getHierarchyMembers(searchEngine, element);
     } else {
       elements = new Set.from([element]);
     }
   }
@@ skipping 24 matching lines @@
       Element refElement = reference.element;
       LibraryElement refLibrary = refElement.library;
       if (refLibrary != library) {
         String message = format("Renamed {0} will be invisible in '{1}'.",
             getElementKindName(element), getElementQualifiedName(refLibrary));
         result.addError(message, newLocation_fromMatch(reference));
       }
     }
   }
 }
+
+class _MatchShadowedByLocal {
+  final SearchMatch match;
+  final LocalElement localElement;
+
+  _MatchShadowedByLocal(this.match, this.localElement);
+}