'Extract Local' and 'Inline Local' refactoring need only single file analysis.

pkg/analysis_server/test/edit/refactoring_test.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 test.edit.refactoring;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/edit/edit_domain.dart';
 import 'package:analysis_server/src/services/index/index.dart';
+import 'package:analyzer/task/dart.dart';
 import 'package:plugin/manager.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart' hide ERROR;
 
 import '../analysis_abstract.dart';
 import '../mocks.dart';
 import '../utils.dart';
 
 main() {
   initializeTestEnvironment();
@@ skipping 241 matching lines @@
       String search, String suffix, String name, bool extractAll) {
     int offset = findOffset(search + suffix);
     int length = search.length;
     return sendExtractRequest(offset, length, name, extractAll);
   }
 
   void tearDown() {
     test_simulateRefactoringException_init = false;
     test_simulateRefactoringException_final = false;
     test_simulateRefactoringException_change = false;
-    test_simulateRefactoringReset_afterInitialConditions = false;
-    test_simulateRefactoringReset_afterFinalConditions = false;
-    test_simulateRefactoringReset_afterCreateChange = false;
     super.tearDown();
   }
 
+  test_analysis_onlyOneFile() async {
+    shouldWaitForFullAnalysis = false;
+    String otherFile = '$testFolder/other.dart';
+    addFile(
+        otherFile,
+        r'''
+foo(int myName) {}
+''');
+    addTestFile('''
+import 'other.dart';
+main() {
+  foo(1 + 2);
+}
+''');
+    // Start refactoring.
+    EditGetRefactoringResult result = await getRefactoringResult(() {
+      return sendStringRequest('1 + 2', 'res', true);
+    });
+    // We get the refactoring feedback....
+    ExtractLocalVariableFeedback feedback = result.feedback;
+    expect(feedback.names, contains('myName'));
+    // ...even though other.dart is not fully analyzed.
+    var otherSource = server.getContextSourcePair(otherFile).source;
+    var otherUnit = new LibrarySpecificUnit(otherSource, otherSource);
+    expect(testContext.getResult(otherUnit, RESOLVED_UNIT), isNull);
+  }
+
   test_coveringExpressions() {
     addTestFile('''
 main() {
   var v = 111 + 222 + 333;
 }
 ''');
     return getRefactoringResult(() {
       return sendExtractRequest(testCode.indexOf('222 +'), 0, 'res', true);
     }).then((result) {
       ExtractLocalVariableFeedback feedback = result.feedback;
@@ skipping 95 matching lines @@
 ''');
     return getRefactoringResult(() {
       return sendStringRequest('1 + 2', 'res', true);
     }).then((result) {
       ExtractLocalVariableFeedback feedback = result.feedback;
       expect(feedback.offsets, [findOffset('1 + 2'), findOffset('1 +  2')]);
       expect(feedback.lengths, [5, 6]);
     });
   }
 
-  test_reset_afterCreateChange() {
-    test_simulateRefactoringReset_afterCreateChange = true;
+  test_resetOnFileChange() async {
+    String otherFile = '$testFolder/other.dart';
+    addFile(otherFile, '// other 1');
     addTestFile('''
 main() {
-  print(1 + 2);
+  foo(1 + 2);
 }
+foo(int myName) {}
 ''');
-    return waitForTasksFinished().then((_) {
-      return sendStringRequest('1 + 2', 'res', true).then((response) {
-        _expectRefactoringRequestCancelled(response);
+    // Send the first request.
+    {
+      EditGetRefactoringResult result = await getRefactoringResult(() {
+        return sendStringRequest('1 + 2', 'res', true);
       });
-    });
-  }
-
-  test_reset_afterFinalConditions() {
-    test_simulateRefactoringReset_afterFinalConditions = true;
-    addTestFile('''
+      ExtractLocalVariableFeedback feedback = result.feedback;
+      expect(feedback.names, contains('myName'));
+    }
+    int initialResetCount = test_resetCount;
+    // Update the other.dart file.
+    // The refactoring is not reset, because it's a different file.
+    addFile(otherFile, '// other 2');
+    await pumpEventQueue();
+    expect(test_resetCount, initialResetCount);
+    // Update the test.dart file.
+    modifyTestFile('''
 main() {
-  print(1 + 2);
+  foo(1 + 2);
 }
+foo(int otherName) {}
 ''');
-    return waitForTasksFinished().then((_) {
-      return sendStringRequest('1 + 2', 'res', true).then((response) {
-        _expectRefactoringRequestCancelled(response);
+    // The refactoring was reset.
+    await pumpEventQueue();
+    expect(test_resetCount, initialResetCount + 1);
+    // Send the second request, with the same kind, file and offset.
+    {
+      EditGetRefactoringResult result = await getRefactoringResult(() {
+        return sendStringRequest('1 + 2', 'res', true);
       });
-    });
-  }
-
-  test_reset_afterInitialConditions() {
-    test_simulateRefactoringReset_afterInitialConditions = true;
-    addTestFile('''
-main() {
-  print(1 + 2);
-}
-''');
-    return waitForTasksFinished().then((_) {
-      return sendStringRequest('1 + 2', 'res', true).then((response) {
-        _expectRefactoringRequestCancelled(response);
-      });
-    });
+      ExtractLocalVariableFeedback feedback = result.feedback;
+      // The refactoring was reset, so we don't get stale results.
+      expect(feedback.names, contains('otherName'));
+    }
   }
 
   test_serverError_change() {
     test_simulateRefactoringException_change = true;
     addTestFile('''
 main() {
   print(1 + 2);
 }
 ''');
     return waitForTasksFinished().then((_) {
@@ skipping 26 matching lines @@
   print(1 + 2);
 }
 ''');
     return waitForTasksFinished().then((_) {
       return sendStringRequest('1 + 2', 'res', true).then((response) {
         expect(response.error, isNotNull);
         expect(response.error.code, RequestErrorCode.SERVER_ERROR);
       });
     });
   }
-
-  void _expectRefactoringRequestCancelled(Response response) {
-    expect(response.error, isNotNull);
-    expect(response,
-        isResponseFailure('0', RequestErrorCode.REFACTORING_REQUEST_CANCELLED));
-  }
 }
 
 @reflectiveTest
 class ExtractMethodTest extends _AbstractGetRefactoring_Test {
   int offset;
   int length;
   String name = 'res';
   ExtractMethodOptions options;
 
   test_expression() {
@@ skipping 427 matching lines @@
 }
 ''');
     await waitForTasksFinished();
     await getRefactoringsAtString('// not an element');
     expect(kinds, isNot(contains(RefactoringKind.RENAME)));
   }
 }
 
 @reflectiveTest
 class InlineLocalTest extends _AbstractGetRefactoring_Test {
+  test_analysis_onlyOneFile() async {
+    shouldWaitForFullAnalysis = false;
+    String otherFile = '$testFolder/other.dart';
+    addFile(
+        otherFile,
+        r'''
+foo(int p) {}
+''');
+    addTestFile('''
+import 'other.dart';
+main() {
+  int res = 1 + 2;
+  foo(res);
+  foo(res);
+}
+''');
+    // Start refactoring.
+    EditGetRefactoringResult result = await getRefactoringResult(() {
+      return _sendInlineRequest('res =');
+    });
+    // We get the refactoring feedback....
+    InlineLocalVariableFeedback feedback = result.feedback;
+    expect(feedback.occurrences, 2);
+    // ...even though other.dart is not fully analyzed.
+    var otherSource = server.getContextSourcePair(otherFile).source;
+    var otherUnit = new LibrarySpecificUnit(otherSource, otherSource);
+    expect(testContext.getResult(otherUnit, RESOLVED_UNIT), isNull);
+  }
+
   test_feedback() {
     addTestFile('''
 main() {
   int test = 42;
   print(test);
   print(test);
 }
 ''');
     return getRefactoringResult(() {
       return _sendInlineRequest('test =');
@@ skipping 28 matching lines @@
       return _sendInlineRequest('test + 2');
     },
         '''
 main() {
   int a = 42 + 2;
   print(42);
 }
 ''');
   }
 
+  test_resetOnFileChange() async {
+    String otherFile = '$testFolder/other.dart';
+    addFile(otherFile, '// other 1');
+    addTestFile('''
+main() {
+  int res = 1 + 2;
+  print(res);
+}
+''');
+    // Send the first request.
+    await getRefactoringResult(() {
+      return _sendInlineRequest('res = ');
+    });
+    int initialResetCount = test_resetCount;
+    // Update the other.dart file.
+    // The refactoring is not reset, because it's a different file.
+    addFile(otherFile, '// other 2');
+    await pumpEventQueue();
+    expect(test_resetCount, initialResetCount);
+    // Update the test.dart file.
+    modifyTestFile('''
+main() {
+  print(1 + 2);
+}
+''');
+    // The refactoring was reset.
+    await pumpEventQueue();
+    expect(test_resetCount, initialResetCount + 1);
+  }
+
   Future<Response> _sendInlineRequest(String search) {
     Request request = new EditGetRefactoringParams(
             RefactoringKind.INLINE_LOCAL_VARIABLE,
             testFile,
             findOffset(search),
             0,
             false)
         .toRequest('0');
     return serverChannel.sendRequest(request);
   }
@@ skipping 166 matching lines @@
   Future<Response> sendRenameRequest(String search, String newName,
       {String id: '0', bool validateOnly: false}) {
     RenameOptions options = newName != null ? new RenameOptions(newName) : null;
     Request request = new EditGetRefactoringParams(RefactoringKind.RENAME,
             testFile, findOffset(search), 0, validateOnly,
             options: options)
         .toRequest(id);
     return serverChannel.sendRequest(request);
   }
 
+  void tearDown() {
+    test_simulateRefactoringReset_afterInitialConditions = false;
+    test_simulateRefactoringReset_afterFinalConditions = false;
+    test_simulateRefactoringReset_afterCreateChange = false;
+    super.tearDown();
+  }
+
   test_cancelPendingRequest() async {
     addTestFile('''
 main() {
   int test = 0;
   print(test);
 }
 ''');
     // send the "1" request, but don't wait for it
     Future<Response> futureA = sendRenameRequest('test =', 'nameA', id: '1');
     // send the "2" request and wait for it
@@ skipping 549 matching lines @@
     return getRefactoringResult(() {
       return sendRenameRequest('test = 0', 'newName');
     }).then((result) {
       List<RefactoringProblem> problems = result.finalProblems;
       expect(problems, hasLength(1));
       assertResultProblemsError(
           problems, "Duplicate local variable 'newName'.");
     });
   }
 
+  test_reset_afterCreateChange() {
+    test_simulateRefactoringReset_afterCreateChange = true;
+    addTestFile('''
+test() {}
+main() {
+  test();
+}
+''');
+    return waitForTasksFinished().then((_) {
+      return sendRenameRequest('test() {}', 'newName').then((response) {
+        _expectRefactoringRequestCancelled(response);
+      });
+    });
+  }
+
+  test_reset_afterFinalConditions() {
+    test_simulateRefactoringReset_afterFinalConditions = true;
+    addTestFile('''
+test() {}
+main() {
+  test();
+}
+''');
+    return waitForTasksFinished().then((_) {
+      return sendRenameRequest('test() {}', 'newName').then((response) {
+        _expectRefactoringRequestCancelled(response);
+      });
+    });
+  }
+
+  test_reset_afterInitialConditions() {
+    test_simulateRefactoringReset_afterInitialConditions = true;
+    addTestFile('''
+test() {}
+main() {
+  test();
+}
+''');
+    return waitForTasksFinished().then((_) {
+      return sendRenameRequest('test() {}', 'newName').then((response) {
+        _expectRefactoringRequestCancelled(response);
+      });
+    });
+  }
+
   test_resetOnAnalysis() {
     addTestFile('''
 main() {
   int initialName = 0;
   print(initialName);
 }
 ''');
     // send the first request
     return getRefactoringResult(() {
       return sendRenameRequest('initialName =', 'newName', validateOnly: true);
@@ skipping 14 matching lines @@
               validateOnly: true);
         }).then((result) {
           RenameFeedback feedback = result.feedback;
           // the refactoring was reset, so we don't get a stale result
           expect(feedback.oldName, 'otherName');
         });
       });
     });
   }
 
