Remove references to Engine classes from protocol.dart

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.dart' hide Element;
+import 'package:analysis_server/src/protocol_server.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 {
@@ skipping 82 matching lines @@
     } else {
       occurrences = [selectionRange];
     }
     // If the whole expression of a statement is selected, like '1 + 2',
     // then convert it into a variable declaration statement.
     if (wholeStatementExpression && occurrences.length == 1) {
       String keyword = _declarationKeyword;
       String declarationSource = '$keyword $name = ';
       SourceEdit edit =
           new SourceEdit(singleExpression.offset, 0, declarationSource);
-      change.addElementEdit(unitElement, edit);
+      doSourceChange_addElementEdit(change, unitElement, edit);
       return new Future.value(change);
     }
     // add variable declaration
     {
       String declarationSource;
       if (stringLiteralPart != null) {
         declarationSource = "var $name = '$stringLiteralPart';";
       } else {
         String keyword = _declarationKeyword;
         String initializerSource = utils.getRangeText(selectionRange);
@@ skipping 15 matching lines @@
             target_ = commonParent.getAncestor((node) => node is Statement);
           }
         }
       }
       AstNode target = target_;
       // insert variable declaration
       if (target is Statement) {
         String prefix = utils.getNodePrefix(target);
         SourceEdit edit =
             new SourceEdit(target.offset, 0, declarationSource + eol + prefix);
-        change.addElementEdit(unitElement, edit);
+        doSourceChange_addElementEdit(change, unitElement, edit);
       } else if (target is ExpressionFunctionBody) {
         String prefix = utils.getNodePrefix(target.parent);
         String indent = utils.getIndent(1);
         String declStatement = prefix + indent + declarationSource + eol;
         String exprStatement = prefix + indent + 'return ';
         Expression expr = target.expression;
-        change.addElementEdit(
+        doSourceChange_addElementEdit(
+            change,
             unitElement,
             new SourceEdit(
                 target.offset,
                 expr.offset - target.offset,
                 '{' + eol + declStatement + exprStatement));
-        change.addElementEdit(
+        doSourceChange_addElementEdit(
+            change,
             unitElement,
             new SourceEdit(expr.end, 0, ';' + eol + prefix + '}'));
       }
     }
     // prepare replacement
     String occurrenceReplacement = name;
     if (stringLiteralPart != null) {
       occurrenceReplacement = "\${$name}";
     }
     // replace occurrences with variable reference
     for (SourceRange range in occurrences) {
-      SourceEdit edit = new SourceEdit.range(range, occurrenceReplacement);
-      change.addElementEdit(unitElement, edit);
+      SourceEdit edit = newSourceEdit_range(range, occurrenceReplacement);
+      doSourceChange_addElementEdit(change, unitElement, edit);
     }
     // done
     return new Future.value(change);
   }
 
   @override
   bool requiresPreview() => false;
 
   /**
    * Checks if [selectionRange] selects [Expression] which can be extracted, and
@@ skipping 54 matching lines @@
         singleExpression = null;
         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
+   * 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);
+  }
+
+  /**
    * Returns [AstNode]s at the offsets of the given [SourceRange]s.
    */
   List<AstNode> _findNodes(List<SourceRange> ranges) {
     List<AstNode> nodes = <AstNode>[];
     for (SourceRange range in ranges) {
       AstNode node = new NodeLocator.con1(range.offset).searchWithin(unit);
       nodes.add(node);
     }
     return nodes;
   }
@@ skipping 111 matching lines @@
   }
 
   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);
 
   /**
    * Records fatal error with given message.
    */
   void invalidSelection(String message) {
     _invalidSelection(message, null);
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     super.visitAssignmentExpression(node);
     Expression lhs = node.leftHandSide;
     if (_isFirstSelectedNode(lhs)) {
       _invalidSelection(
           'Cannot extract the left-hand side of an assignment.',
-          new Location.fromNode(lhs));
+          newLocation_fromNode(lhs));
     }
     return null;
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     super.visitSimpleIdentifier(node);
     if (_isFirstSelectedNode(node)) {
       // name of declaration
       if (node.inDeclarationContext()) {
@@ skipping 132 matching lines @@
       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);
     }
   }
 }
+
+
+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;
+    }
+  }
+}