'Inline Method' refactoring.

pkg/analysis_server/lib/src/services/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.
 
 library services.src.correction.util;
 
 import 'dart:math';
 
 import 'package:analysis_server/src/protocol.dart' show SourceEdit;
 import 'package:analysis_server/src/services/correction/source_range.dart';
@@ skipping 76 matching lines @@
   ElementKind kind = element.kind;
   if (kind == ElementKind.FIELD || kind == ElementKind.METHOD) {
     return '${element.enclosingElement.displayName}.${element.displayName}';
   } else {
     return element.displayName;
   }
 }
 
 
 /**
+ * If the given [AstNode] is in a [ClassDeclaration], returns the
+ * [ClassElement]. Otherwise returns `null`.
+ */
+ClassElement getEnclosingClassElement(AstNode node) {
+  ClassDeclaration enclosingClassNode =
+      node.getAncestor((node) => node is ClassDeclaration);
+  if (enclosingClassNode != null) {
+    return enclosingClassNode.element;
+  }
+  return null;
+}
+
+
+
+/**
  * Returns a class or an unit member enclosing the given [node].
  */
 AstNode getEnclosingClassOrUnitMember(AstNode node) {
   AstNode member = node;
   while (node != null) {
     if (node is ClassDeclaration) {
       return member;
     }
     if (node is CompilationUnit) {
       return member;
     }
     member = node;
     node = node.parent;
   }
   return null;
 }
 
