Remove references to Engine classes from protocol.dart

pkg/analysis_server/lib/src/services/refactoring/inline_method.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.inline_method;
 
 import 'dart:async';
 
-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/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/refactoring.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring_internal.dart';
 import 'package:analysis_server/src/services/search/element_visitors.dart';
 import 'package:analysis_server/src/services/search/hierarchy.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 49 matching lines @@
     for (_ParameterOccurrence occurrence in occurrences) {
       SourceRange range = occurrence.range;
       // prepare argument source to apply at this occurrence
       String occurrenceArgumentSource;
       if (argumentPrecedence < occurrence.parentPrecedence) {
         occurrenceArgumentSource = "(${argumentSource})";
       } else {
         occurrenceArgumentSource = argumentSource;
       }
       // do replace
-      edits.add(new SourceEdit.range(range, occurrenceArgumentSource));
+      edits.add(newSourceEdit_range(range, occurrenceArgumentSource));
     }
   });
   // replace static field "qualifier" with invocation target
   part._staticFieldQualifiers.forEach(
       (String className, List<SourceRange> ranges) {
     for (SourceRange range in ranges) {
-      edits.add(new SourceEdit.range(range, className + '.'));
+      edits.add(newSourceEdit_range(range, className + '.'));
     }
   });
   // replace instance field "qualifier" with invocation target
   if (targetExpression != null) {
     String targetSource = utils.getNodeText(targetExpression) + '.';
     for (SourceRange qualifierRange in part._instanceFieldQualifiers) {
-      edits.add(new SourceEdit.range(qualifierRange, targetSource));
+      edits.add(newSourceEdit_range(qualifierRange, targetSource));
     }
   }
   // prepare edits to replace conflicting variables
   Set<String> conflictingNames = _getNamesConflictingAt(contextNode);
   part._variables.forEach((VariableElement variable, List<SourceRange> ranges) {
     String originalName = variable.displayName;
     // prepare unique name
     String uniqueName;
     {
       uniqueName = originalName;
       int uniqueIndex = 2;
       while (conflictingNames.contains(uniqueName)) {
         uniqueName = originalName + uniqueIndex.toString();
         uniqueIndex++;
       }
     }
     // update references, if name was change
     if (uniqueName != originalName) {
       for (SourceRange range in ranges) {
-        edits.add(new SourceEdit.range(range, uniqueName));
+        edits.add(newSourceEdit_range(range, uniqueName));
       }
     }
   });
   // prepare source with applied arguments
   edits.sort((SourceEdit a, SourceEdit b) => b.offset - a.offset);
   return SourceEdit.applySequence(part._source, edits);
 }
 
 
 /**
@@ skipping 108 matching lines @@
       result.addError('All references must be inlined to remove the source.');
     }
     // prepare changes
     for (_ReferenceProcessor processor in _referenceProcessors) {
       processor._process(result);
     }
     // delete method
     if (deleteSource && inlineAll) {
       SourceRange methodRange = rangeNode(_methodNode);
       SourceRange linesRange = _methodUtils.getLinesRange(methodRange);
-      change.addElementEdit(
+      doSourceChange_addElementEdit(
+          change,
           _methodElement,
-          new SourceEdit.range(linesRange, ''));
+          newSourceEdit_range(linesRange, ''));
     }
     // done
     return new Future.value(result);
   }
 
   @override
   Future<RefactoringStatus> checkInitialConditions() {
     RefactoringStatus result = new RefactoringStatus();
     // prepare method information
     result.addStatus(_prepareMethod());
@@ skipping 166 matching lines @@
     Statement refStatement = _node.getAncestor((node) => node is Statement);
     if (refStatement != null) {
       _refLineRange = _refUtils.getLinesRangeStatements([refStatement]);
       _refPrefix = _refUtils.getNodePrefix(refStatement);
     } else {
       _refLineRange = null;
       _refPrefix = _refUtils.getLinePrefix(_node.offset);
     }
   }
 
+  void _addRefEdit(SourceEdit edit) {
+    doSourceChange_addElementEdit(ref.change, refElement, edit);
+  }
+
   bool _canInlineBody(AstNode usage) {
     // no statements, usually just expression
     if (ref._methodStatementsPart == null) {
       // empty method, inline as closure
       if (ref._methodExpressionPart == null) {
         return false;
       }
       // OK, just expression
       return true;
     }
@@ skipping 27 matching lines @@
     // not in block, cannot inline body
     return false;
   }
 
   void _inlineMethodInvocation(RefactoringStatus status, Expression usage,
       bool cascaded, Expression target, List<Expression> arguments) {
     // we don't support cascade
     if (cascaded) {
       status.addError(
           'Cannot inline cascade invocation.',
-          new Location.fromNode(usage));
+          newLocation_fromNode(usage));
     }
     // can we inline method body into "methodUsage" block?
     if (_canInlineBody(usage)) {
       // insert non-return statements
       if (ref._methodStatementsPart != null) {
         // prepare statements source for invocation
         String source = _getMethodSourceForInvocation(
             ref._methodStatementsPart,
             _refUtils,
             usage,
             target,
             arguments);
         source = _refUtils.replaceSourceIndent(
             source,
             ref._methodStatementsPart._prefix,
             _refPrefix);
         // do insert
         SourceRange range = rangeStartLength(_refLineRange, 0);
-        SourceEdit edit = new SourceEdit.range(range, source);
+        SourceEdit edit = newSourceEdit_range(range, source);
         _addRefEdit(edit);
       }
       // replace invocation with return expression
       if (ref._methodExpressionPart != null) {
         // prepare expression source for invocation
         String source = _getMethodSourceForInvocation(
             ref._methodExpressionPart,
             _refUtils,
             usage,
             target,
             arguments);
         if (getExpressionPrecedence(ref._methodExpression) <
             getExpressionParentPrecedence(usage)) {
           source = "(${source})";
         }
         // do replace
         SourceRange methodUsageRange = rangeNode(usage);
-        SourceEdit edit = new SourceEdit.range(methodUsageRange, source);
+        SourceEdit edit = newSourceEdit_range(methodUsageRange, source);
         _addRefEdit(edit);
       } else {
-        SourceEdit edit = new SourceEdit.range(_refLineRange, "");
+        SourceEdit edit = newSourceEdit_range(_refLineRange, "");
         _addRefEdit(edit);
       }
       return;
     }
     // inline as closure invocation
     String source;
     {
       source = ref._methodUtils.getRangeText(
           rangeStartEnd(ref._methodParameters.leftParenthesis, ref._methodNode));
       String methodPrefix =
           ref._methodUtils.getLinePrefix(ref._methodNode.offset);
       source = _refUtils.replaceSourceIndent(source, methodPrefix, _refPrefix);
       source = source.trim();
     }
     // do insert
     SourceRange range = rangeNode(_node);
-    SourceEdit edit = new SourceEdit.range(range, source);
+    SourceEdit edit = newSourceEdit_range(range, source);
     _addRefEdit(edit);
   }
 
   void _process(RefactoringStatus status) {
     AstNode nodeParent = _node.parent;
     // may be only single place should be inlined
     if (!_shouldProcess()) {
       return;
     }
     // may be invocation of inline method
     if (nodeParent is MethodInvocation) {
       MethodInvocation invocation = nodeParent;
       Expression target = invocation.target;
       List<Expression> arguments = invocation.argumentList.arguments;
       _inlineMethodInvocation(
           status,
           invocation,
           invocation.isCascaded,
           target,
           arguments);
     } else {
       // cannot inline reference to method: var v = new A().method;
       if (ref._methodElement is MethodElement) {
         status.addFatalError(
             'Cannot inline class method reference.',
-            new Location.fromNode(_node));
+            newLocation_fromNode(_node));
         return;
       }
       // PropertyAccessorElement
       if (ref._methodElement is PropertyAccessorElement) {
         Expression usage = _node;
         Expression target = null;
         bool cascade = false;
         if (nodeParent is PrefixedIdentifier) {
           PrefixedIdentifier propertyAccess = nodeParent;
           usage = propertyAccess;
@@ skipping 24 matching lines @@
             rangeStartEnd(ref._methodParameters.leftParenthesis, ref._methodNode));
         String methodPrefix =
             ref._methodUtils.getLinePrefix(ref._methodNode.offset);
         source =
             _refUtils.replaceSourceIndent(source, methodPrefix, _refPrefix);
         source = source.trim();
         source = removeEnd(source, ';');
       }
       // do insert
       SourceRange range = rangeNode(_node);
-      SourceEdit edit = new SourceEdit.range(range, source);
+      SourceEdit edit = newSourceEdit_range(range, source);
       _addRefEdit(edit);
     }
   }
 
-  void _addRefEdit(SourceEdit edit) {
-    ref.change.addElementEdit(refElement, edit);
-  }
-
   bool _shouldProcess() {
     if (!ref.inlineAll) {
       SourceRange parentRange = rangeNode(_node);
       return parentRange.contains(ref.offset);
     }
     return true;
   }
 }
 
 class _ReturnsValidatorVisitor extends RecursiveAstVisitor {
   final RefactoringStatus result;
   int _numReturns = 0;
 
   _ReturnsValidatorVisitor(this.result);
 
   @override
   visitReturnStatement(ReturnStatement node) {
     _numReturns++;
     if (_numReturns == 2) {
-      result.addError('Ambiguous return value.', new Location.fromNode(node));
+      result.addError('Ambiguous return value.', newLocation_fromNode(node));
     }
   }
 }
 
 /**
  * Information about the source of a method being inlined.
  */
 class _SourcePart {
   /**
    * The base for all [SourceRange]s.
@@ skipping 157 matching lines @@
   }
 
   void _addVariable(SimpleIdentifier node) {
     VariableElement variableElement = getLocalVariableElement(node);
     if (variableElement != null) {
       SourceRange nodeRange = rangeNode(node);
       result.addVariable(variableElement, nodeRange);
     }
   }
 }