Fix for 'Extract Local' refactoring - take into account local variable elements.

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 'package:analysis_server/src/protocol.dart' hide Element;
 import 'package:analysis_server/src/services/correction/name_suggestion.dart';
 import 'package:analysis_server/src/services/correction/selection_analyzer.dart';
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/correction/strings.dart';
 import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analysis_server/src/services/refactoring/naming_conventions.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring_internal.dart';
 import 'package:analysis_server/src/services/search/element_visitors.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'dart:collection';
 
 
 const String _TOKEN_SEPARATOR = "\uFFFF";
 
 
 /**
  * [ExtractLocalRefactoring] implementation.
  */
 class ExtractLocalRefactoringImpl extends RefactoringImpl implements
     ExtractLocalRefactoring {
   final CompilationUnit unit;
   final int selectionOffset;
   final int selectionLength;
   CompilationUnitElement unitElement;
   String file;
   SourceRange selectionRange;
   CorrectionUtils utils;
 
   String name;
   bool extractAll = true;
   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>{};
   final Set<String> excludedVariableNames = new Set<String>();
 
   ExtractLocalRefactoringImpl(this.unit, this.selectionOffset,
       this.selectionLength) {
     unitElement = unit.element;
     selectionRange = new SourceRange(selectionOffset, selectionLength);
     utils = new CorrectionUtils(unit);
   }
 
   @override
@@ skipping 291 matching lines @@
               excludedVariableNames));
     }
   }
 
   /**
    * Prepares all occurrences of the source which matches given selection,
    * sorted by offsets.
    */
   void _prepareOccurrences() {
     occurrences.clear();
+    elementIds.clear();
     // prepare selection
     String selectionSource;
     {
       String rawSelectionSource = utils.getRangeText(selectionRange);
       List<Token> selectionTokens = TokenUtils.getTokens(rawSelectionSource);
-      selectionSource = selectionTokens.join(_TOKEN_SEPARATOR);
+      selectionSource =
+          _encodeExpressionTokens(rootExpression, selectionTokens);
     }
     // prepare enclosing function
     AstNode enclosingFunction;
     {
       AstNode selectionNode =
           new NodeLocator.con1(selectionOffset).searchWithin(unit);
       enclosingFunction = getEnclosingExecutableNode(selectionNode);
     }
     // visit function
     enclosingFunction.accept(
         new _OccurrencesVisitor(this, occurrences, selectionSource));
   }
 
   void _prepareOffsetsLengths() {
     offsets.clear();
     lengths.clear();
     for (SourceRange occurrence in occurrences) {
       offsets.add(occurrence.offset);
       lengths.add(occurrence.length);
     }
   }
+
+  /**
+   * 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
+   * 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>(
+        equals: (Token a, Token b) => a.lexeme == b.lexeme,
+        hashCode: (Token t) => t.lexeme.hashCode);
+    expr.accept(new _TokenLocalElementVisitor(map));
+    // map and join tokens
+    return tokens.map((Token token) {
+      String tokenString = token.lexeme;
+      // append token's Element id
+      Element element = map[token];
+      if (element != null) {
+        int elementId = _encodeElement(element);
+        if (elementId != null) {
+          tokenString += '-$elementId';
+        }
+      }
+      // done
+      return tokenString;
+    }).join(_TOKEN_SEPARATOR);
+  }
+}
+
+
+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;
+    }
+  }
 }
 
 
 /**
  * [SelectionAnalyzer] for [ExtractLocalRefactoringImpl].
  */
 class _ExtractExpressionAnalyzer extends SelectionAnalyzer {
   final RefactoringStatus status = new RefactoringStatus();
 
   _ExtractExpressionAnalyzer(SourceRange selection) : super(selection);
@@ skipping 69 matching lines @@
 class _OccurrencesVisitor extends GeneralizingAstVisitor<Object> {
   final ExtractLocalRefactoringImpl ref;
   final List<SourceRange> occurrences;
   final String selectionSource;
 
   _OccurrencesVisitor(this.ref, this.occurrences, this.selectionSource);
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     if (!_hasStatements(node)) {
-      _tryToFindOccurrenceFragment(node);
+      _tryToFindOccurrenceFragments(node);
       return null;
     }
     return super.visitBinaryExpression(node);
   }
 
   @override
   Object visitExpression(Expression node) {
     if (ref._isExtractable(rangeNode(node))) {
       _tryToFindOccurrence(node);
     }
@@ skipping 32 matching lines @@
 
   bool _hasStatements(AstNode root) {
     List<bool> result = [false];
     root.accept(new _HasStatementVisitor(result));
     return result[0];
   }
 
   void _tryToFindOccurrence(Expression node) {
     String nodeSource = ref.utils.getNodeText(node);
     List<Token> nodeTokens = TokenUtils.getTokens(nodeSource);
-    nodeSource = nodeTokens.join(_TOKEN_SEPARATOR);
+    nodeSource = ref._encodeExpressionTokens(node, nodeTokens);
     if (nodeSource == selectionSource) {
       SourceRange occuRange = rangeNode(node);
       _addOccurrence(occuRange);
     }
   }
 
-  void _tryToFindOccurrenceFragment(Expression node) {
+  void _tryToFindOccurrenceFragments(Expression node) {
     int nodeOffset = node.offset;
     String nodeSource = ref.utils.getNodeText(node);
     List<Token> nodeTokens = TokenUtils.getTokens(nodeSource);
-    nodeSource = nodeTokens.join(_TOKEN_SEPARATOR);
+    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);
     }
   }
 }