Streamline AnalysisDriver status tracking.

pkg/analyzer/test/src/dart/analysis/driver_test.dart

 // Copyright (c) 2016, 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 analyzer.test.driver;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 94 matching lines @@
     provider.newFile(c, 'class C {}');
     driver1.addFile(a);
     driver2.addFile(b);
     driver2.addFile(c);
     driver1.priorityFiles = [a];
     driver2.priorityFiles = [a];
 
     AnalysisResult result = await driver2.getResult(b);
     expect(result.path, b);
 
-    await driver1.status.firstWhere((status) => status.isIdle);
-    await driver2.status.firstWhere((status) => status.isIdle);
+    await scheduler.status.firstWhere((status) => status.isIdle);
 
     expect(allResults, hasLength(3));
     expect(allResults[0].path, b);
     expect(allResults[1].path, a);
     expect(allResults[2].path, c);
   }
 
   test_priorities_priorityBeforeGeneral1() async {
     AnalysisDriver driver1 = newDriver();
     AnalysisDriver driver2 = newDriver();
 
     String a = _p('/a.dart');
     String b = _p('/b.dart');
     provider.newFile(a, 'class A {}');
     provider.newFile(b, 'class B {}');
     driver1.addFile(a);
     driver2.addFile(b);
     driver1.priorityFiles = [a];
     driver2.priorityFiles = [a];
 
-    await driver1.status.firstWhere((status) => status.isIdle);
-    await driver2.status.firstWhere((status) => status.isIdle);
+    await scheduler.status.firstWhere((status) => status.isIdle);
 
     expect(allResults, hasLength(2));
     expect(allResults[0].path, a);
     expect(allResults[1].path, b);
   }
 
   test_priorities_priorityBeforeGeneral2() async {
     AnalysisDriver driver1 = newDriver();
     AnalysisDriver driver2 = newDriver();
 
     String a = _p('/a.dart');
     String b = _p('/b.dart');
     provider.newFile(a, 'class A {}');
     provider.newFile(b, 'class B {}');
     driver1.addFile(a);
     driver2.addFile(b);
     driver1.priorityFiles = [b];
     driver2.priorityFiles = [b];
 
-    await driver1.status.firstWhere((status) => status.isIdle);
-    await driver2.status.firstWhere((status) => status.isIdle);
+    await scheduler.status.firstWhere((status) => status.isIdle);
 
     expect(allResults, hasLength(2));
     expect(allResults[0].path, b);
     expect(allResults[1].path, a);
   }
 
   test_priorities_priorityBeforeGeneral3() async {
     AnalysisDriver driver1 = newDriver();
     AnalysisDriver driver2 = newDriver();
 
     String a = _p('/a.dart');
     String b = _p('/b.dart');
     String c = _p('/c.dart');
     provider.newFile(a, 'class A {}');
     provider.newFile(b, 'class B {}');
     provider.newFile(c, 'class C {}');
     driver1.addFile(a);
     driver1.addFile(b);
     driver2.addFile(c);
     driver1.priorityFiles = [a, c];
     driver2.priorityFiles = [a, c];
 
-    await driver1.status.firstWhere((status) => status.isIdle);
-    await driver2.status.firstWhere((status) => status.isIdle);
+    await scheduler.status.firstWhere((status) => status.isIdle);
 
     expect(allResults, hasLength(3));
     expect(allResults[0].path, a);
     expect(allResults[1].path, c);
     expect(allResults[2].path, b);
   }
 
   test_status() async {
     AnalysisDriver driver1 = newDriver();
     AnalysisDriver driver2 = newDriver();
@@ skipping 90 matching lines @@
     driver.addFile(a);
     driver.addFile(b);
 
     void assertNumberOfErrorsInB(int n) {
       var bResult = allResults.singleWhere((r) => r.path == b);
       expect(bResult.errors, hasLength(n));
       allResults.clear();
     }
 
     // Initial analysis, 'b' does not use 'a', so there is a hint.
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     assertNumberOfErrorsInB(1);
 
     // Update 'b' to use 'a', no more hints.
     provider.newFile(
         b,
         r'''
 import 'a.dart';
 main() {
   print(A);
 }
 ''');
     driver.changeFile(b);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     assertNumberOfErrorsInB(0);
 
     // Change 'b' content so that it has a hint.
     // Remove 'b' and add it again.
     // The file 'b' must be refreshed, and the hint must be reported.
     provider.newFile(
         b,
         r'''
 import 'a.dart';
 ''');
     driver.removeFile(b);
     driver.addFile(b);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     assertNumberOfErrorsInB(1);
   }
 
   test_addFile_thenRemove() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     provider.newFile(a, 'class A {}');
     provider.newFile(b, 'class B {}');
     driver.addFile(a);
     driver.addFile(b);
 
     // Now remove 'a'.
     driver.removeFile(a);
 
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     // Only 'b' has been analyzed, because 'a' was removed before we started.
     expect(allResults, hasLength(1));
     expect(allResults[0].path, b);
   }
 
   test_cachedPriorityResults() async {
     var a = _p('/test/bin/a.dart');
     provider.newFile(a, 'var a = 1;');
 
@@ skipping 88 matching lines @@
         r'''
 import 'b.dart';
 var A = B;
 ''');
     provider.newFile(b, 'var B = 1;');
 
     driver.priorityFiles = [a];
     driver.addFile(a);
 
     // We have a result only for "a".
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, hasLength(1));
     {
       AnalysisResult ar = allResults.firstWhere((r) => r.path == a);
       expect(_getTopLevelVarType(ar.unit, 'A'), 'int');
     }
     allResults.clear();
 
     // Change "b" and notify.
     provider.updateFile(b, 'var B = 1.2;');
     driver.changeFile(b);
 
     // "b" is not an added file, so it is not scheduled for analysis.
     expect(driver.test.filesToAnalyze, isEmpty);
 
     // While "b" is not analyzed explicitly, it is analyzed implicitly.
     // The change causes "a" to be reanalyzed.
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, hasLength(1));
     {
       AnalysisResult ar = allResults.firstWhere((r) => r.path == a);
       expect(_getTopLevelVarType(ar.unit, 'A'), 'double');
     }
   }
 
   test_changeFile_notUsed() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/other/b.dart');
     provider.newFile(a, '');
     provider.newFile(b, 'class B1 {}');
 
     driver.addFile(a);
 
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     allResults.clear();
 
     // Change "b" and notify.
     // Nothing depends on "b", so nothing is analyzed.
     provider.updateFile(b, 'class B2 {}');
     driver.changeFile(b);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, isEmpty);
 
     // This should not add "b" to the file state.
     expect(driver.fsState.knownFilePaths, isNot(contains(b)));
   }
 
   test_changeFile_selfConsistent() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     provider.newFile(
         a,
         r'''
 import 'b.dart';
 var A1 = 1;
 var A2 = B1;
 ''');
     provider.newFile(
         b,
         r'''
 import 'a.dart';
 var B1 = A1;
 ''');
 
     driver.priorityFiles = [a, b];
     driver.addFile(a);
     driver.addFile(b);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     // We have results for both "a" and "b".
     expect(allResults, hasLength(2));
     {
       AnalysisResult ar = allResults.firstWhere((r) => r.path == a);
       expect(_getTopLevelVarType(ar.unit, 'A1'), 'int');
       expect(_getTopLevelVarType(ar.unit, 'A2'), 'int');
     }
     {
       AnalysisResult br = allResults.firstWhere((r) => r.path == b);
       expect(_getTopLevelVarType(br.unit, 'B1'), 'int');
     }
 
     // Clear the results and update "a".
     allResults.clear();
     provider.updateFile(
         a,
         r'''
 import 'b.dart';
 var A1 = 1.2;
 var A2 = B1;
 ''');
     driver.changeFile(a);
 
     // We again get results for both "a" and "b".
     // The results are consistent.
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, hasLength(2));
     {
       AnalysisResult ar = allResults.firstWhere((r) => r.path == a);
       expect(_getTopLevelVarType(ar.unit, 'A1'), 'double');
       expect(_getTopLevelVarType(ar.unit, 'A2'), 'double');
     }
     {
       AnalysisResult br = allResults.firstWhere((r) => r.path == b);
       expect(_getTopLevelVarType(br.unit, 'B1'), 'double');
     }
   }
 
   test_changeFile_single() async {
     addTestFile('var V = 1;', priority: true);
 
     // Initial analysis.
     {
-      await driver.waitForIdle();
+      await scheduler.waitForIdle();
       expect(allResults, hasLength(1));
       AnalysisResult result = allResults[0];
       expect(result.path, testFile);
       expect(_getTopLevelVarType(result.unit, 'V'), 'int');
     }
 
     // Update the file, but don't notify the driver.
     allResults.clear();
     provider.updateFile(testFile, 'var V = 1.2');
 
     // No new results.
     await pumpEventQueue();
     expect(allResults, isEmpty);
 
     // Notify the driver about the change.
     driver.changeFile(testFile);
 
     // The file was added, so it is scheduled for analysis.
     expect(driver.test.filesToAnalyze, contains(testFile));
 
     // We get a new result.
     {
-      await driver.waitForIdle();
+      await scheduler.waitForIdle();
       expect(allResults, hasLength(1));
       AnalysisResult result = allResults[0];
       expect(result.path, testFile);
       expect(_getTopLevelVarType(result.unit, 'V'), 'double');
     }
   }
 
   test_errors_uriDoesNotExist_export() async {
     addTestFile(r'''
 export 'foo.dart';
@@ skipping 74 matching lines @@
       String path = source.fullName;
       if (path == templatePath || path == generatedPath) {
         return uri;
       } else {
         return null;
       }
     });
 
     driver.addFile(templatePath);
 
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allExceptions, isEmpty);
     expect(allResults, isEmpty);
 
     var result = await driver.getResult(templatePath);
     expect(result, isNull);
     expect(allExceptions, isEmpty);
     expect(allResults, isEmpty);
 
     var element = await driver.getUnitElement(templatePath);
     expect(element, isNull);
     expect(allExceptions, isEmpty);
     expect(allResults, isEmpty);
 
     driver.priorityFiles = [templatePath];
     driver.changeFile(templatePath);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allExceptions, isEmpty);
     expect(allResults, isEmpty);
 
     expect(driver.knownFiles, isNot(contains(templatePath)));
   }
 
   test_getErrors() async {
     String content = 'int f() => 42 + bar();';
     addTestFile(content, priority: true);
 
@@ skipping 63 matching lines @@
     expect(result.content, content);
     expect(result.contentHash, _md5(content));
     expect(result.unit, isNotNull);
     expect(result.errors, hasLength(0));
 
     var f = result.unit.declarations[0] as FunctionDeclaration;
     expect(f.name.staticType.toString(), '() → int');
     expect(f.returnType.type.toString(), 'int');
 
     // The same result is also received through the stream.
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, [result]);
   }
 
   test_getResult_constants_defaultParameterValue_localFunction() async {
     var a = _p('/test/bin/a.dart');
     var b = _p('/test/bin/b.dart');
     provider.newFile(a, 'const C = 42;');
     provider.newFile(
         b,
         r'''
 import 'a.dart';
 main() {
   foo({int p: C}) {}
   foo();
 }
 ''');
     driver.addFile(a);
     driver.addFile(b);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     AnalysisResult result = await driver.getResult(b);
     expect(result.errors, isEmpty);
   }
 
   test_getResult_doesNotExist() async {
     var a = _p('/test/lib/a.dart');
 
     AnalysisResult result = await driver.getResult(a);
     expect(result.path, a);
@@ skipping 37 matching lines @@
   }
 
   test_getResult_inferTypes_finalField() async {
     addTestFile(
         r'''
 class C {
   final f = 42;
 }
 ''',
         priority: true);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(_getClassFieldType(result.unit, 'C', 'f'), 'int');
   }
 
   test_getResult_inferTypes_instanceMethod() async {
     addTestFile(
         r'''
 class A {
   int m(double p) => 1;
 }
 class B extends A {
   m(double p) => 2;
 }
 ''',
         priority: true);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(_getClassMethodReturnType(result.unit, 'A', 'm'), 'int');
     expect(_getClassMethodReturnType(result.unit, 'B', 'm'), 'int');
   }
 
   test_getResult_invalid_annotation_functionAsConstructor() async {
     addTestFile(
         r'''
 fff() {}
@@ skipping 136 matching lines @@
 ''');
     provider.newFile(
         c,
         r'''
 import '../lib/a.dart';
 var VC = new A<double>();
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     {
       AnalysisResult result = await driver.getResult(b);
       expect(_getImportSource(result.unit, 0).uri.toString(),
           'package:test/a.dart');
       expect(_getTopLevelVarType(result.unit, 'VB'), 'A<int>');
     }
 
     {
       AnalysisResult result = await driver.getResult(c);
@@ skipping 15 matching lines @@
 ''');
     provider.newFile(
         b,
         r'''
 import 'a.dart';
 var B1 = A1;
 ''');
 
     driver.addFile(a);
     driver.addFile(b);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     {
       AnalysisResult result = await driver.getResult(a);
       expect(_getTopLevelVarType(result.unit, 'A1'), 'int');
       expect(_getTopLevelVarType(result.unit, 'A2'), 'int');
     }
 
     // Update "a" so that "A1" is now "double".
     // Get result for "a".
     //
@@ skipping 154 matching lines @@
 
   test_hasFilesToAnalyze() async {
     // No files yet, nothing to analyze.
     expect(driver.hasFilesToAnalyze, isFalse);
 
     // Add a new file, it should be analyzed.
     addTestFile('main() {}', priority: false);
     expect(driver.hasFilesToAnalyze, isTrue);
 
     // Wait for idle, nothing to do.
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(driver.hasFilesToAnalyze, isFalse);
 
     // Ask to analyze the file, so there is a file to analyze.
     Future<AnalysisResult> future = driver.getResult(testFile);
     expect(driver.hasFilesToAnalyze, isTrue);
 
     // Once analysis is done, there is nothing to analyze.
     await future;
     expect(driver.hasFilesToAnalyze, isFalse);
 
     // Change a file, even if not added, it still might affect analysis.
     driver.changeFile(_p('/not/added.dart'));
     expect(driver.hasFilesToAnalyze, isTrue);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(driver.hasFilesToAnalyze, isFalse);
 
     // Request of referenced names is not analysis of a file.
     driver.getFilesReferencingName('X');
     expect(driver.hasFilesToAnalyze, isFalse);
   }
 
   test_hermetic_modifyLibraryFile_resolvePart() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
@@ skipping 66 matching lines @@
     provider.newFile(
         a,
         r'''
 import 'b.dart';
 ''');
     provider.newFile(b, '');
     provider.newFile(c, '');
 
     driver.addFile(a);
     driver.addFile(c);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     expect(driver.knownFiles, contains(a));
     expect(driver.knownFiles, contains(b));
     expect(driver.knownFiles, contains(c));
 
     // Remove a.dart and analyze.
     // Both a.dart and b.dart are not known now.
     driver.removeFile(a);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(driver.knownFiles, isNot(contains(a)));
     expect(driver.knownFiles, isNot(contains(b)));
     expect(driver.knownFiles, contains(c));
   }
 
   test_knownFiles_beforeAnalysis() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
 
     provider.newFile(a, '');
@@ skipping 231 matching lines @@
 var a = new A();
 var b = new B();
 ''');
 
     // The order is important for creating the test case.
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
 
     {
-      await driver.waitForIdle();
+      await scheduler.waitForIdle();
 
       // c.dart was added after a.dart, so it is analyzed after a.dart,
       // so we know that a.dart is the library of c.dart, so no errors.
       AnalysisResult result = allResults.lastWhere((r) => r.path == c);
       expect(result.errors, isEmpty);
       expect(result.unit, isNull);
     }
 
     // Update a.dart so that c.dart is not a part.
     {
       provider.updateFile(a, '// does not use c.dart anymore');
       driver.changeFile(a);
-      await driver.waitForIdle();
+      await scheduler.waitForIdle();
 
       // Now c.dart does not have a library context, so A and B cannot be
       // resolved, so there are errors.
       AnalysisResult result = allResults.lastWhere((r) => r.path == c);
       expect(result.errors, isNotEmpty);
       expect(result.unit, isNull);
     }
   }
 
   test_part_results_beforeLibrary() async {
@@ skipping 17 matching lines @@
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     // The order is important for creating the test case.
     driver.addFile(c);
     driver.addFile(a);
     driver.addFile(b);
 
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     // c.dart was added before a.dart, so we attempt to analyze it before
     // a.dart, but we cannot find the library for it, so we delay analysis
     // until all other files are analyzed, including a.dart, after which we
     // analyze the delayed parts.
     AnalysisResult result = allResults.lastWhere((r) => r.path == c);
     expect(result.errors, isEmpty);
     expect(result.unit, isNull);
   }
 
   test_part_results_noLibrary() async {
     var c = _p('/test/lib/c.dart');
     provider.newFile(
         c,
         r'''
 part of a;
 class C {}
 var a = new A();
 var b = new B();
 ''');
 
     driver.addFile(c);
 
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     // There is no library which c.dart is a part of, so it has unresolved
     // A and B references.
     AnalysisResult result = allResults.lastWhere((r) => r.path == c);
     expect(result.errors, isNotEmpty);
     expect(result.unit, isNull);
   }
 
   test_part_results_priority_beforeLibrary() async {
     var a = _p('/test/lib/a.dart');
@@ skipping 17 matching lines @@
 var a = new A();
 var b = new B();
 ''');
 
     // The order is important for creating the test case.
     driver.priorityFiles = [c];
     driver.addFile(c);
     driver.addFile(a);
     driver.addFile(b);
 
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     // c.dart was added before a.dart, so we attempt to analyze it before
     // a.dart, but we cannot find the library for it, so we delay analysis
     // until all other files are analyzed, including a.dart, after which we
     // analyze the delayed parts.
     AnalysisResult result = allResults.lastWhere((r) => r.path == c);
     expect(result.errors, isEmpty);
     expect(result.unit, isNotNull);
   }
 
   test_removeFile_changeFile_implicitlyAnalyzed() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     provider.newFile(
         a,
         r'''
 import 'b.dart';
 var A = B;
 ''');
     provider.newFile(b, 'var B = 1;');
 
     driver.priorityFiles = [a, b];
     driver.addFile(a);
     driver.addFile(b);
 
     // We have results for both "a" and "b".
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, hasLength(2));
     {
       AnalysisResult ar = allResults.firstWhere((r) => r.path == a);
       expect(_getTopLevelVarType(ar.unit, 'A'), 'int');
     }
     {
       AnalysisResult br = allResults.firstWhere((r) => r.path == b);
       expect(_getTopLevelVarType(br.unit, 'B'), 'int');
     }
     allResults.clear();
 
     // Remove "b" and send the change notification.
     provider.updateFile(b, 'var B = 1.2;');
     driver.removeFile(b);
     driver.changeFile(b);
 
     // While "b" is not analyzed explicitly, it is analyzed implicitly.
     // We don't get a result for "b".
     // But the change causes "a" to be reanalyzed.
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, hasLength(1));
     {
       AnalysisResult ar = allResults.firstWhere((r) => r.path == a);
       expect(_getTopLevelVarType(ar.unit, 'A'), 'double');
     }
   }
 
   test_removeFile_changeFile_notAnalyzed() async {
     addTestFile('main() {}');
 
     // We have a result.
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, hasLength(1));
     expect(allResults[0].path, testFile);
     allResults.clear();
 
     // Remove the file and send the change notification.
     // The change notification does nothing, because the file is explicitly
     // or implicitly analyzed.
     driver.removeFile(testFile);
     driver.changeFile(testFile);
 
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, isEmpty);
   }
 
   test_removeFile_invalidate_importers() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
 
     provider.newFile(a, 'class A {}');
     provider.newFile(b, "import 'a.dart';  var a = new A();");
 
     driver.addFile(a);
     driver.addFile(b);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     // b.dart s clean.
     expect(allResults.singleWhere((r) => r.path == b).errors, isEmpty);
     allResults.clear();
 
     // Remove a.dart, now b.dart should be reanalyzed and has an error.
     provider.deleteFile(a);
     driver.removeFile(a);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults.singleWhere((r) => r.path == b).errors, hasLength(2));
     allResults.clear();
   }
 
   test_results_priority() async {
     String content = 'int f() => 42;';
     addTestFile(content, priority: true);
 
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     expect(allResults, hasLength(1));
     AnalysisResult result = allResults.single;
     expect(result.path, testFile);
     expect(result.uri.toString(), 'package:test/test.dart');
     expect(result.content, content);
     expect(result.contentHash, _md5(content));
     expect(result.unit, isNotNull);
     expect(result.errors, hasLength(0));
 
     var f = result.unit.declarations[0] as FunctionDeclaration;
     expect(f.name.staticType.toString(), '() → int');
     expect(f.returnType.type.toString(), 'int');
   }
 
   test_results_priorityFirst() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
     var c = _p('/test/lib/c.dart');
     provider.newFile(a, 'class A {}');
     provider.newFile(b, 'class B {}');
     provider.newFile(c, 'class C {}');
 
     driver.addFile(a);
     driver.addFile(b);
     driver.addFile(c);
     driver.priorityFiles = [b];
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     expect(allResults, hasLength(3));
     AnalysisResult result = allResults[0];
     expect(result.path, b);
     expect(result.unit, isNotNull);
     expect(result.errors, hasLength(0));
   }
 
   test_results_regular() async {
     String content = 'int f() => 42;';
     addTestFile(content);
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     expect(allResults, hasLength(1));
     AnalysisResult result = allResults.single;
     expect(result.path, testFile);
     expect(result.uri.toString(), 'package:test/test.dart');
     expect(result.content, isNull);
     expect(result.contentHash, _md5(content));
     expect(result.unit, isNull);
     expect(result.errors, hasLength(0));
   }
 
   test_results_status() async {
     addTestFile('int f() => 42;');
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
 
     expect(allStatuses, hasLength(2));
     expect(allStatuses[0].isAnalyzing, isTrue);
     expect(allStatuses[0].isIdle, isFalse);
     expect(allStatuses[1].isAnalyzing, isFalse);
     expect(allStatuses[1].isIdle, isTrue);
   }
 
   test_waitForIdle() async {
-    // With no analysis to do, driver.waitForIdle should complete immediately.
-    await driver.waitForIdle();
+    // With no analysis to do, scheduler.waitForIdle should complete immediately.
+    await scheduler.waitForIdle();
     // Now schedule some analysis.
     addTestFile('int f() => 42;');
     expect(allResults, isEmpty);
-    // driver.waitForIdle should wait for the analysis.
-    await driver.waitForIdle();
+    // scheduler.waitForIdle should wait for the analysis.
+    await scheduler.waitForIdle();
     expect(allResults, hasLength(1));
     // Make sure there is no more analysis pending.
-    await driver.waitForIdle();
+    await scheduler.waitForIdle();
     expect(allResults, hasLength(1));
   }
 
   void _assertTopLevelDeclarations(
       List<TopLevelDeclarationInSource> declarations,
       List<String> expectedFiles,
       List<bool> expectedIsExported) {
     expect(expectedFiles, hasLength(expectedIsExported.length));
     for (int i = 0; i < expectedFiles.length; i++) {
       expect(declarations,
@@ skipping 99 matching lines @@
    * Return the [provider] specific path for the given Posix [path].
    */
   String _p(String path) => provider.convertPath(path);
 
   static String _md5(String content) {
     return hex.encode(md5.convert(UTF8.encode(content)).bytes);
   }
 }
 
 class _SourceMock extends TypedMock implements Source {}