Compute covering offsets/lengths.

pkg/analysis_server/lib/src/services/refactoring/extract_local.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.refactoring.extract_local;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
@@ skipping 22 matching lines @@
   final CompilationUnit unit;
   final int selectionOffset;
   final int selectionLength;
   CompilationUnitElement unitElement;
   String file;
   SourceRange selectionRange;
   CorrectionUtils utils;
 
   String name;
   bool extractAll = true;
+  final List<int> coveringExpressionOffsets = <int>[];
+  final List<int> coveringExpressionLengths = <int>[];
   final List<String> names = <String>[];
   final List<int> offsets = <int>[];
   final List<int> lengths = <int>[];
 
   Expression rootExpression;
   Expression singleExpression;
   bool wholeStatementExpression = false;
   String stringLiteralPart;
   final List<SourceRange> occurrences = <SourceRange>[];
   final Map<Element, int> elementIds = <Element, int>{};
@@ skipping 118 matching lines @@
     }
     // done
     return new Future.value(change);
   }
 
   @override
   bool requiresPreview() => false;
 
   /**
    * Checks if [selectionRange] selects [Expression] which can be extracted, and
-   * location of this [DartExpression] in AST allows extracting.
+   * location of this [Expression] in AST allows extracting.
    */
   RefactoringStatus _checkSelection() {
-    _ExtractExpressionAnalyzer _selectionAnalyzer =
-        new _ExtractExpressionAnalyzer(selectionRange);
-    unit.accept(_selectionAnalyzer);
-    AstNode coveringNode = _selectionAnalyzer.coveringNode;
-    // may be fatal error
+    String selectionStr;
+    // exclude whitespaces
     {
-      RefactoringStatus status = _selectionAnalyzer.status;
-      if (status.hasFatalError) {
-        return status;
+      selectionStr = utils.getRangeText(selectionRange);
+      int numLeading = countLeadingWhitespaces(selectionStr);
+      int numTrailing = countTrailingWhitespaces(selectionStr);
+      int offset = selectionRange.offset + numLeading;
+      int end = selectionRange.end - numTrailing;
+      selectionRange = new SourceRange(offset, end - offset);
+    }
+    // get covering node
+    AstNode coveringNode = new NodeLocator(
+        selectionRange.offset, selectionRange.end).searchWithin(unit);
+    // compute covering expressions
+    for (AstNode node = coveringNode; node is Expression; node = node.parent) {
+      AstNode parent = node.parent;
+      // cannot extract the name part of a property access
+      if (parent is PrefixedIdentifier && parent.identifier == node ||
+          parent is PropertyAccess && parent.propertyName == node) {
+        continue;
       }
+      // fatal selection problems
+      if (coveringExpressionOffsets.isEmpty) {
+        if (node is SimpleIdentifier) {
+          Element element = node.bestElement;
+          if (element is FunctionElement || element is MethodElement) {
+            return new RefactoringStatus.fatal(
+                'Cannot extract a single method name.',
+                newLocation_fromNode(node));
+          }
+          if (node.inDeclarationContext()) {
+            return new RefactoringStatus.fatal(
+                'Cannot extract the name part of a declaration.',
+                newLocation_fromNode(node));
+          }
+        }
+        if (parent is AssignmentExpression && parent.leftHandSide == node) {
+          return new RefactoringStatus.fatal(
+              'Cannot extract the left-hand side of an assignment.',
+              newLocation_fromNode(node));
+        }
+      }
+      // set selected expression
+      if (coveringExpressionOffsets.isEmpty) {
+        rootExpression = node;
+      }
+      // add the expression range
+      coveringExpressionOffsets.add(node.offset);
+      coveringExpressionLengths.add(node.length);
     }
     // we need enclosing block to add variable declaration statement
     if (coveringNode == null ||
         coveringNode.getAncestor((node) => node is Block) == null) {
       return new RefactoringStatus.fatal(
           'Expression inside of function must be selected '
           'to activate this refactoring.');
     }
     // part of string literal
     if (coveringNode is StringLiteral) {
-      stringLiteralPart = utils.getRangeText(selectionRange);
-      if (stringLiteralPart.startsWith("'") ||
-          stringLiteralPart.startsWith('"') ||
-          stringLiteralPart.endsWith("'") ||
-          stringLiteralPart.endsWith('"')) {
-        return new RefactoringStatus.fatal(
-            'Cannot extract only leading or trailing quote of string literal.');
-      }
-      return new RefactoringStatus();
-    }
-    // single node selected
-    if (_selectionAnalyzer.selectedNodes.length == 1 &&
-        !utils.selectionIncludesNonWhitespaceOutsideNode(
-            selectionRange, _selectionAnalyzer.firstSelectedNode)) {
-      AstNode selectedNode = _selectionAnalyzer.firstSelectedNode;
-      if (selectedNode is Expression) {
-        rootExpression = selectedNode;
-        singleExpression = rootExpression;
-        wholeStatementExpression =
-            singleExpression.parent is ExpressionStatement;
+      if (selectionRange.offset > coveringNode.offset &&
+          selectionRange.end < coveringNode.end) {
+        stringLiteralPart = selectionStr;
         return new RefactoringStatus();
       }
     }
-    // fragment of binary expression selected
-    if (coveringNode is BinaryExpression) {
-      BinaryExpression binaryExpression = coveringNode;
-      if (utils.validateBinaryExpressionRange(
-          binaryExpression, selectionRange)) {
-        rootExpression = binaryExpression;
-        singleExpression = null;
-        return new RefactoringStatus();
-      }
+    // single node selected
+    if (rootExpression != null) {
+      singleExpression = rootExpression;
+      selectionRange = rangeNode(singleExpression);
+      wholeStatementExpression = singleExpression.parent is ExpressionStatement;
+      return new RefactoringStatus();
     }
     // invalid selection
     return new RefactoringStatus.fatal(
         'Expression must be selected to activate this refactoring.');
   }
 
   /**
    * Return an unique identifier for the given [Element], or `null` if [element]
    * is `null`.
    */
   int _encodeElement(Element element) {
     if (element == null) {
       return null;
     }
     int id = elementIds[element];
     if (id == null) {
       id = elementIds.length;
       elementIds[element] = id;
     }
     return id;
   }
 
   /**
    * Returns an [Element]-sensitive encoding of [tokens].
    * Each [Token] with a [LocalVariableElement] has a suffix of the element id.
    *
-   * So, we can distingush different local variables with the same name, if
+   * So, we can distinguish different local variables with the same name, if
    * there are multiple variables with the same name are declared in the
    * function we are searching occurrences in.
    */
   String _encodeExpressionTokens(Expression expr, List<Token> tokens) {
     // no expression, i.e. a part of a string
     if (expr == null) {
       return tokens.join(_TOKEN_SEPARATOR);
     }
     // prepare Token -> LocalElement map
     Map<Token, Element> map = new HashMap<Token, Element>(
@@ skipping 195 matching lines @@
         invalidSelection('Cannot extract name part of a property access.');
       }
       if (parent is PropertyAccess && identical(parent.propertyName, node)) {
         invalidSelection('Cannot extract name part of a property access.');
       }
     }
     return null;
   }
 
   /**
-   * Records fatal error with given message and [Locatiom].
+   * Records fatal error with given [message] and [location].
    */
   void _invalidSelection(String message, Location location) {
     status.addFatalError(message, location);
     reset();
   }
 
   bool _isFirstSelectedNode(AstNode node) => node == firstSelectedNode;
 }
 
 class _HasStatementVisitor extends GeneralizingAstVisitor {
@@ skipping 27 matching lines @@
   Object visitExpression(Expression node) {
     if (ref._isExtractable(rangeNode(node))) {
       _tryToFindOccurrence(node);
     }
     return super.visitExpression(node);
   }
 
   @override
   Object visitStringLiteral(StringLiteral node) {
     if (ref.stringLiteralPart != null) {
-      int occuLength = ref.stringLiteralPart.length;
+      int length = ref.stringLiteralPart.length;
       String value = ref.utils.getNodeText(node);
       int lastIndex = 0;
       while (true) {
         int index = value.indexOf(ref.stringLiteralPart, lastIndex);
         if (index == -1) {
           break;
         }
-        lastIndex = index + occuLength;
-        int occuStart = node.offset + index;
-        SourceRange occuRange = rangeStartLength(occuStart, occuLength);
-        occurrences.add(occuRange);
+        lastIndex = index + length;
+        int start = node.offset + index;
+        SourceRange range = rangeStartLength(start, length);
+        occurrences.add(range);
       }
       return null;
     }
     return visitExpression(node);
   }
 
   void _addOccurrence(SourceRange range) {
     if (range.intersects(ref.selectionRange)) {
       occurrences.add(ref.selectionRange);
     } else {
       occurrences.add(range);
     }
   }
 
   bool _hasStatements(AstNode root) {
     _HasStatementVisitor visitor = new _HasStatementVisitor();
     root.accept(visitor);
     return visitor.result;
   }
 
   void _tryToFindOccurrence(Expression node) {
     String nodeSource = ref.utils.getNodeText(node);
     List<Token> nodeTokens = TokenUtils.getTokens(nodeSource);
     nodeSource = ref._encodeExpressionTokens(node, nodeTokens);
     if (nodeSource == selectionSource) {
-      SourceRange occuRange = rangeNode(node);
-      _addOccurrence(occuRange);
+      SourceRange range = rangeNode(node);
+      _addOccurrence(range);
     }
   }
 
   void _tryToFindOccurrenceFragments(Expression node) {
     int nodeOffset = node.offset;
     String nodeSource = ref.utils.getNodeText(node);
     List<Token> nodeTokens = TokenUtils.getTokens(nodeSource);
     nodeSource = ref._encodeExpressionTokens(node, nodeTokens);
     // find "selection" in "node" tokens
     int lastIndex = 0;
     while (true) {
       // find next occurrence
       int index = nodeSource.indexOf(selectionSource, lastIndex);
       if (index == -1) {
         break;
       }
       lastIndex = index + selectionSource.length;
       // find start/end tokens
       int startTokenIndex =
           countMatches(nodeSource.substring(0, index), _TOKEN_SEPARATOR);
       int endTokenIndex =
           countMatches(nodeSource.substring(0, lastIndex), _TOKEN_SEPARATOR);
       Token startToken = nodeTokens[startTokenIndex];
       Token endToken = nodeTokens[endTokenIndex];
       // add occurrence range
-      int occuStart = nodeOffset + startToken.offset;
-      int occuEnd = nodeOffset + endToken.end;
-      SourceRange occuRange = rangeStartEnd(occuStart, occuEnd);
-      _addOccurrence(occuRange);
+      int start = nodeOffset + startToken.offset;
+      int end = nodeOffset + endToken.end;
+      SourceRange range = rangeStartEnd(start, end);
+      _addOccurrence(range);
     }
   }
 }
 
 class _TokenLocalElementVisitor extends RecursiveAstVisitor {
   final Map<Token, Element> map;
 
   _TokenLocalElementVisitor(this.map);
 
   visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is LocalVariableElement) {
       map[node.token] = element;
     }
   }
 }