-
-
 /**
  * @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;
 }
 
+
 /**
  * @return the enclosing executable [AstNode].
  */
 AstNode getEnclosingExecutableNode(AstNode node) {
   while (node != null) {
     if (node is FunctionDeclaration) {
       return node;
     }
     if (node is ConstructorDeclaration) {
       return node;
@@ skipping 26 matching lines @@
  * Returns the precedence of [node] it is an [Expression], negative otherwise.
  */
 int getExpressionPrecedence(AstNode node) {
   if (node is Expression) {
     return node.precedence;
   }
   return -1000;
 }
 
 
+
 /**
  * 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;
 }
 
 
+/**
+ * Returns the line prefix from the given source, i.e. basically just a
+ * whitespace prefix of the given [String].
+ */
+String getLinesPrefix(String lines) {

[Brian Wilkerson, 2014/08/31 15:59:56]

Should "lines" be "line"?

[scheglov, 2014/08/31 16:43:23]

Acknowledged.

+  int index = 0;
+  while (index < lines.length) {
+    int c = lines.codeUnitAt(index);
+    if (!isWhitespace(c)) {
+      break;
+    }
+    index++;
+  }
+  return lines.substring(0, index);
+}
+
 
 /**
  * @return the [LocalVariableElement] or [ParameterElement] if given
  *         [SimpleIdentifier] is the reference to local variable or parameter, or
  *         <code>null</code> in the other case.
  */
 VariableElement getLocalOrParameterVariableElement(SimpleIdentifier node) {
   Element element = node.staticElement;
   if (element is LocalVariableElement) {
     return element;
@@ skipping 10 matching lines @@
  *         local variable, or <code>null</code> in the other case.
  */
 LocalVariableElement getLocalVariableElement(SimpleIdentifier node) {
   Element element = node.staticElement;
   if (element is LocalVariableElement) {
     return element;
   }
   return null;
 }
 
-
 /**
  * @return the nearest common ancestor [AstNode] of the given [AstNode]s.
  */
 AstNode getNearestCommonAncestor(List<AstNode> nodes) {
   // may be no nodes
   if (nodes.isEmpty) {
     return null;
   }
   // prepare parents
   List<List<AstNode>> parents = [];
   for (AstNode node in nodes) {
     parents.add(getParents(node));
   }
   // find min length
   int minLength = 1 << 20;
   for (List<AstNode> parentList in parents) {
     minLength = min(minLength, parentList.length);
   }
   // find deepest parent
   int i = 0;
   for ( ; i < minLength; i++) {
     if (!allListsIdentical(parents, i)) {
       break;
     }
   }
   return parents[0][i - 1];
 }
 
+/**
+ * Returns the [Expression] qualifier if given node is the name part of a
+ * [PropertyAccess] or a [PrefixedIdentifier]. Maybe `null`.
+ */
+Expression getNodeQualifier(SimpleIdentifier node) {
+  AstNode parent = node.parent;
+  if (parent is PropertyAccess) {
+    PropertyAccess propertyAccess = parent;
+    if (identical(propertyAccess.propertyName, node)) {
+      return propertyAccess.target;
+    }
+  }
+  if (parent is PrefixedIdentifier) {
+    PrefixedIdentifier prefixed = parent;
+    if (identical(prefixed.identifier, node)) {
+      return prefixed.prefix;
+    }
+  }
+  return null;
+}
+
+
+/**
+ * Returns the [ParameterElement] if the given [SimpleIdentifier] is a reference
+ * to a parameter, or `null` in the other case.
+ */
+ParameterElement getParameterElement(SimpleIdentifier node) {
+  Element element = node.staticElement;
+  if (element is ParameterElement) {
+    return element;
+  }
+  return null;
+}
+
 
 /**
  * @return parent [AstNode]s from [CompilationUnit] (at index "0") to the given one.
  */
 List<AstNode> getParents(AstNode node) {
   // prepare number of parents
   int numParents = 0;
   {
     AstNode current = node.parent;
     while (current != null) {
       numParents++;
       current = current.parent;
     }
   }
   // fill array of parents
   List<AstNode> parents = new List<AstNode>(numParents);
   AstNode current = node.parent;
   int index = numParents;
   while (current != null) {
     parents[--index] = current;
     current = current.parent;
   }
   return parents;
 }
 
+
+/**
+ * Returns a [PropertyAccessorElement] if the given [SimpleIdentifier] is a
+ * reference to a property, or `null` in the other case.
+ */
+PropertyAccessorElement getPropertyAccessorElement(SimpleIdentifier node) {
+  Element element = node.staticElement;
+  if (element is PropertyAccessorElement) {
+    return element;
+  }
+  return null;
+}
+
+
 /**
  * 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 26 matching lines @@
 /**
  * Checks if the given [Element]'s display name equals to the given name.
  */
 bool hasDisplayName(Element element, String name) {
   if (element == null) {
     return false;
   }
   return element.displayName == name;
 }
 
+/**
+ * Returns `true` if the given [PropertyAccessorElement] is an accessor of
+ * some [FieldElement].
+ */
+bool isFieldAccessorElement(PropertyAccessorElement accessor) {
+  return accessor != null &&
+      accessor.variable is FieldElement &&
+      accessor.variable.enclosingElement is ClassElement;

[Brian Wilkerson, 2014/08/31 15:59:56]

Do we have field elements whose parent is not a class element?

[scheglov, 2014/08/31 16:43:23]

Yes, we do.
Although we are not interested in it for "Inline Method" refactoring.
I will rename this function to "isClassFieldAccessorElement".

+}
+
 
 /**
  * @return <code>true</code> if given [DartNode] is left hand side of assignment, or
  *         declaration of the variable.
  */
 bool isLeftHandOfAssignment(SimpleIdentifier node) {
   if (node.inSetterContext()) {
     return true;
   }
   return node.parent is VariableDeclaration &&
@@ skipping 54 matching lines @@
    */
   SourceEdit createIndentEdit(SourceRange range, String oldIndent,
       String newIndent) {
     String newSource = replaceSourceRangeIndent(range, oldIndent, newIndent);
     return new SourceEdit(range.offset, range.length, newSource);
   }
 
   /**
    * Returns the [AstNode] that encloses the given offset.
    */
-  AstNode findNode(int offset) => new NodeLocator.con1(offset).searchWithin(unit);
+  AstNode findNode(int offset) =>
+      new NodeLocator.con1(offset).searchWithin(unit);
 
   /**
    * Returns the actual type source of the given [Expression], may be `null`
    * if can not be resolved, should be treated as the `dynamic` type.
    */
   String getExpressionTypeSource(Expression expression) {
     if (expression == null) {
       return null;
     }
     DartType type = expression.bestType;
@@ skipping 792 matching lines @@
   }
 
   /**
    * @return <code>true</code> if given [Token]s contain only single [Token] with given
    *         [TokenType].
    */
   static bool hasOnly(List<Token> tokens, TokenType type) =>
       tokens.length == 1 && tokens[0].type == type;
 }
 
+
 /**
  * A container with a source and its precedence.
  */
 class _InvertedCondition {
   final int _precedence;
 
   final String _source;
 
   _InvertedCondition(this._precedence, this._source);
 
@@ skipping 39 matching lines @@
 
   @override
   Object visitExpression(Expression node) {
     if (node is BinaryExpression && node.operator.type == groupOperatorType) {
       return super.visitNode(node);
     }
     operands.add(node);
     return null;
   }
 }