Initial 'Extract Local' 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';
 import 'package:analysis_server/src/services/correction/strings.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/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 
 /**
+ * @return <code>true</code> if given [List]s are identical at given position.
+ */
+bool allListsIdentical(List<List> lists, int position) {
+  Object element = lists[0][position];
+  for (List list in lists) {
+    if (list[position] != element) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
+/**
  * TODO(scheglov) replace with nodes once there will be [CompilationUnit#getComments].
  *
  * Returns [SourceRange]s of all comments in [unit].
  */
 List<SourceRange> getCommentRanges(CompilationUnit unit) {
   List<SourceRange> ranges = <SourceRange>[];
   Token token = unit.beginToken;
   while (token != null && token.type != TokenType.EOF) {
     Token commentToken = token.precedingComments;
     while (commentToken != null) {
@@ skipping 60 matching lines @@
       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;
+    }
+    if (node is MethodDeclaration) {
+      return node;
+    }
+    node = node.parent;
+  }
+  return null;
+}
+
+
 /**
  * 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;
   }
   return getExpressionPrecedence(parent);
 }
 
+
 /**
  * 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;
 }
 
+/**
+ * @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];
+}
+
+/**
+ * @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) {
@@ skipping 525 matching lines @@
     return sb.toString();
   }
 
   /**
    * @return the source of the inverted condition for the given logical expression.
    */
   String invertCondition(Expression expression) =>
       _invertCondition0(expression)._source;
 
   /**
+   * @return <code>true</code> if selection range contains only whitespace or comments
+   */
+  bool isJustWhitespaceOrComment(SourceRange range) {
+    String trimmedText = getRangeText(range).trim();
+    // may be whitespace
+    if (trimmedText.isEmpty) {
+      return true;
+    }
+    // may be comment
+    return TokenUtils.getTokens(trimmedText).isEmpty;
+  }
+
+  /**
    * 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) {
@@ skipping 41 matching lines @@
    * from [oldIndent] to [newIndent], keeping indentation of lines relative
    * to each other.
    */
   String replaceSourceRangeIndent(SourceRange range, String oldIndent,
       String newIndent) {
     String oldSource = getRangeText(range);
     return replaceSourceIndent(oldSource, oldIndent, newIndent);
   }
 
   /**
+   * @return <code>true</code> if "selection" covers "node" and there are any non-whitespace tokens
+   *         between "selection" and "node" start/end.
+   */
+  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) {
+    // 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;
+    }
+    // may be some punctuation included into selection - operators, braces, etc
+    if (_selectionIncludesNonWhitespaceOutsideOperands(range, subOperands)) {
+      return false;
+    }
+    // OK
+    return true;
+  }
+
+  /**
    * @return the [ImportElement] used to import given [Element] into [library].
    *         May be `null` if was not imported, i.e. declared in the same library.
    */
   ImportElement _getImportElement(Element element) {
     for (ImportElement imp in _library.imports) {
       Map<String, Element> definedNames = getImportNamespace(imp);
       if (definedNames.containsValue(element)) {
         return imp;
       }
     }
@@ skipping 83 matching lines @@
         innerExpresion = (innerExpresion as ParenthesizedExpression).expression;
       }
       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));
+  }
+
+  /**
+   * @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) {
+    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);
+      // 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)) {
+          entered = true;
+        }
+      }
+    }
+    // check if last operand is in range
+    Expression lastGroupMember = operands[operands.length - 1];
+    if (range.end == lastGroupMember.end) {
+      subOperands.add(lastGroupMember);
+      exited = true;
+    }
+    // we expect that range covers only given operands
+    if (!exited) {
+      return [];
+    }
+    // done
+    return subOperands;
+  }
+
+  /**
+   * @return all operands of the given [BinaryExpression] and its children with the same
+   *         operator.
+   */
+  static List<Expression> _getOperandsInOrderFor(BinaryExpression groupRoot) {
+    List<Expression> operands = [];
+    TokenType groupOperatorType = groupRoot.operator.type;
+    groupRoot.accept(new _OrderedOperandsVisitor(groupOperatorType, operands));
+    return operands;
+  }
 }
 
 
 /**
  * Describes where to insert new directive or top-level declaration.
  */
 class CorrectionUtils_InsertDesc {
   int offset = 0;
   String prefix = "";
   String suffix = "";
 }
 
 
 /**
+ * Utilities to work with [Token]s.
+ */
+class TokenUtils {
+  /**
+   * @return the first [KeywordToken] with given [Keyword], may be <code>null</code> if
+   *         not found.
+   */
+  static KeywordToken findKeywordToken(List<Token> tokens, Keyword keyword) {
+    for (Token token in tokens) {
+      if (token is KeywordToken) {
+        KeywordToken keywordToken = token;
+        if (keywordToken.keyword == keyword) {
+          return keywordToken;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @return the first [Token] with given [TokenType], may be <code>null</code> if not
+   *         found.
+   */
+  static Token findToken(List<Token> tokens, TokenType type) {
+    for (Token token in tokens) {
+      if (token.type == type) {
+        return token;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @return [Token]s of the given Dart source, not <code>null</code>, may be empty if no
+   *         tokens or some exception happens.
+   */
+  static List<Token> getTokens(String s) {
+    try {
+      List<Token> tokens = [];
+      Scanner scanner = new Scanner(null, new CharSequenceReader(s), null);
+      Token token = scanner.tokenize();
+      while (token.type != TokenType.EOF) {
+        tokens.add(token);
+        token = token.next;
+      }
+      return tokens;
+    } catch (e) {
+      return [];
+    }
+  }
+
+  /**
+   * @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);
 
   static _InvertedCondition _binary(int precedence, _InvertedCondition left,
@@ skipping 21 matching lines @@
       int newOperatorPrecedence) {
     if (expr._precedence < newOperatorPrecedence) {
       return "(${expr._source})";
     }
     return expr._source;
   }
 
   static _InvertedCondition _simple(String source) =>
       new _InvertedCondition(2147483647, source);
 }
+
+
+class _OrderedOperandsVisitor extends GeneralizingAstVisitor {
+  final TokenType groupOperatorType;
+  final List<Expression> operands;
+
+  _OrderedOperandsVisitor(this.groupOperatorType, this.operands);
+
+  @override
+  Object visitExpression(Expression node) {
+    if (node is BinaryExpression && node.operator.type == groupOperatorType) {
+      return super.visitNode(node);
+    }
+    operands.add(node);
+    return null;
+  }
+}