'Rename Local Variable' refactoring implementation.

pkg/analysis_services/lib/src/correction/util.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library services.src.correction.util;
 
 import 'package:analysis_services/correction/change.dart';
@@ skipping 42 matching lines @@
     if (typeName == "String") {
       return "''";
     }
   }
   // no better guess
   return "null";
 }
 
 
 /**
+ * Return the name of the [Element] kind.
+ */
+String getElementKindName(Element element) {
+  return element.kind.displayName;
+}
+
+
+/**
+ * Returns the name to display in the UI for the given [Element].
+ */
+String getElementQualifiedName(Element element) {
+  ElementKind kind = element.kind;
+  while (true) {
+    if (kind == ElementKind.FIELD || kind == ElementKind.METHOD) {
+      return '${element.enclosingElement.displayName}.${element.displayName}';
+    } else {
+      return element.displayName;
+    }
+    break;

[Brian Wilkerson, 2014/08/12 04:44:40]

I don't understand this code. We will never reach line 81, and we will never
execute the loop more than once.

[scheglov, 2014/08/12 05:09:33]

/me is surprised too.
I guess it was a switch/case in Java and I copy/pasted it blindly.

Fixed.

+  }
+}
+
+
+/**
  * @return the [ExecutableElement] of the enclosing executable [AstNode].
  */
 ExecutableElement getEnclosingExecutableElement(AstNode node) {
   while (node != null) {
     if (node is FunctionDeclaration) {
       return node.element;
     }
     if (node is ConstructorDeclaration) {
       return node.element;
     }
     if (node is MethodDeclaration) {
       return node.element;
     }
     node = node.parent;
   }
   return null;
 }
 
-
 /**
  * Returns a namespace of the given [ExportElement].
  */
 Map<String, Element> getExportNamespaceForDirective(ExportElement exp) {
   Namespace namespace =
       new NamespaceBuilder().createExportNamespaceForDirective(exp);
   return namespace.definedNames;
 }
 
 
 /**
  * Returns a export namespace of the given [LibraryElement].
  */
 Map<String, Element> getExportNamespaceForLibrary(LibraryElement library) {
   Namespace namespace =
       new NamespaceBuilder().createExportNamespaceForLibrary(library);
   return namespace.definedNames;
 }
 
 /**
  * Returns an [Element] exported from the given [LibraryElement].
  */
 Element getExportedElement(LibraryElement library, String name) {
   if (library == null) {
     return null;
   }
   return getExportNamespaceForLibrary(library)[name];
 }
 
-
 /**
  * Returns [getExpressionPrecedence] for the parent of [node],
  * or `0` if the parent node is [ParenthesizedExpression].
  *
  * The reason is that `(expr)` is always executed after `expr`.
  */
 int getExpressionParentPrecedence(AstNode node) {
   AstNode parent = node.parent;
   if (parent is ParenthesizedExpression) {
     return 0;
@@ skipping 13 matching lines @@
 
 /**
  * Returns the namespace of the given [ImportElement].
  */
 Map<String, Element> getImportNamespace(ImportElement imp) {
   NamespaceBuilder builder = new NamespaceBuilder();
   Namespace namespace = builder.createImportNamespaceForDirective(imp);
   return namespace.definedNames;
 }
 
+
 /**
  * If given [AstNode] is name of qualified property extraction, returns target from which
  * this property is extracted. Otherwise `null`.
  */
 Expression getQualifiedPropertyTarget(AstNode node) {
   AstNode parent = node.parent;
   if (parent is PrefixedIdentifier) {
     PrefixedIdentifier prefixed = parent;
     if (prefixed.identifier == node) {
       return parent.prefix;
     }
   }
   if (parent is PropertyAccess) {
     PropertyAccess access = parent;
     if (access.propertyName == node) {
       return access.realTarget;
     }
   }
   return null;
 }
 
+
 /**
  * Returns the given [Statement] if not a [Block], or the first child
  * [Statement] if a [Block], or `null` if more than one child.
  */
 Statement getSingleStatement(Statement statement) {
   if (statement is Block) {
     List<Statement> blockStatements = statement.statements;
     if (blockStatements.length != 1) {
       return null;
     }
@@ skipping 708 matching lines @@
       int newOperatorPrecedence) {
     if (expr._precedence < newOperatorPrecedence) {
       return "(${expr._source})";
     }
     return expr._source;
   }
 
   static _InvertedCondition _simple(String source) =>
       new _InvertedCondition(2147483647, source);
 }