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) {

[Brian Wilkerson, 2014/08/20 22:11:16]

This seems slow, especially for large files. Do we ever need the list for
anything other than iterating? Perhaps we should (later) add an iterator that
can iterate over token streams.

[scheglov, 2014/08/20 22:19:21]

Acknowledged.

+    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;
+  }
+}