Explicitly compute analysis results for sources to check errors.

pkg/analyzer/test/generated/resolver_test_case.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.generated.resolver_test_case;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 307 matching lines @@
    * Specifies if [assertErrors] should check for [HintCode.UNUSED_ELEMENT] and
    * [HintCode.UNUSED_FIELD].
    */
   bool enableUnusedElement = false;
 
   /**
    * Specifies if [assertErrors] should check for [HintCode.UNUSED_LOCAL_VARIABLE].
    */
   bool enableUnusedLocalVariable = false;
 
+  final Map<Source, TestAnalysisResult> analysisResults = {};
+
   AnalysisContext get analysisContext => analysisContext2;
 
   /**
    * Return a type provider that can be used to test the results of resolution.
    *
    * @return a type provider
    * @throws AnalysisException if dart:core cannot be resolved
    */
   TypeProvider get typeProvider => analysisContext2.typeProvider;
 
@@ skipping 26 matching lines @@
   Source addSource(String contents) => addNamedSource("/test.dart", contents);
 
   /**
    * Assert that the number of errors reported against the given
    * [source] matches the number of errors that are given and that they have
    * the expected error codes. The order in which the errors were gathered is
    * ignored.
    */
   Future<Null> assertErrors(Source source,
       [List<ErrorCode> expectedErrorCodes = const <ErrorCode>[]]) async {
+    TestAnalysisResult result = analysisResults[source];
+    expect(result, isNotNull);
+
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    for (AnalysisError error in analysisContext2.computeErrors(source)) {
+    for (AnalysisError error in result.errors) {
       expect(error.source, source);
       ErrorCode errorCode = error.errorCode;
       if (!enableUnusedElement &&
           (errorCode == HintCode.UNUSED_ELEMENT ||
               errorCode == HintCode.UNUSED_FIELD)) {
         continue;
       }
       if (!enableUnusedLocalVariable &&
           (errorCode == HintCode.UNUSED_CATCH_CLAUSE ||
               errorCode == HintCode.UNUSED_CATCH_STACK ||
               errorCode == HintCode.UNUSED_LOCAL_VARIABLE)) {
         continue;
       }
       errorListener.onError(error);
     }
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   /**
    * Asserts that [code] verifies, but has errors with the given error codes.
    *
    * Like [assertErrors], but takes a string of source code.
    */
   // TODO(rnystrom): Use this in more tests that have the same structure.
   Future<Null> assertErrorsInCode(String code, List<ErrorCode> errors) async {
     Source source = addSource(code);
+    await computeAnalysisResult(source);
     await assertErrors(source, errors);
     verify([source]);
   }
 
   /**
    * Asserts that [code] has errors with the given error codes.
    *
    * Like [assertErrors], but takes a string of source code.
    */
   Future<Null> assertErrorsInUnverifiedCode(
       String code, List<ErrorCode> errors) async {
     Source source = addSource(code);
+    await computeAnalysisResult(source);
     await assertErrors(source, errors);
   }
 
   /**
    * Assert that no errors have been reported against the given source.
    *
    * @param source the source against which no errors should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if any errors have been reported
    */
   Future<Null> assertNoErrors(Source source) async {
     await assertErrors(source);
   }
 
   /**
    * Asserts that [code] has no errors or warnings.
    */
   // TODO(rnystrom): Use this in more tests that have the same structure.
   Future<Null> assertNoErrorsInCode(String code) async {
     Source source = addSource(code);
+    await computeAnalysisResult(source);
     await assertNoErrors(source);
     verify([source]);
   }
 
   /**
    * @param code the code that assigns the value to the variable "v", no matter how. We check that
    *          "v" has expected static and propagated type.
    */
   Future<Null> assertPropagatedAssignedType(String code,
       DartType expectedStaticType, DartType expectedPropagatedType) async {
@@ skipping 44 matching lines @@
   /**
    * Change the contents of the given [source] to the given [contents].
    */
   void changeSource(Source source, String contents) {
     analysisContext2.setContents(source, contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedSource(source);
     analysisContext2.applyChanges(changeSet);
   }
 
+  Future<Null> computeAnalysisResult(Source source) async {
+    analysisContext2.computeKindOf(source);
+    List<Source> libraries = analysisContext2.getLibrariesContaining(source);
+    if (libraries.length > 0) {
+      CompilationUnit unit =
+          analysisContext.resolveCompilationUnit2(source, libraries.first);
+      List<AnalysisError> errors = analysisContext.computeErrors(source);
+      analysisResults[source] = new TestAnalysisResult(source, unit, errors);
+    }
+  }
+
   /**
    * Create a library element that represents a library named `"test"` containing a single
    * empty compilation unit.
    *
    * @return the library element that was created
    */
   LibraryElementImpl createDefaultTestLibrary() =>
       createTestLibrary(AnalysisContextFactory.contextWithCore(), "test");
 
   /**
@@ skipping 55 matching lines @@
    * @param code source code to analyze.
    * @param marker marker identifying sought after expression in source code.
    * @return expression marked by the marker.
    * @throws Exception
    */
   Future<SimpleIdentifier> findMarkedIdentifier(
       String code, String marker) async {
     try {
       Source source = addSource(code);
       LibraryElement library = resolve2(source);
+      await computeAnalysisResult(source);
       await assertNoErrors(source);
       verify([source]);
       CompilationUnit unit = resolveCompilationUnit(source, library);
       // Could generalize this further by making [SimpleIdentifier.class] a
       // parameter.
       return EngineTestCase.findNode(
           unit, code, marker, (node) => node is SimpleIdentifier);
     } catch (exception) {
       // Is there a better exception to throw here? The point is that an
       // assertion failure here should be a failure, in both "test_*" and
@@ skipping 66 matching lines @@
 
   CompilationUnit resolveSource(String sourceText) =>
       resolveSource2("/test.dart", sourceText);
 
   CompilationUnit resolveSource2(String fileName, String sourceText) {
     Source source = addNamedSource(fileName, sourceText);
     LibraryElement library = analysisContext.computeLibraryElement(source);
     return analysisContext.resolveCompilationUnit(source, library);
   }
 
-  Source resolveSources(List<String> sourceTexts) {
+  Future<Source> resolveSources2(List<String> sourceTexts) async {
     for (int i = 0; i < sourceTexts.length; i++) {
-      CompilationUnit unit =
-          resolveSource2("/lib${i + 1}.dart", sourceTexts[i]);
+      Source source = addNamedSource('/lib${i + 1}.dart', sourceTexts[i]);
+      await computeAnalysisResult(source);
       // reference the source if this is the last source
       if (i + 1 == sourceTexts.length) {
-        return resolutionMap.elementDeclaredByCompilationUnit(unit).source;
+        return source;
       }
     }
     return null;
   }
 
   Future<Null> resolveWithAndWithoutExperimental(
       List<String> strSources,
       List<ErrorCode> codesWithoutExperimental,
       List<ErrorCode> codesWithExperimental) async {
     // Setup analysis context as non-experimental
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
 //    options.enableDeferredLoading = false;
     resetWithOptions(options);
     // Analysis and assertions
-    Source source = resolveSources(strSources);
+    Source source = await resolveSources2(strSources);
+    await computeAnalysisResult(source);
     await assertErrors(source, codesWithoutExperimental);
     verify([source]);
     // Setup analysis context as experimental
     reset();
     // Analysis and assertions
-    source = resolveSources(strSources);
+    source = await resolveSources2(strSources);
+    await computeAnalysisResult(source);
     await assertErrors(source, codesWithExperimental);
     verify([source]);
   }
 
   Future<Null> resolveWithErrors(
       List<String> strSources, List<ErrorCode> codes) async {
-    // Analysis and assertions
-    Source source = resolveSources(strSources);
+    Source source = await resolveSources2(strSources);
     await assertErrors(source, codes);
     verify([source]);
   }
 
   @override
   void setUp() {
     ElementFactory.flushStaticState();
     super.setUp();
     reset();
   }
 
   @override
   void tearDown() {
     analysisContext2 = null;
     super.tearDown();
   }
 
   /**
    * Verify that all of the identifiers in the compilation units associated with
    * the given [sources] have been resolved.
    */
   void verify(List<Source> sources) {
     ResolutionVerifier verifier = new ResolutionVerifier();
     for (Source source in sources) {
-      List<Source> libraries = analysisContext2.getLibrariesContaining(source);
-      for (Source library in libraries) {
-        analysisContext2
-            .resolveCompilationUnit2(source, library)
-            .accept(verifier);
-      }
+      TestAnalysisResult result = analysisResults[source];
+      expect(result, isNotNull);
+      result.unit.accept(verifier);
     }
     verifier.assertResolved();
   }
 }
 
 /**
  * Shared infrastructure for [StaticTypeAnalyzer2Test] and
  * [StrongModeStaticTypeAnalyzer2Test].
  */
 class StaticTypeAnalyzer2TestShared extends ResolverTestCase {
@@ skipping 79 matching lines @@
   SimpleIdentifier findIdentifier(String search) {
     SimpleIdentifier identifier = EngineTestCase.findNode(
         testUnit, testCode, search, (node) => node is SimpleIdentifier);
     return identifier;
   }
 
   Future<Null> resolveTestUnit(String code) async {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
+    await computeAnalysisResult(testSource);
     await assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 
   /**
    * Validates that [type] matches [expected].
    *
    * If [expected] is a string, validates that the type stringifies to that
    * text. Otherwise, [expected] is used directly a [Matcher] to match the type.
    */
   _expectType(DartType type, expected) {
     if (expected is String) {
       expect(type.toString(), expected);
     } else {
       expect(type, expected);
     }
   }
 }
+
+class TestAnalysisResult {
+  final Source source;
+  final CompilationUnit unit;
+  final List<AnalysisError> errors;
+  TestAnalysisResult(this.source, this.unit, this.errors);
+}