Make creating LibraryContext async, so all its transitive clients.

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.
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 535 matching lines @@
 ''');
 
     driver.addFile(lib);
 
     AnalysisResult libResult = await driver.getResult(lib);
     List<AnalysisError> errors = libResult.errors;
     expect(errors, hasLength(1));
     expect(errors[0].errorCode, CompileTimeErrorCode.PART_OF_NON_PART);
   }
 
+  test_asyncChangesDuringAnalysis_getErrors() async {
+    var path = _p('/test/lib/test.dart');
+    provider.newFile(path, 'class A {}');
+    driver.addFile(path);
+
+    // Compute and cache errors.
+    await driver.getErrors(path);
+    await scheduler.waitForIdle();
+
+    // Simulate a change that happens during reading the cached errors.
+    bool asyncWorkExecuted = false;
+    driver.test.workToWaitAfterComputingResult = (path) {
+      provider.updateFile(path, 'class B');
+      driver.changeFile(path);
+      asyncWorkExecuted = true;
+    };
+
+    ErrorsResult result = await driver.getErrors(testFile);
+    expect(asyncWorkExecuted, isTrue);
+    expect(result.errors, isNotEmpty);
+  }
+
+  test_asyncChangesDuringAnalysis_getResult() async {
+    var path = _p('/test/lib/test.dart');
+    provider.newFile(path, 'class A {}');
+    driver.addFile(path);
+
+    // Schedule the result to be computed.
+    Future<AnalysisResult> future1 = driver.getResult(testFile);
+
+    // Simulate a change that happens during computing the result.
+    // We also request a new result, which must include the change.
+    Future<AnalysisResult> future2;
+    bool asyncWorkExecuted = false;
+    driver.test.workToWaitAfterComputingResult = (path) {
+      provider.updateFile(path, 'class B {}');
+      driver.changeFile(path);
+      future2 = driver.getResult(testFile);
+      asyncWorkExecuted = true;
+    };
+
+    // Both futures complete, with the same result.
+    // The result must be with the new changes.
+    //
+    // It would not be wrong to have "class A {}" in result1, and "class B {}"
+    // in result2, but we test here the actual implementation behaviour.
+    AnalysisResult result1 = await future1;
+    AnalysisResult result2 = await future2;
+    expect(asyncWorkExecuted, isTrue);
+    expect(result2, same(result1));
+    expect(result1.path, testFile);
+    expect(result1.unit, isNotNull);
+    expect((result1.unit.declarations[0] as ClassDeclaration).name.name, 'B');
+  }
+
+  test_asyncChangesDuringAnalysis_resultsStream() async {
+    var path = _p('/test/lib/test.dart');
+    provider.newFile(path, 'class A {}');
+    driver.addFile(path);
+
+    // Simulate a change that happens during computing the result.
+    bool asyncWorkExecuted = false;
+    driver.test.workToWaitAfterComputingResult = (p) {
+      if (p == path && !asyncWorkExecuted) {
+        provider.updateFile(path, 'class B');
+        driver.changeFile(path);
+        asyncWorkExecuted = true;
+      }
+    };
+
+    await scheduler.waitForIdle();
+    expect(asyncWorkExecuted, isTrue);
+
+    // The last result must have an error.
+    expect(allResults.last.errors, isNotEmpty);
+  }
+
+  test_asyncChangesDuringAnalysis_resultsStream_priority() async {
+    var path = _p('/test/lib/test.dart');
+    provider.newFile(path, 'class A {}');
+    driver.addFile(path);
+    driver.priorityFiles = [path];
+
+    // Simulate a change that happens during computing the result.
+    bool asyncWorkExecuted = false;
+    driver.test.workToWaitAfterComputingResult = (p) {
+      if (p == path && !asyncWorkExecuted) {
+        provider.updateFile(path, 'class B {}');
+        driver.changeFile(path);
+        asyncWorkExecuted = true;
+      }
+    };
+
+    await scheduler.waitForIdle();
+    expect(asyncWorkExecuted, isTrue);
+
+    // The last unit must have "class B {}".
+    var lastUnit = allResults.last.unit;
+    expect((lastUnit.declarations[0] as ClassDeclaration).name.name, 'B');
+  }
+
   test_cachedPriorityResults() async {
     var a = _p('/test/bin/a.dart');
     provider.newFile(a, 'var a = 1;');
 
     driver.priorityFiles = [a];
 
     AnalysisResult result1 = await driver.getResult(a);
     expect(driver.test.priorityResults, containsPair(a, result1));
 
     await scheduler.waitForIdle();
@@ skipping 404 matching lines @@
     provider.newFile(a, r'''
 class A {}
 ''');
     provider.newFile(b, r'''
 import 'a.dart';
 var a = new A();
 ''');
 
     // Prepare the store with a.dart and everything it needs.
     SummaryDataStore summaryStore =
-        createAnalysisDriver().test.getSummaryStore(a);
+        await createAnalysisDriver().test.getSummaryStore(a);
 
     // There are at least a.dart and dart:core libraries.
     String aUri = provider.pathContext.toUri(a).toString();
     expect(summaryStore.unlinkedMap.keys, contains(aUri));
     expect(summaryStore.linkedMap.keys, contains(aUri));
     expect(summaryStore.unlinkedMap.keys, contains('dart:core'));
     expect(summaryStore.linkedMap.keys, contains('dart:core'));
 
     // Remove a.dart from the file system.
     provider.deleteFile(a);
@@ skipping 159 matching lines @@
     expect(fooId, isNonNegative);
   }
 
   test_getLibraryByUri_external_resynthesize() async {
     provider.newFile(testFile, r'''
 class Test {}
 ''');
 
     // Prepare the store with package:test/test.dart URI.
     SummaryDataStore summaryStore =
-        createAnalysisDriver().test.getSummaryStore(testFile);
+        await createAnalysisDriver().test.getSummaryStore(testFile);
 
     // package:test/test.dart is in the store.
     String uri = 'package:test/test.dart';
     expect(summaryStore.unlinkedMap.keys, contains(uri));
     expect(summaryStore.linkedMap.keys, contains(uri));
 
     // Remove the file from the file system.
     provider.deleteFile(testFile);
 
     // We can resynthesize the library from the store without reading the file.
     AnalysisDriver driver =
         createAnalysisDriver(externalSummaries: summaryStore);
     expect(driver.test.numOfCreatedLibraryContexts, 0);
     LibraryElement library = await driver.getLibraryByUri(uri);
     expect(library.getType('Test'), isNotNull);
   }
 
   test_getLibraryByUri_sdk_analyze() async {
     LibraryElement coreLibrary = await driver.getLibraryByUri('dart:core');
     expect(coreLibrary, isNotNull);
     expect(coreLibrary.getType('Object'), isNotNull);
     expect(coreLibrary.getType('int'), isNotNull);
   }
 
   test_getLibraryByUri_sdk_resynthesize() async {
     SummaryDataStore sdkStore;
     {
       String corePath = sdk.mapDartUri('dart:core').fullName;
-      sdkStore = createAnalysisDriver().test.getSummaryStore(corePath);
+      sdkStore = await createAnalysisDriver().test.getSummaryStore(corePath);
     }
 
     // There are dart:core and dart:async in the store.
     expect(sdkStore.unlinkedMap.keys, contains('dart:core'));
     expect(sdkStore.unlinkedMap.keys, contains('dart:async'));
     expect(sdkStore.linkedMap.keys, contains('dart:core'));
     expect(sdkStore.linkedMap.keys, contains('dart:async'));
 
     // We don't create new library context (so, don't parse, summarize and
     // link) for dart:core. The library is resynthesized from the provided
@@ skipping 1543 matching lines @@
     var path = _p('/test.dart');
     expect(() {
       driver.removeFile(path);
     }, throwsStateError);
   }
 
   String _p(String path) => provider.convertPath(path);
 }
 
 class _SourceMock extends Mock implements Source {}