Make 'Inline Method' refactoring work with the new analysis driver.

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_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/source_range.dart';
@@ skipping 173 matching lines @@
           result.add(classMemberElement.displayName);
         }
       }
     }
   }
   // done
   return result;
 }
 
 /**
+ * Completes with the resolved [CompilationUnit] that contains the [element].
+ */
+typedef Future<CompilationUnit> GetResolvedUnitContainingElement(
+    Element element);
+
+/**
  * [InlineMethodRefactoring] implementation.
  */
 class InlineMethodRefactoringImpl extends RefactoringImpl
     implements InlineMethodRefactoring {
   final SearchEngine searchEngine;
+  final GetResolvedUnitContainingElement getResolvedUnit;
   final CompilationUnit unit;
   final int offset;
   CorrectionUtils utils;
   SourceChange change;
 
   bool isDeclaration = false;
   bool deleteSource = false;
   bool inlineAll = true;
 
   ExecutableElement _methodElement;
   bool _isAccessor;
   CompilationUnit _methodUnit;
   CorrectionUtils _methodUtils;
   AstNode _methodNode;
   FormalParameterList _methodParameters;
   FunctionBody _methodBody;
   Expression _methodExpression;
   _SourcePart _methodExpressionPart;
   _SourcePart _methodStatementsPart;
   List<_ReferenceProcessor> _referenceProcessors = [];
   Set<FunctionBody> _alreadyMadeAsync = new Set<FunctionBody>();
 
-  InlineMethodRefactoringImpl(this.searchEngine, this.unit, this.offset) {
+  InlineMethodRefactoringImpl(
+      this.searchEngine, this.getResolvedUnit, this.unit, this.offset) {
     utils = new CorrectionUtils(unit);
   }
 
   @override
   String get className {
     if (_methodElement == null) {
       return null;
     }
     Element classElement = _methodElement.enclosingElement;
     if (classElement is ClassElement) {
@@ skipping 40 matching lines @@
           change, _methodElement, newSourceEdit_range(linesRange, ''));
     }
     // done
     return new Future.value(result);
   }
 
   @override
   Future<RefactoringStatus> checkInitialConditions() async {
     RefactoringStatus result = new RefactoringStatus();
     // prepare method information
-    result.addStatus(_prepareMethod());
+    result.addStatus(await _prepareMethod());
     if (result.hasFatalError) {
       return new Future<RefactoringStatus>.value(result);
     }
     // maybe operator
     if (_methodElement.isOperator) {
       result = new RefactoringStatus.fatal('Cannot inline operator.');
       return new Future<RefactoringStatus>.value(result);
     }
     // maybe [a]sync*
     if (_methodElement.isGenerator) {
       result = new RefactoringStatus.fatal('Cannot inline a generator.');
       return new Future<RefactoringStatus>.value(result);
     }
     // analyze method body
     result.addStatus(_prepareMethodParts());
     // process references
     List<SearchMatch> references =
         await searchEngine.searchReferences(_methodElement);
     _referenceProcessors.clear();
     for (SearchMatch reference in references) {
       _ReferenceProcessor processor = new _ReferenceProcessor(this, reference);
+      await processor.init();
       _referenceProcessors.add(processor);
     }
     return result;
   }
 
   @override
   Future<SourceChange> createChange() {
     return new Future.value(change);
   }
 
   @override
   bool requiresPreview() => false;
 
   _SourcePart _createSourcePart(SourceRange range) {
     String source = _methodUtils.getRangeText(range);
     String prefix = getLinePrefix(source);
     _SourcePart result = new _SourcePart(range.offset, source, prefix);
     // remember parameters and variables occurrences
     _methodUnit.accept(new _VariablesVisitor(_methodElement, range, result));
     // done
     return result;
   }
 
   /**
    * Initializes [_methodElement] and related fields.
    */
-  RefactoringStatus _prepareMethod() {
+  Future<RefactoringStatus> _prepareMethod() async {
     _methodElement = null;
     _methodParameters = null;
     _methodBody = null;
     deleteSource = false;
     inlineAll = false;
     // prepare for failure
     RefactoringStatus fatalStatus = new RefactoringStatus.fatal(
         'Method declaration or reference must be selected to activate this refactoring.');
     // prepare selected SimpleIdentifier
     AstNode node = new NodeLocator(offset).searchWithin(unit);
     if (node is! SimpleIdentifier) {
       return fatalStatus;
     }
     SimpleIdentifier identifier = node as SimpleIdentifier;
     // prepare selected ExecutableElement
     Element element = identifier.bestElement;
     if (element is! ExecutableElement) {
       return fatalStatus;
     }
     if (element.isSynthetic) {
       return fatalStatus;
     }
     _methodElement = element as ExecutableElement;
     _isAccessor = element is PropertyAccessorElement;
-    _methodUnit = element.unit;
+    _methodUnit = await getResolvedUnit(element);
     _methodUtils = new CorrectionUtils(_methodUnit);
     // class member
     bool isClassMember = element.enclosingElement is ClassElement;
     if (element is MethodElement || _isAccessor && isClassMember) {
       MethodDeclaration methodDeclaration = element.computeNode();
       _methodNode = methodDeclaration;
       _methodParameters = methodDeclaration.parameters;
       _methodBody = methodDeclaration.body;
       // prepare mode
       isDeclaration = node == methodDeclaration.name;
@@ skipping 62 matching lines @@
   final int parentPrecedence;
   final SourceRange range;
   _ParameterOccurrence(this.parentPrecedence, this.range);
 }
 
 /**
  * Processor for single [SearchMatch] reference to [methodElement].
  */
 class _ReferenceProcessor {
   final InlineMethodRefactoringImpl ref;
+  final SearchMatch reference;
 
   Element refElement;
   CorrectionUtils _refUtils;
   SimpleIdentifier _node;
   SourceRange _refLineRange;
   String _refPrefix;
 
-  _ReferenceProcessor(this.ref, SearchMatch reference) {
+  _ReferenceProcessor(this.ref, this.reference);
+
+  Future<Null> init() async {
     refElement = reference.element;
     // prepare CorrectionUtils
-    CompilationUnit refUnit = refElement.unit;
+    CompilationUnit refUnit = await ref.getResolvedUnit(refElement);
     _refUtils = new CorrectionUtils(refUnit);
     // prepare node and environment
     _node = _refUtils.findNode(reference.sourceRange.offset);
     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);
@@ skipping 399 matching lines @@
   }
 
   void _addVariable(SimpleIdentifier node) {
     VariableElement variableElement = getLocalVariableElement(node);
     if (variableElement != null) {
       SourceRange nodeRange = rangeNode(node);
       result.addVariable(variableElement, nodeRange);
     }
   }
 }