Initial 'Extract Method' refactoring implementation.

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/protocol2.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;
   }
 }
 
 
 /**
+ * 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) {
+AstNode getEnclosingExecutableNode(AstNode node) {
   while (node != null) {
     if (node is FunctionDeclaration) {
       return node;
     }
     if (node is ConstructorDeclaration) {
       return node;
     }
     if (node is MethodDeclaration) {
       return node;
     }
@@ skipping 31 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;
 }
 
+
+
+/**
+ * @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;
+  }
+  if (element is ParameterElement) {
+    return element;
+  }
+  return null;
+}
+
+
+/**
+ * @return the [LocalVariableElement] if given [SimpleIdentifier] is the reference to
+ *         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++) {
+  for ( ; i < minLength; i++) {
     if (!allListsIdentical(parents, i)) {
       break;
     }
   }
   return parents[0][i - 1];
 }
 
+
 /**
  * @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;
 }
 
-
 /**
  * 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 27 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;
 }
 
 
+/**
+ * @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 &&
+      (node.parent as VariableDeclaration).name == node;

[Brian Wilkerson, 2014/08/25 07:44:00]

Does this also want to ensure that there is an initializer, or is the fact that
it will be set to a default value sufficient?

[scheglov, 2014/08/25 15:36:29]

I's not very useful to extract an empty variable declaration, but it is
semantically correct and it may be a valid code to start developing some method.

+}
+
+
+/**
+ * @return `true` if the given [SimpleIdentifier] is the name of the
+ *         [NamedExpression].
+ */
+bool isNamedExpressionName(SimpleIdentifier node) {
+  AstNode parent = node.parent;
+  if (parent is Label) {
+    Label label = parent;
+    if (identical(label.label, node)) {
+      AstNode parent2 = label.parent;
+      if (parent2 is NamedExpression) {
+        return identical(parent2.name, label);
+      }
+    }
+  }
+  return false;
+}
+
+
 class CorrectionUtils {
   final CompilationUnit unit;
 
   LibraryElement _library;
   String _buffer;
   String _endOfLine;
 
   CorrectionUtils(this.unit) {
     CompilationUnitElement unitElement = unit.element;
     this._library = unitElement.library;
@@ skipping 476 matching lines @@
 
   /**
    * Returns the source with indentation changed from [oldIndent] to
    * [newIndent], keeping indentation of lines relative to each other.
    */
   String replaceSourceIndent(String source, String oldIndent,
       String newIndent) {
     // prepare STRING token ranges
     List<SourceRange> lineRanges = [];
     {
-      var token = unit.beginToken;
-      while (token != null && token.type != TokenType.EOF) {
+      List<Token> tokens = TokenUtils.getTokens(source);
+      for (Token token in tokens) {
         if (token.type == TokenType.STRING) {
           lineRanges.add(rangeToken(token));
         }
         token = token.next;
       }
     }
     // re-indent lines
     StringBuffer sb = new StringBuffer();
     String eol = endOfLine;
     List<String> lines = source.split(eol);
@@ skipping 44 matching lines @@
   bool selectionIncludesNonWhitespaceOutsideNode(SourceRange selection,
       AstNode node) {
     return _selectionIncludesNonWhitespaceOutsideRange(
         selection,
         rangeNode(node));
   }
 
   /**
    * @return <code>true</code> if given range of [BinaryExpression] can be extracted.
    */
-  bool validateBinaryExpressionRange(BinaryExpression binaryExpression, SourceRange range) {
+  bool validateBinaryExpressionRange(BinaryExpression binaryExpression,
+      SourceRange range) {
     // only parts of associative expression are safe to extract
     if (!binaryExpression.operator.type.isAssociativeOperator) {
       return false;
     }
     // prepare selected operands
     List<Expression> operands = _getOperandsInOrderFor(binaryExpression);
     List<Expression> subOperands = _getOperandsForSourceRange(operands, range);
     // if empty, then something wrong with selection
     if (subOperands.isEmpty) {
       return false;
@@ skipping 104 matching lines @@
       }
       return _invertCondition0(innerExpresion);
     }
     DartType type = expression.bestType;
     if (type.displayName == "bool") {
       return _InvertedCondition._simple("!${getNodeText(expression)}");
     }
     return _InvertedCondition._simple(getNodeText(expression));
   }
 
-  bool _selectionIncludesNonWhitespaceOutsideOperands(SourceRange selection, List<Expression> operands) {
-    return _selectionIncludesNonWhitespaceOutsideRange(selection, rangeNodes(operands));
+  bool _selectionIncludesNonWhitespaceOutsideOperands(SourceRange selection,
+      List<Expression> operands) {
+    return _selectionIncludesNonWhitespaceOutsideRange(
+        selection,
+        rangeNodes(operands));
   }
 
   /**
    * @return <code>true</code> if "selection" covers "range" and there are any non-whitespace tokens
    *         between "selection" and "range" start/end.
    */
   bool _selectionIncludesNonWhitespaceOutsideRange(SourceRange selection,
       SourceRange range) {
     // selection should cover range
     if (!selection.covers(range)) {
       return false;
     }
     // non-whitespace between selection start and range start
     if (!isJustWhitespaceOrComment(rangeStartStart(selection, range))) {
       return true;
     }
     // non-whitespace after range
     if (!isJustWhitespaceOrComment(rangeEndEnd(range, selection))) {
       return true;
     }
     // only whitespace in selection around range
     return false;
   }
 
   /**
    * @return [Expression]s from <code>operands</code> which are completely covered by given
    *         [SourceRange]. Range should start and end between given [Expression]s.
    */
-  static List<Expression> _getOperandsForSourceRange(List<Expression> operands, SourceRange range) {
+  static List<Expression> _getOperandsForSourceRange(List<Expression> operands,
+      SourceRange range) {
     assert(!operands.isEmpty);
     List<Expression> subOperands = [];
     // track range enter/exit
     bool entered = false;
     bool exited = false;
     // may be range starts before or on first operand
     if (range.offset <= operands[0].offset) {
       entered = true;
     }
     // iterate over gaps between operands
     for (int i = 0; i < operands.length - 1; i++) {
       Expression operand = operands[i];
       Expression nextOperand = operands[i + 1];
-      SourceRange inclusiveGap = rangeEndStart(operand, nextOperand).getMoveEnd(1);
+      SourceRange inclusiveGap =
+          rangeEndStart(operand, nextOperand).getMoveEnd(1);
       // add operand, if already entered range
       if (entered) {
         subOperands.add(operand);
         // may be last operand in range
         if (range.endsIn(inclusiveGap)) {
           exited = true;
         }
       } else {
         // may be first operand in range
         if (range.startsIn(inclusiveGap)) {
@@ skipping 150 matching lines @@
 
   @override
   Object visitExpression(Expression node) {
     if (node is BinaryExpression && node.operator.type == groupOperatorType) {
       return super.visitNode(node);
     }
     operands.add(node);
     return null;
   }
 }