When user renames 'prefix' in 'prefix.Class' she actually wants to rename ImportElement.

pkg/analysis_server/lib/src/services/index/index_contributor.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.index.index_contributor;
 
 import 'dart:collection' show Queue;
 
+import 'package:analysis_server/src/services/correction/namespace.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/index_store.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/html.dart' as ht;
-import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
-import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 
 /**
  * Adds data to [store] based on the resolved Dart [unit].
  */
 void indexDartUnit(IndexStore store, AnalysisContext context,
     CompilationUnit unit) {
   // check unit
@@ skipping 284 matching lines @@
       if (xmlExpression is ht.RawXmlExpression) {
         ht.RawXmlExpression rawXmlExpression = xmlExpression;
         visitExpression(rawXmlExpression.expression);
       }
     }
   }
 }
 
 
 /**
- * Information about [ImportElement] and place where it is referenced using
- * [PrefixElement].
- */
-class _ImportElementInfo {
-  ImportElement _element;
-
-  int _periodEnd = 0;
-}
-
-
-/**
  * Visits a resolved AST and adds relationships into [IndexStore].
  */
 class _IndexContributor extends GeneralizingAstVisitor<Object> {
   final IndexStore _store;
 
   LibraryElement _libraryElement;
 
   Map<ImportElement, Set<Element>> _importElementsMap = {};
 
   /**
@@ skipping 568 matching lines @@
     Relationship relationship = IndexConstants.DEFINES;
     recordRelationship(_libraryElement, relationship, location);
     recordRelationship(UniverseElement.INSTANCE, relationship, location);
   }
 
   /**
    * Records [ImportElement] that declares given prefix and imports library with element used
    * with given prefix node.
    */
   void _recordImportElementReferenceWithPrefix(SimpleIdentifier prefixNode) {
-    _ImportElementInfo info = getImportElementInfo(prefixNode);
+    ImportElementInfo info = internal_getImportElementInfo(prefixNode);
     if (info != null) {
       int offset = prefixNode.offset;
-      int length = info._periodEnd - offset;
+      int length = info.periodEnd - offset;
       Location location = _createLocationForOffset(offset, length);
       recordRelationship(
-          info._element,
+          info.element,
           IndexConstants.IS_REFERENCED_BY,
           location);
     }
   }
 
   /**
    * Records [ImportElement] reference if given [SimpleIdentifier] references some
    * top-level element and not qualified with import prefix.
    */
   void _recordImportElementReferenceWithoutPrefix(SimpleIdentifier node) {
     if (_isIdentifierInImportCombinator(node)) {
       return;
     }
     if (_isIdentifierInPrefixedIdentifier(node)) {
       return;
     }
     Element element = node.staticElement;
     ImportElement importElement =
-        _internalGetImportElement(_libraryElement, null, element, _importElementsMap);
+        internal_getImportElement(_libraryElement, null, element, _importElementsMap);
     if (importElement != null) {
       Location location = _createLocationForOffset(node.offset, 0);
       recordRelationship(
           importElement,
           IndexConstants.IS_REFERENCED_BY,
           location);
     }
   }
 
   /**
@@ skipping 59 matching lines @@
   static Location createLocation(Element element) {
     if (element != null) {
       int offset = element.nameOffset;
       int length = element.displayName.length;
       return new Location(element, offset, length);
     }
     return null;
   }
 
   /**
-   * @return the [ImportElement] that is referenced by this node with [PrefixElement],
-   *         may be `null`.
-   */
-  static ImportElement getImportElement(SimpleIdentifier prefixNode) {
-    _ImportElementInfo info = getImportElementInfo(prefixNode);
-    return info != null ? info._element : null;
-  }
-
-  /**
-   * @return the [ImportElementInfo] with [ImportElement] that is referenced by this
-   *         node with [PrefixElement], may be `null`.
-   */
-  static _ImportElementInfo getImportElementInfo(SimpleIdentifier prefixNode) {
-    _ImportElementInfo info = new _ImportElementInfo();
-    // prepare environment
-    AstNode parent = prefixNode.parent;
-    CompilationUnit unit =
-        prefixNode.getAncestor((node) => node is CompilationUnit);
-    LibraryElement libraryElement = unit.element.library;
-    // prepare used element
-    Element usedElement = null;
-    if (parent is PrefixedIdentifier) {
-      PrefixedIdentifier prefixed = parent;
-      if (prefixed.prefix == prefixNode) {
-        usedElement = prefixed.staticElement;
-        info._periodEnd = prefixed.period.end;
-      }
-    }
-    if (parent is MethodInvocation) {
-      MethodInvocation invocation = parent;
-      if (invocation.target == prefixNode) {
-        usedElement = invocation.methodName.staticElement;
-        info._periodEnd = invocation.period.end;
-      }
-    }
-    // we need used Element
-    if (usedElement == null) {
-      return null;
-    }
-    // find ImportElement
-    String prefix = prefixNode.name;
-    Map<ImportElement, Set<Element>> importElementsMap = {};
-    info._element = _internalGetImportElement(
-        libraryElement,
-        prefix,
-        usedElement,
-        importElementsMap);
-    if (info._element == null) {
-      return null;
-    }
-    return info;
-  }
-
-  /**
    * If the given expression has resolved type, returns the new location with this type.
    *
    * [location] - the base location
    * [expression] - the expression assigned at the given location
    */
   static Location _getLocationWithExpressionType(Location location,
       Expression expression) {
     if (expression != null) {
       return new LocationWithData<DartType>(location, expression.bestType);
     }
     return location;
   }
 
   /**
-   * @return the [ImportElement] that declares given [PrefixElement] and imports library
-   *         with given "usedElement".
-   */
-  static ImportElement _internalGetImportElement(LibraryElement libraryElement,
-      String prefix, Element usedElement, Map<ImportElement,
-      Set<Element>> importElementsMap) {
-    // validate Element
-    if (usedElement == null) {
-      return null;
-    }
-    if (usedElement.enclosingElement is! CompilationUnitElement) {
-      return null;
-    }
-    LibraryElement usedLibrary = usedElement.library;
-    // find ImportElement that imports used library with used prefix
-    List<ImportElement> candidates = null;
-    for (ImportElement importElement in libraryElement.imports) {
-      // required library
-      if (importElement.importedLibrary != usedLibrary) {
-        continue;
-      }
-      // required prefix
-      PrefixElement prefixElement = importElement.prefix;
-      if (prefix == null) {
-        if (prefixElement != null) {
-          continue;
-        }
-      } else {
-        if (prefixElement == null) {
-          continue;
-        }
-        if (prefix != prefixElement.name) {
-          continue;
-        }
-      }
-      // no combinators => only possible candidate
-      if (importElement.combinators.length == 0) {
-        return importElement;
-      }
-      // OK, we have candidate
-      if (candidates == null) {
-        candidates = [];
-      }
-      candidates.add(importElement);
-    }
-    // no candidates, probably element is defined in this library
-    if (candidates == null) {
-      return null;
-    }
-    // one candidate
-    if (candidates.length == 1) {
-      return candidates[0];
-    }
-    // ensure that each ImportElement has set of elements
-    for (ImportElement importElement in candidates) {
-      if (importElementsMap.containsKey(importElement)) {
-        continue;
-      }
-      Namespace namespace =
-          new NamespaceBuilder().createImportNamespaceForDirective(importElement);
-      Set<Element> elements = new Set.from(namespace.definedNames.values);
-      importElementsMap[importElement] = elements;
-    }
-    // use import namespace to choose correct one
-    for (MapEntry<ImportElement, Set<Element>> entry in getMapEntrySet(
-        importElementsMap)) {
-      if (entry.getValue().contains(usedElement)) {
-        return entry.getKey();
-      }
-    }
-    // not found
-    return null;
-  }
-
-  /**
    * @return `true` if given "node" is part of an import [Combinator].
    */
   static bool _isIdentifierInImportCombinator(SimpleIdentifier node) {
     AstNode parent = node.parent;
     return parent is Combinator;
   }
 
   /**
    * @return `true` if given "node" is part of [PrefixedIdentifier] "prefix.node".
    */
   static bool _isIdentifierInPrefixedIdentifier(SimpleIdentifier node) {
     AstNode parent = node.parent;
     return parent is PrefixedIdentifier && parent.identifier == node;
   }
 }