TypeProvider is only available after a resolution.

pkg/analyzer/test/generated/strong_mode_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.generated.strong_mode_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 39 matching lines @@
   AsserterBuilder<Asserter<DartType>, InterfaceType> _isListOf;
   AsserterBuilder2<Asserter<DartType>, Asserter<DartType>, InterfaceType>
       _isMapOf;
   AsserterBuilder<List<Asserter<DartType>>, InterfaceType> _isStreamOf;
   AsserterBuilder<DartType, DartType> _isType;
 
   AsserterBuilder<Element, DartType> _hasElement;
   AsserterBuilder<DartType, DartType> _hasElementOf;
 
   @override
-  void setUp() {
-    super.setUp();
-    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    options.strongMode = true;
-    resetWith(options: options);
+  Future<TestAnalysisResult> computeAnalysisResult(Source source) async {

[Brian Wilkerson, 2017/01/23 20:50:34]

I assume that none of the initializations that were moved into this method will
cause a problem if this method is invoked more than once per test.

[scheglov, 2017/01/23 21:26:33]

They are not, but it is still wasteful.
I changed it to create assertions only once per test.
Thanks.

+    TestAnalysisResult result = await super.computeAnalysisResult(source);
     _assertions = new TypeAssertions(typeProvider);
     _isType = _assertions.isType;
     _hasElement = _assertions.hasElement;
     _isInstantiationOf = _assertions.isInstantiationOf;
     _isInt = _assertions.isInt;
     _isNum = _assertions.isNum;
     _isString = _assertions.isString;
     _isDynamic = _assertions.isDynamic;
     _isListOf = _assertions.isListOf;
     _isMapOf = _assertions.isMapOf;
     _isFunction2Of = _assertions.isFunction2Of;
     _hasElementOf = _assertions.hasElementOf;
     _isFutureOf = _isInstantiationOf(_hasElementOf(typeProvider.futureType));
     _isFutureOfDynamic = _isFutureOf([_isDynamic]);
     _isFutureOfInt = _isFutureOf([_isInt]);
     _isStreamOf = _isInstantiationOf(_hasElementOf(typeProvider.streamType));
+    return result;
+  }
+
+  @override
+  void setUp() {
+    super.setUp();
+    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
+    options.strongMode = true;
+    resetWith(options: options);
   }
 
   test_async_method_propagation() async {
     String code = r'''
       import "dart:async";
       class A {
         Future f0() => new Future.value(3);
         Future f1() async => new Future.value(3);
         Future f2() async => await new Future.value(3);
 
@@ skipping 2255 matching lines @@
   }
 
   test_foreachInference_dynamic_disabled() async {
     String code = r'''
 main() {
   var list = <int>[];
   for (dynamic v in list) {
     v; // marker
   }
 }''';
-    await assertPropagatedIterationType(code, typeProvider.dynamicType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedIterationType(code, unit, typeProvider.dynamicType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.dynamicType, null);
   }
 
   test_foreachInference_reusedVar_disabled() async {
     String code = r'''
 main() {
   var list = <int>[];
   var v;
   for (v in list) {
     v; // marker
   }
 }''';
-    await assertPropagatedIterationType(code, typeProvider.dynamicType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedIterationType(code, unit, typeProvider.dynamicType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.dynamicType, null);
   }
 
   test_foreachInference_var() async {
     String code = r'''
 main() {
   var list = <int>[];
   for (var v in list) {
     v; // marker
   }
 }''';
-    await assertPropagatedIterationType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedIterationType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_foreachInference_var_iterable() async {
     String code = r'''
 main() {
   Iterable<int> list = <int>[];
   for (var v in list) {
     v; // marker
   }
 }''';
-    await assertPropagatedIterationType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedIterationType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_foreachInference_var_stream() async {
     String code = r'''
 import 'dart:async';
 main() async {
   Stream<int> stream = null;
   await for (var v in stream) {
     v; // marker
   }
 }''';
-    await assertPropagatedIterationType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedIterationType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_bottom_disabled() async {
     String code = r'''
 main() {
   var v = null;
   v; // marker
 }''';
-    await assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.dynamicType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.dynamicType, null);
   }
 
   test_localVariableInference_constant() async {
     String code = r'''
 main() {
   var v = 3;
   v; // marker
 }''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_declaredType_disabled() async {
     String code = r'''
 main() {
   dynamic v = 3;
   v; // marker
 }''';
-    await assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.dynamicType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.dynamicType, null);
   }
 
   test_localVariableInference_noInitializer_disabled() async {
     String code = r'''
 main() {
   var v;
   v = 3;
   v; // marker
 }''';
-    await assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.dynamicType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.dynamicType, null);
   }
 
   test_localVariableInference_transitive_field_inferred_lexical() async {
     String code = r'''
 class A {
   final x = 3;
   f() {
     var v = x;
     return v; // marker
   }
 }
 main() {
 }
 ''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_field_inferred_reversed() async {
     String code = r'''
 class A {
   f() {
     var v = x;
     return v; // marker
   }
   final x = 3;
 }
 main() {
 }
 ''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_field_lexical() async {
     String code = r'''
 class A {
   int x = 3;
   f() {
     var v = x;
     return v; // marker
   }
 }
 main() {
 }
 ''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_field_reversed() async {
     String code = r'''
 class A {
   f() {
     var v = x;
     return v; // marker
   }
   int x = 3;
 }
 main() {
 }
 ''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_list_local() async {
     String code = r'''
 main() {
   var x = <int>[3];
   var v = x[0];
   v; // marker
 }''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_local() async {
     String code = r'''
 main() {
   var x = 3;
   var v = x;
   v; // marker
 }''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_toplevel_inferred_lexical() async {
     String code = r'''
 final x = 3;
 main() {
   var v = x;
   v; // marker
 }
 ''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_toplevel_inferred_reversed() async {
     String code = r'''
 main() {
   var v = x;
   v; // marker
 }
 final x = 3;
 ''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_toplevel_lexical() async {
     String code = r'''
 int x = 3;
 main() {
   var v = x;
   v; // marker
 }
 ''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 
   test_localVariableInference_transitive_toplevel_reversed() async {
     String code = r'''
 main() {
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
-    await assertPropagatedAssignedType(code, typeProvider.intType, null);
-    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    CompilationUnit unit = await resolveSource(code);
+    assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
+    assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 }