TypeProvider is only available after a resolution.

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 332 matching lines @@
   bool get enableNewAnalysisDriver => false;
 
   /**
    * 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 {
     if (enableNewAnalysisDriver) {
-      return driver.sourceFactory.dartSdk.context.typeProvider;
+      return analysisResults.values.first.unit.element.context.typeProvider;
     } else {
       return analysisContext2.typeProvider;
     }
   }
 
   /**
    * Return a type system that can be used to test the results of resolution.
    *
    * @return a type system
    */
@@ skipping 101 matching lines @@
     Source source = addSource(code);
     await computeAnalysisResult(source);
     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 {
-    SimpleIdentifier identifier = await findMarkedIdentifier(code, "v = ");
+  void assertPropagatedAssignedType(String code, CompilationUnit unit,
+      DartType expectedStaticType, DartType expectedPropagatedType) {
+    SimpleIdentifier identifier = findMarkedIdentifier(code, unit, "v = ");
     expect(identifier.staticType, expectedStaticType);
     expect(identifier.propagatedType, expectedPropagatedType);
   }
 
   /**
    * @param code the code that iterates using variable "v". We check that
    *          "v" has expected static and propagated type.
    */
-  Future<Null> assertPropagatedIterationType(String code,
-      DartType expectedStaticType, DartType expectedPropagatedType) async {
-    SimpleIdentifier identifier = await findMarkedIdentifier(code, "v in ");
+  void assertPropagatedIterationType(String code, CompilationUnit unit,
+      DartType expectedStaticType, DartType expectedPropagatedType) {
+    SimpleIdentifier identifier = findMarkedIdentifier(code, unit, "v in ");
     expect(identifier.staticType, expectedStaticType);
     expect(identifier.propagatedType, expectedPropagatedType);
   }
 
   /**
    * Check the static and propagated types of the expression marked with "; // marker" comment.
    *
    * @param code source code to analyze, with the expression to check marked with "// marker".
    * @param expectedStaticType if non-null, check actual static type is equal to this.
    * @param expectedPropagatedType if non-null, check actual static type is equal to this.
    * @throws Exception
    */
-  Future<Null> assertTypeOfMarkedExpression(String code,
-      DartType expectedStaticType, DartType expectedPropagatedType) async {
+  void assertTypeOfMarkedExpression(String code, CompilationUnit unit,
+      DartType expectedStaticType, DartType expectedPropagatedType) {
     SimpleIdentifier identifier =
-        await findMarkedIdentifier(code, "; // marker");
+        findMarkedIdentifier(code, unit, "; // marker");
     if (expectedStaticType != null) {
       expect(identifier.staticType, expectedStaticType);
     }
     expect(identifier.propagatedType, expectedPropagatedType);
   }
 
   /**
    * Change the contents of the given [source] to the given [contents].
    */
   void changeSource(Source source, String contents) {
@@ skipping 17 matching lines @@
             analysisContext.resolveCompilationUnit2(source, libraries.first);
         List<AnalysisError> errors = analysisContext.computeErrors(source);
         analysisResult = new TestAnalysisResult(source, unit, errors);
       }
     }
     analysisResults[source] = analysisResult;
     return analysisResult;
   }
 
   /**
+   * Compute the analysis result to the given [code] in '/test.dart'.
+   */
+  Future<TestAnalysisResult> computeTestAnalysisResult(String code) async {
+    Source source = addSource(code);
+    return await computeAnalysisResult(source);
+  }
+
+  /**
    * 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");
 
   /**
    * Create a source object representing a file with the given [fileName] and
@@ skipping 41 matching lines @@
     compilationUnit.librarySource =
         compilationUnit.source = definingCompilationUnitSource;
     LibraryElementImpl library = new LibraryElementImpl.forNode(
         context, AstTestFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = compilationUnit;
     library.parts = sourcedCompilationUnits;
     return library;
   }
 
   /**
-   * Return the `SimpleIdentifier` marked by `marker`. The source code must have no
-   * errors and be verifiable.
-   *
-   * @param code source code to analyze.
-   * @param marker marker identifying sought after expression in source code.
-   * @return expression marked by the marker.
-   * @throws Exception
+   * Return the [SimpleIdentifier] from [unit] marked by [marker] in [code].
+   * The source code must have no errors and be verifiable.
    */
-  Future<SimpleIdentifier> findMarkedIdentifier(
-      String code, String marker) async {
-    try {
-      Source source = addSource(code);
-      await computeAnalysisResult(source);
-      assertNoErrors(source);
-      verify([source]);
-      CompilationUnit unit = analysisResults[source].unit;
-      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
-      // "fail_*" tests. However, an assertion failure is success for the
-      // purpose of "fail_*" tests, so without catching them here "fail_*" tests
-      // can succeed by failing for the wrong reason.
-      throw new StateError("Unexpected assertion failure: $exception");
-    }
+  SimpleIdentifier findMarkedIdentifier(
+      String code, CompilationUnit unit, String marker) {
+    return EngineTestCase.findNode(
+        unit, code, marker, (node) => node is SimpleIdentifier);
   }
 
   Expression findTopLevelConstantExpression(
           CompilationUnit compilationUnit, String name) =>
       findTopLevelDeclaration(compilationUnit, name).initializer;
   VariableDeclaration findTopLevelDeclaration(
       CompilationUnit compilationUnit, String name) {
     for (CompilationUnitMember member in compilationUnit.declarations) {
       if (member is TopLevelVariableDeclaration) {
         for (VariableDeclaration variable in member.variables.variables) {
@@ skipping 297 matching lines @@
     }
   }
 }
 
 class TestAnalysisResult {
   final Source source;
   final CompilationUnit unit;
   final List<AnalysisError> errors;
   TestAnalysisResult(this.source, this.unit, this.errors);
 }