+  void _expectRefactoringRequestCancelled(Response response) {
+    expect(response.error, isNotNull);
+    expect(response,
+        isResponseFailure('0', RequestErrorCode.REFACTORING_REQUEST_CANCELLED));
+  }
+
   SourceEdit _findEditWithId(SourceChange change, String id) {
     SourceEdit potentialEdit;
     change.edits.forEach((fileEdit) {
       fileEdit.edits.forEach((edit) {
         if (edit.id == id) {
           potentialEdit = edit;
         }
       });
     });
     return potentialEdit;
   }
 }
 
 @reflectiveTest
 class _AbstractGetRefactoring_Test extends AbstractAnalysisTest {
+  bool shouldWaitForFullAnalysis = true;
+
   /**
    * Asserts that [problems] has a single ERROR problem.
    */
   void assertResultProblemsError(List<RefactoringProblem> problems,
       [String message]) {
     RefactoringProblem problem = problems[0];
     expect(problem.severity, RefactoringProblemSeverity.ERROR,
         reason: problem.toString());
     if (message != null) {
       expect(problem.message, message);
@@ skipping 63 matching lines @@
     fail('No SourceFileEdit for $testFile in $change');
   }
 
   @override
   Index createIndex() {
     return createMemoryIndex();
   }
 
   Future<EditGetRefactoringResult> getRefactoringResult(
       Future<Response> requestSender()) async {
-    await waitForTasksFinished();
+    if (shouldWaitForFullAnalysis) {
+      await waitForTasksFinished();
+    }
     Response response = await requestSender();
     return new EditGetRefactoringResult.fromResponse(response);
   }
 
   Future<Response> sendRequest(
       RefactoringKind kind, int offset, int length, RefactoringOptions options,
       [bool validateOnly = false]) {
     Request request = new EditGetRefactoringParams(
             kind, testFile, offset, length, validateOnly,
             options: options)
@@ skipping 43 matching lines @@
         .toRequest('0');
     return _assertErrorResponseNoIndex(request);
   }
 
   _assertErrorResponseNoIndex(Request request) async {
     Response response = await serverChannel.sendRequest(request);
     expect(response.error, isNotNull);
     expect(response.error.code, RequestErrorCode.NO_INDEX_GENERATED);
   }
 }