Run 'Inline Method' refactoring tests 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 181 matching lines @@
 
 /**
  * [InlineMethodRefactoring] implementation.
  */
 class InlineMethodRefactoringImpl extends RefactoringImpl
     implements InlineMethodRefactoring {
   final SearchEngine searchEngine;
   final GetResolvedUnit getResolvedUnit;
   final CompilationUnit unit;
   final int offset;
+  _UnitCache _unitCache;
   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.getResolvedUnit, this.unit, this.offset) {
+    _unitCache = new _UnitCache(getResolvedUnit, unit);
     utils = new CorrectionUtils(unit);
   }
 
   @override
   String get className {
     if (_methodElement == null) {
       return null;
     }
     Element classElement = _methodElement.enclosingElement;
     if (classElement is ClassElement) {
@@ skipping 76 matching lines @@
   }
 
   @override
   Future<SourceChange> createChange() {
     return new Future.value(change);
   }
 
   @override
   bool requiresPreview() => false;
 
+  Future<FunctionDeclaration> _computeFunctionDeclaration() async {
+    CompilationUnit unit = await _unitCache.getUnit(_methodElement);
+    return new NodeLocator(_methodElement.nameOffset)
+        .searchWithin(unit)
+        .getAncestor((n) => n is FunctionDeclaration) as FunctionDeclaration;
+  }
+
+  Future<MethodDeclaration> _computeMethodDeclaration() async {
+    CompilationUnit unit = await _unitCache.getUnit(_methodElement);
+    return new NodeLocator(_methodElement.nameOffset)
+        .searchWithin(unit)
+        .getAncestor((n) => n is MethodDeclaration) as MethodDeclaration;
+  }
+
   _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;
   }
 
@@ skipping 18 matching lines @@
     // 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 = await getResolvedUnit(element);
+    _methodUnit = await _unitCache.getUnit(element);
     _methodUtils = new CorrectionUtils(_methodUnit);
     // class member
     bool isClassMember = element.enclosingElement is ClassElement;
     if (element is MethodElement || _isAccessor && isClassMember) {
-      MethodDeclaration methodDeclaration = element.computeNode();
+      MethodDeclaration methodDeclaration = await _computeMethodDeclaration();
       _methodNode = methodDeclaration;
       _methodParameters = methodDeclaration.parameters;
       _methodBody = methodDeclaration.body;
       // prepare mode
       isDeclaration = node == methodDeclaration.name;
       deleteSource = isDeclaration;
       inlineAll = deleteSource;
       return new RefactoringStatus();
     }
     // unit member
     bool isUnitMember = element.enclosingElement is CompilationUnitElement;
     if (element is FunctionElement || _isAccessor && isUnitMember) {
-      FunctionDeclaration functionDeclaration = element.computeNode();
+      FunctionDeclaration functionDeclaration =
+          await _computeFunctionDeclaration();
       _methodNode = functionDeclaration;
       _methodParameters = functionDeclaration.functionExpression.parameters;
       _methodBody = functionDeclaration.functionExpression.body;
       // prepare mode
       isDeclaration = node == functionDeclaration.name;
       deleteSource = isDeclaration;
       inlineAll = deleteSource;
       return new RefactoringStatus();
     }
     // OK
@@ skipping 57 matching lines @@
   CorrectionUtils _refUtils;
   SimpleIdentifier _node;
   SourceRange _refLineRange;
   String _refPrefix;
 
   _ReferenceProcessor(this.ref, this.reference);
 
   Future<Null> init() async {
     refElement = reference.element;
     // prepare CorrectionUtils
-    CompilationUnit refUnit = await ref.getResolvedUnit(refElement);
+    CompilationUnit refUnit = await ref._unitCache.getUnit(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 299 matching lines @@
     List<SourceRange> ranges = _variables[element];
     if (ranges == null) {
       ranges = [];
       _variables[element] = ranges;
     }
     range = rangeFromBase(range, _base);
     ranges.add(range);
   }
 }
 
+class _UnitCache {
+  final GetResolvedUnit getResolvedUnit;
+  final Map<CompilationUnitElement, CompilationUnit> map = {};
+
+  _UnitCache(this.getResolvedUnit, CompilationUnit unit) {
+    map[unit.element] = unit;
+  }
+
+  Future<CompilationUnit> getUnit(Element element) async {
+    Element unitElement =
+        element.getAncestor((e) => e is CompilationUnitElement);
+    CompilationUnit unit = map[unitElement];
+    if (unit == null) {
+      unit = unitElement.unit;
+      map[unitElement] = unit;
+    }
+    return unit;
+  }
+}
+
 /**
  * A visitor that fills [_SourcePart] with fields, parameters and variables.
  */
 class _VariablesVisitor extends GeneralizingAstVisitor {
   /**
    * The [ExecutableElement] being inlined.
    */
   final ExecutableElement methodElement;
 
   /**
@@ skipping 80 matching lines @@
   }
 
   void _addVariable(SimpleIdentifier node) {
     VariableElement variableElement = getLocalVariableElement(node);
     if (variableElement != null) {
       SourceRange nodeRange = rangeNode(node);
       result.addVariable(variableElement, nodeRange);
     }
   }
 }