Make error producing tests ansynchronous.

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';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ skipping 54 matching lines @@
     _isListOf = _assertions.isListOf;
     _isMapOf = _assertions.isMapOf;
     _isFunction2Of = _assertions.isFunction2Of;
     _sameElement = _assertions.sameElement;
     _isFutureOf = _isInstantiationOf(_sameElement(typeProvider.futureType));
     _isFutureOfDynamic = _isFutureOf([_isDynamic]);
     _isFutureOfInt = _isFutureOf([_isInt]);
     _isStreamOf = _isInstantiationOf(_sameElement(typeProvider.streamType));
   }
 
-  void test_async_method_propagation() {
+  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);
 
         Future<int> f3() => new Future.value(3);
         Future<int> f4() async => new Future.value(3);
         Future<int> f5() async => await new Future.value(3);
@@ skipping 36 matching lines @@
 
     check("g0", _isFutureOfDynamic);
     check("g1", _isFutureOfDynamic);
     check("g2", _isFutureOfDynamic);
 
     check("g3", _isFutureOfInt);
     check("g4", _isFutureOfInt);
     check("g5", _isFutureOfInt);
   }
 
-  void test_async_propagation() {
+  test_async_propagation() async {
     String code = r'''
       import "dart:async";
 
       Future f0() => new Future.value(3);
       Future f1() async => new Future.value(3);
       Future f2() async => await new Future.value(3);
 
       Future<int> f3() => new Future.value(3);
       Future<int> f4() async => new Future.value(3);
       Future<int> f5() async => await new Future.value(3);
@@ skipping 35 matching lines @@
 
     check("g0", _isFutureOfDynamic);
     check("g1", _isFutureOfDynamic);
     check("g2", _isFutureOfDynamic);
 
     check("g3", _isFutureOfInt);
     check("g4", _isFutureOfInt);
     check("g5", _isFutureOfInt);
   }
 
-  void test_async_star_method_propagation() {
+  test_async_star_method_propagation() async {
     String code = r'''
       import "dart:async";
       class A {
         Stream g0() async* { yield []; }
         Stream g1() async* { yield* new Stream(); }
 
         Stream<List<int>> g2() async* { yield []; }
         Stream<List<int>> g3() async* { yield* new Stream(); }
       }
     ''';
     CompilationUnit unit = resolveSource(code);
 
     void check(String name, Asserter<InterfaceType> typeTest) {
       MethodDeclaration test = AstFinder.getMethodInClass(unit, "A", name);
       BlockFunctionBody body = test.body;
       YieldStatement stmt = body.block.statements[0];
       Expression exp = stmt.expression;
       typeTest(exp.staticType);
     }
 
     check("g0", _isListOf(_isDynamic));
     check("g1", _isStreamOf([_isDynamic]));
 
     check("g2", _isListOf(_isInt));
     check("g3", _isStreamOf([(DartType type) => _isListOf(_isInt)(type)]));
   }
 
-  void test_async_star_propagation() {
+  test_async_star_propagation() async {
     String code = r'''
       import "dart:async";
 
       Stream g0() async* { yield []; }
       Stream g1() async* { yield* new Stream(); }
 
       Stream<List<int>> g2() async* { yield []; }
       Stream<List<int>> g3() async* { yield* new Stream(); }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     void check(String name, Asserter<InterfaceType> typeTest) {
       FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, name);
       BlockFunctionBody body = test.functionExpression.body;
       YieldStatement stmt = body.block.statements[0];
       Expression exp = stmt.expression;
       typeTest(exp.staticType);
     }
 
     check("g0", _isListOf(_isDynamic));
     check("g1", _isStreamOf([_isDynamic]));
 
     check("g2", _isListOf(_isInt));
     check("g3", _isStreamOf([(DartType type) => _isListOf(_isInt)(type)]));
   }
 
-  void test_cascadeExpression() {
+  test_cascadeExpression() async {
     String code = r'''
       class A<T> {
         List<T> map(T a, List<T> mapper(T x)) => mapper(a);
       }
 
       void main () {
         A<int> a = new A()..map(0, (x) => [x]);
      }
    ''';
     CompilationUnit unit = resolveSource(code);
@@ skipping 10 matching lines @@
 
     CascadeExpression cascade = fetch(0);
     _isInstantiationOf(_hasElement(elementA))([_isInt])(cascade.staticType);
     MethodInvocation invoke = cascade.cascadeSections[0];
     FunctionExpression function = invoke.argumentList.arguments[1];
     ExecutableElement f0 = function.element;
     _isListOf(_isInt)(f0.type.returnType);
     expect(f0.type.normalParameterTypes[0], typeProvider.intType);
   }
 
-  void test_constructorInitializer_propagation() {
+  test_constructorInitializer_propagation() async {
     String code = r'''
       class A {
         List<String> x;
         A() : this.x = [];
       }
    ''';
     CompilationUnit unit = resolveSource(code);
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     ConstructorFieldInitializer assignment = constructor.initializers[0];
     Expression exp = assignment.expression;
     _isListOf(_isString)(exp.staticType);
   }
 
-  void test_factoryConstructor_propagation() {
+  test_factoryConstructor_propagation() async {
     String code = r'''
       class A<T> {
         factory A() { return new B(); }
       }
       class B<S> extends A<S> {}
    ''';
     CompilationUnit unit = resolveSource(code);
 
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     BlockFunctionBody body = constructor.body;
     ReturnStatement stmt = body.block.statements[0];
     InstanceCreationExpression exp = stmt.expression;
     ClassElement elementB = AstFinder.getClass(unit, "B").element;
     ClassElement elementA = AstFinder.getClass(unit, "A").element;
     expect(resolutionMap.typeForTypeName(exp.constructorName.type).element,
         elementB);
     _isInstantiationOf(_hasElement(elementB))(
         [_isType(elementA.typeParameters[0].type)])(exp.staticType);
   }
 
-  void test_fieldDeclaration_propagation() {
+  test_fieldDeclaration_propagation() async {
     String code = r'''
       class A {
         List<String> f0 = ["hello"];
       }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     VariableDeclaration field = AstFinder.getFieldInClass(unit, "A", "f0");
 
     _isListOf(_isString)(field.initializer.staticType);
   }
 
-  void test_functionDeclaration_body_propagation() {
+  test_functionDeclaration_body_propagation() async {
     String code = r'''
       typedef T Function2<S, T>(S x);
 
       List<int> test1() => [];
 
       Function2<int, int> test2 (int x) {
         Function2<String, int> inner() {
           return (x) => x.length;
         }
         return (x) => x;
@@ skipping 19 matching lines @@
     expect(type0.returnType, typeProvider.intType);
     expect(type0.normalParameterTypes[0], typeProvider.stringType);
 
     FunctionExpression anon1 = (statements[1] as ReturnStatement).expression;
     FunctionType type1 =
         resolutionMap.elementDeclaredByFunctionExpression(anon1).type;
     expect(type1.returnType, typeProvider.intType);
     expect(type1.normalParameterTypes[0], typeProvider.intType);
   }
 
-  void test_functionLiteral_assignment_typedArguments() {
+  test_functionLiteral_assignment_typedArguments() async {
     String code = r'''
       typedef T Function2<S, T>(S x);
 
       void main () {
         Function2<int, String> l0 = (int x) => null;
         Function2<int, String> l1 = (int x) => "hello";
         Function2<int, String> l2 = (String x) => "hello";
         Function2<int, String> l3 = (int x) => 3;
         Function2<int, String> l4 = (int x) {return 3;};
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
-  void test_functionLiteral_assignment_unTypedArguments() {
+  test_functionLiteral_assignment_unTypedArguments() async {
     String code = r'''
       typedef T Function2<S, T>(S x);
 
       void main () {
         Function2<int, String> l0 = (x) => null;
         Function2<int, String> l1 = (x) => "hello";
         Function2<int, String> l2 = (x) => "hello";
         Function2<int, String> l3 = (x) => 3;
         Function2<int, String> l4 = (x) {return 3;};
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
-  void test_functionLiteral_body_propagation() {
+  test_functionLiteral_body_propagation() async {
     String code = r'''
       typedef T Function2<S, T>(S x);
 
       void main () {
         Function2<int, List<String>> l0 = (int x) => ["hello"];
         Function2<int, List<String>> l1 = (String x) => ["hello"];
         Function2<int, List<String>> l2 = (int x) => [3];
         Function2<int, List<String>> l3 = (int x) {return [3];};
      }
    ''';
@@ skipping 13 matching lines @@
       }
     }
 
     Asserter<InterfaceType> assertListOfString = _isListOf(_isString);
     assertListOfString(functionReturnValue(0).staticType);
     assertListOfString(functionReturnValue(1).staticType);
     assertListOfString(functionReturnValue(2).staticType);
     assertListOfString(functionReturnValue(3).staticType);
   }
 
-  void test_functionLiteral_functionExpressionInvocation_typedArguments() {
+  test_functionLiteral_functionExpressionInvocation_typedArguments() async {
     String code = r'''
       class Mapper<F, T> {
         T map(T mapper(F x)) => mapper(null);
       }
 
       void main () {
         (new Mapper<int, String>().map)((int x) => null);
         (new Mapper<int, String>().map)((int x) => "hello");
         (new Mapper<int, String>().map)((String x) => "hello");
         (new Mapper<int, String>().map)((int x) => 3);
@@ skipping 10 matching lines @@
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
-  void test_functionLiteral_functionExpressionInvocation_unTypedArguments() {
+  test_functionLiteral_functionExpressionInvocation_unTypedArguments() async {
     String code = r'''
       class Mapper<F, T> {
         T map(T mapper(F x)) => mapper(null);
       }
 
       void main () {
         (new Mapper<int, String>().map)((x) => null);
         (new Mapper<int, String>().map)((x) => "hello");
         (new Mapper<int, String>().map)((x) => "hello");
         (new Mapper<int, String>().map)((x) => 3);
@@ skipping 10 matching lines @@
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
-  void test_functionLiteral_functionInvocation_typedArguments() {
+  test_functionLiteral_functionInvocation_typedArguments() async {
     String code = r'''
       String map(String mapper(int x)) => mapper(null);
 
       void main () {
         map((int x) => null);
         map((int x) => "hello");
         map((String x) => "hello");
         map((int x) => 3);
         map((int x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
-  void test_functionLiteral_functionInvocation_unTypedArguments() {
+  test_functionLiteral_functionInvocation_unTypedArguments() async {
     String code = r'''
       String map(String mapper(int x)) => mapper(null);
 
       void main () {
         map((x) => null);
         map((x) => "hello");
         map((x) => "hello");
         map((x) => 3);
         map((x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
-  void test_functionLiteral_methodInvocation_typedArguments() {
+  test_functionLiteral_methodInvocation_typedArguments() async {
     String code = r'''
       class Mapper<F, T> {
         T map(T mapper(F x)) => mapper(null);
       }
 
       void main () {
         new Mapper<int, String>().map((int x) => null);
         new Mapper<int, String>().map((int x) => "hello");
         new Mapper<int, String>().map((String x) => "hello");
         new Mapper<int, String>().map((int x) => 3);
@@ skipping 10 matching lines @@
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
-  void test_functionLiteral_methodInvocation_unTypedArguments() {
+  test_functionLiteral_methodInvocation_unTypedArguments() async {
     String code = r'''
       class Mapper<F, T> {
         T map(T mapper(F x)) => mapper(null);
       }
 
       void main () {
         new Mapper<int, String>().map((x) => null);
         new Mapper<int, String>().map((x) => "hello");
         new Mapper<int, String>().map((x) => "hello");
         new Mapper<int, String>().map((x) => 3);
@@ skipping 10 matching lines @@
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
-  void test_functionLiteral_unTypedArgument_propagation() {
+  test_functionLiteral_unTypedArgument_propagation() async {
     String code = r'''
       typedef T Function2<S, T>(S x);
 
       void main () {
         Function2<int, int> l0 = (x) => x;
         Function2<int, int> l1 = (x) => x+1;
         Function2<int, String> l2 = (x) => x;
         Function2<int, String> l3 = (x) => x.toLowerCase();
         Function2<String, String> l4 = (x) => x.toLowerCase();
      }
@@ skipping 14 matching lines @@
       }
     }
 
     expect(functionReturnValue(0).staticType, typeProvider.intType);
     expect(functionReturnValue(1).staticType, typeProvider.intType);
     expect(functionReturnValue(2).staticType, typeProvider.intType);
     expect(functionReturnValue(3).staticType, typeProvider.dynamicType);
     expect(functionReturnValue(4).staticType, typeProvider.stringType);
   }
 
-  void test_inference_hints() {
+  test_inference_hints() async {
     Source source = addSource(r'''
       void main () {
         var x = 3;
         List<int> l0 = [];
      }
    ''');
     resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
   }
 
-  void test_inferredFieldDeclaration_propagation() {
+  test_inferredFieldDeclaration_propagation() async {
     // Regression test for https://github.com/dart-lang/sdk/issues/25546
     String code = r'''
       abstract class A {
         Map<int, List<int>> get map;
       }
       class B extends A {
         var map = { 42: [] };
       }
       class C extends A {
         get map => { 43: [] };
@@ skipping 16 matching lines @@
     MapLiteral mapLiteralC = (mapC.body as ExpressionFunctionBody).expression;
     assertMapOfIntToListOfInt(mapLiteralB.staticType);
     assertMapOfIntToListOfInt(mapLiteralC.staticType);
 
     ListLiteral listLiteralB = mapLiteralB.entries[0].value;
     ListLiteral listLiteralC = mapLiteralC.entries[0].value;
     assertListOfInt(listLiteralB.staticType);
     assertListOfInt(listLiteralC.staticType);
   }
 
-  void test_instanceCreation() {
+  test_instanceCreation() async {
     String code = r'''
       class A<S, T> {
         S x;
         T y;
         A(this.x, this.y);
         A.named(this.x, this.y);
       }
 
       class B<S, T> extends A<T, S> {
         B(S y, T x) : super(x, y);
@@ skipping 198 matching lines @@
           AstFinder.getStatementsInTopLevelFunction(unit, "test9");
       hasType(assertFOf([_isInt, _isString]), rhs(statements[0]));
       hasType(assertFOf([_isInt, _isString]), rhs(statements[1]));
       hasType(assertFOf([_isInt, _isString]), rhs(statements[2]));
       hasType(assertFOf([_isInt, _isString]), rhs(statements[3]));
       hasType(assertFOf([_isInt, _isString]), rhs(statements[4]));
       hasType(assertFOf([_isInt, _isString]), rhs(statements[5]));
     }
   }
 
-  void test_listLiteral_nested() {
+  test_listLiteral_nested() async {
     String code = r'''
       void main () {
         List<List<int>> l0 = [[]];
         Iterable<List<int>> l1 = [[3]];
         Iterable<List<int>> l2 = [[3], [4]];
         List<List<int>> l3 = [["hello", 3], []];
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
@@ skipping 12 matching lines @@
     assertListOfListOfInt(literal(0).staticType);
     assertListOfListOfInt(literal(1).staticType);
     assertListOfListOfInt(literal(2).staticType);
     assertListOfListOfInt(literal(3).staticType);
 
     assertListOfInt(literal(1).elements[0].staticType);
     assertListOfInt(literal(2).elements[0].staticType);
     assertListOfInt(literal(3).elements[0].staticType);
   }
 
-  void test_listLiteral_simple() {
+  test_listLiteral_simple() async {
     String code = r'''
       void main () {
         List<int> l0 = [];
         List<int> l1 = [3];
         List<int> l2 = ["hello"];
         List<int> l3 = ["hello", 3];
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       ListLiteral exp = decl.initializer;
       return exp.staticType;
     }
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
 
     assertListOfInt(literal(0));
     assertListOfInt(literal(1));
     assertListOfInt(literal(2));
     assertListOfInt(literal(3));
   }
 
-  void test_listLiteral_simple_const() {
+  test_listLiteral_simple_const() async {
     String code = r'''
       void main () {
         const List<int> c0 = const [];
         const List<int> c1 = const [3];
         const List<int> c2 = const ["hello"];
         const List<int> c3 = const ["hello", 3];
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       ListLiteral exp = decl.initializer;
       return exp.staticType;
     }
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
 
     assertListOfInt(literal(0));
     assertListOfInt(literal(1));
     assertListOfInt(literal(2));
     assertListOfInt(literal(3));
   }
 
-  void test_listLiteral_simple_disabled() {
+  test_listLiteral_simple_disabled() async {
     String code = r'''
       void main () {
         List<int> l0 = <num>[];
         List<int> l1 = <num>[3];
         List<int> l2 = <String>["hello"];
         List<int> l3 = <dynamic>["hello", 3];
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       ListLiteral exp = decl.initializer;
       return exp.staticType;
     }
 
     _isListOf(_isNum)(literal(0));
     _isListOf(_isNum)(literal(1));
     _isListOf(_isString)(literal(2));
     _isListOf(_isDynamic)(literal(3));
   }
 
-  void test_listLiteral_simple_subtype() {
+  test_listLiteral_simple_subtype() async {
     String code = r'''
       void main () {
         Iterable<int> l0 = [];
         Iterable<int> l1 = [3];
         Iterable<int> l2 = ["hello"];
         Iterable<int> l3 = ["hello", 3];
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       ListLiteral exp = decl.initializer;
       return exp.staticType;
     }
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
 
     assertListOfInt(literal(0));
     assertListOfInt(literal(1));
     assertListOfInt(literal(2));
     assertListOfInt(literal(3));
   }
 
-  void test_mapLiteral_nested() {
+  test_mapLiteral_nested() async {
     String code = r'''
       void main () {
         Map<int, List<String>> l0 = {};
         Map<int, List<String>> l1 = {3: ["hello"]};
         Map<int, List<String>> l2 = {"hello": ["hello"]};
         Map<int, List<String>> l3 = {3: [3]};
         Map<int, List<String>> l4 = {3:["hello"], "hello": [3]};
      }
    ''';
     CompilationUnit unit = resolveSource(code);
@@ skipping 15 matching lines @@
     assertMapOfIntToListOfString(literal(2).staticType);
     assertMapOfIntToListOfString(literal(3).staticType);
     assertMapOfIntToListOfString(literal(4).staticType);
 
     assertListOfString(literal(1).entries[0].value.staticType);
     assertListOfString(literal(2).entries[0].value.staticType);
     assertListOfString(literal(3).entries[0].value.staticType);
     assertListOfString(literal(4).entries[0].value.staticType);
   }
 
-  void test_mapLiteral_simple() {
+  test_mapLiteral_simple() async {
     String code = r'''
       void main () {
         Map<int, String> l0 = {};
         Map<int, String> l1 = {3: "hello"};
         Map<int, String> l2 = {"hello": "hello"};
         Map<int, String> l3 = {3: 3};
         Map<int, String> l4 = {3:"hello", "hello": 3};
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       MapLiteral exp = decl.initializer;
       return exp.staticType;
     }
 
     Asserter<InterfaceType> assertMapOfIntToString =
         _isMapOf(_isInt, _isString);
 
     assertMapOfIntToString(literal(0));
     assertMapOfIntToString(literal(1));
     assertMapOfIntToString(literal(2));
     assertMapOfIntToString(literal(3));
   }
 
-  void test_mapLiteral_simple_disabled() {
+  test_mapLiteral_simple_disabled() async {
     String code = r'''
       void main () {
         Map<int, String> l0 = <int, dynamic>{};
         Map<int, String> l1 = <int, dynamic>{3: "hello"};
         Map<int, String> l2 = <int, dynamic>{"hello": "hello"};
         Map<int, String> l3 = <int, dynamic>{3: 3};
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       MapLiteral exp = decl.initializer;
       return exp.staticType;
     }
 
     Asserter<InterfaceType> assertMapOfIntToDynamic =
         _isMapOf(_isInt, _isDynamic);
 
     assertMapOfIntToDynamic(literal(0));
     assertMapOfIntToDynamic(literal(1));
     assertMapOfIntToDynamic(literal(2));
     assertMapOfIntToDynamic(literal(3));
   }
 
-  void test_methodDeclaration_body_propagation() {
+  test_methodDeclaration_body_propagation() async {
     String code = r'''
       class A {
         List<String> m0(int x) => ["hello"];
         List<String> m1(int x) {return [3];};
       }
    ''';
     CompilationUnit unit = resolveSource(code);
     Expression methodReturnValue(String methodName) {
       MethodDeclaration method =
           AstFinder.getMethodInClass(unit, "A", methodName);
       FunctionBody body = method.body;
       if (body is ExpressionFunctionBody) {
         return body.expression;
       } else {
         Statement stmt = (body as BlockFunctionBody).block.statements[0];
         return (stmt as ReturnStatement).expression;
       }
     }
 
     Asserter<InterfaceType> assertListOfString = _isListOf(_isString);
     assertListOfString(methodReturnValue("m0").staticType);
     assertListOfString(methodReturnValue("m1").staticType);
   }
 
-  void test_redirectingConstructor_propagation() {
+  test_redirectingConstructor_propagation() async {
     String code = r'''
       class A {
         A() : this.named([]);
         A.named(List<String> x);
       }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     RedirectingConstructorInvocation invocation = constructor.initializers[0];
     Expression exp = invocation.argumentList.arguments[0];
     _isListOf(_isString)(exp.staticType);
   }
 
-  void test_superConstructorInvocation_propagation() {
+  test_superConstructorInvocation_propagation() async {
     String code = r'''
       class B {
         B(List<String>);
       }
       class A extends B {
         A() : super([]);
       }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     SuperConstructorInvocation invocation = constructor.initializers[0];
     Expression exp = invocation.argumentList.arguments[0];
     _isListOf(_isString)(exp.staticType);
   }
 
-  void test_sync_star_method_propagation() {
+  test_sync_star_method_propagation() async {
     String code = r'''
       import "dart:async";
       class A {
         Iterable f0() sync* { yield []; }
         Iterable f1() sync* { yield* new List(); }
 
         Iterable<List<int>> f2() sync* { yield []; }
         Iterable<List<int>> f3() sync* { yield* new List(); }
       }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     void check(String name, Asserter<InterfaceType> typeTest) {
       MethodDeclaration test = AstFinder.getMethodInClass(unit, "A", name);
       BlockFunctionBody body = test.body;
       YieldStatement stmt = body.block.statements[0];
       Expression exp = stmt.expression;
       typeTest(exp.staticType);
     }
 
     check("f0", _isListOf(_isDynamic));
     check("f1", _isListOf(_isDynamic));
 
     check("f2", _isListOf(_isInt));
     check("f3", _isListOf((DartType type) => _isListOf(_isInt)(type)));
   }
 
-  void test_sync_star_propagation() {
+  test_sync_star_propagation() async {
     String code = r'''
       import "dart:async";
 
       Iterable f0() sync* { yield []; }
       Iterable f1() sync* { yield* new List(); }
 
       Iterable<List<int>> f2() sync* { yield []; }
       Iterable<List<int>> f3() sync* { yield* new List(); }
    ''';
     CompilationUnit unit = resolveSource(code);
@@ skipping 12 matching lines @@
     check("f2", _isListOf(_isInt));
     check("f3", _isListOf((DartType type) => _isListOf(_isInt)(type)));
   }
 }
 
 /**
  * Strong mode static analyzer end to end tests
  */
 @reflectiveTest
 class StrongModeStaticTypeAnalyzer2Test extends StaticTypeAnalyzer2TestShared {
-  void fail_genericMethod_tearoff_instantiated() {
-    resolveTestUnit(r'''
+  fail_genericMethod_tearoff_instantiated() async {
+    await resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(E e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
   static final h = g;
 }
 
 /*=T*/ topF/*<T>*/(/*=T*/ e) => null;
 var topG = topF;
 void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
   var c = new C<int>();
   /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
   var methodTearOffInst = c.f/*<int>*/;
   var staticTearOffInst = C.g/*<int>*/;
   var staticFieldTearOffInst = C.h/*<int>*/;
   var topFunTearOffInst = topF/*<int>*/;
   var topFieldTearOffInst = topG/*<int>*/;
   var localTearOffInst = lf/*<int>*/;
   var paramTearOffInst = pf/*<int>*/;
 }
 ''');
     expectIdentifierType('methodTearOffInst', "(int) → int");
     expectIdentifierType('staticTearOffInst', "(int) → int");
     expectIdentifierType('staticFieldTearOffInst', "(int) → int");
     expectIdentifierType('topFunTearOffInst', "(int) → int");
     expectIdentifierType('topFieldTearOffInst', "(int) → int");
     expectIdentifierType('localTearOffInst', "(int) → int");
     expectIdentifierType('paramTearOffInst', "(int) → int");
   }
 
-  void objectMethodOnFunctions_helper(String code) {
-    resolveTestUnit(code);
+  Future<Null> _objectMethodOnFunctions_helper2(String code) async {
+    await resolveTestUnit(code);
     expectIdentifierType('t0', "String");
     expectIdentifierType('t1', "() → String");
     expectIdentifierType('t2', "int");
     expectIdentifierType('t3', "String");
     expectIdentifierType('t4', "() → String");
     expectIdentifierType('t5', "int");
   }
 
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
   }
 
-  void test_dynamicObjectGetter_hashCode() {
+  test_dynamicObjectGetter_hashCode() async {
     String code = r'''
 main() {
   dynamic a = null;
   var foo = a.hashCode;
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'int', isNull);
   }
 
-  void test_dynamicObjectMethod_toString() {
+  test_dynamicObjectMethod_toString() async {
     String code = r'''
 main() {
   dynamic a = null;
   var foo = a.toString();
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'String', isNull);
   }
 
-  void test_genericFunction() {
-    resolveTestUnit(r'/*=T*/ f/*<T>*/(/*=T*/ x) => null;');
+  test_genericFunction() async {
+    await resolveTestUnit(r'/*=T*/ f/*<T>*/(/*=T*/ x) => null;');
     expectFunctionType('f', '<T>(T) → T',
         elementTypeParams: '[T]', typeFormals: '[T]');
     SimpleIdentifier f = findIdentifier('f');
     FunctionElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
-  void test_genericFunction_bounds() {
-    resolveTestUnit(r'/*=T*/ f/*<T extends num>*/(/*=T*/ x) => null;');
+  test_genericFunction_bounds() async {
+    await resolveTestUnit(r'/*=T*/ f/*<T extends num>*/(/*=T*/ x) => null;');
     expectFunctionType('f', '<T extends num>(T) → T',
         elementTypeParams: '[T extends num]', typeFormals: '[T extends num]');
   }
 
-  void test_genericFunction_parameter() {
-    resolveTestUnit(r'''
+  test_genericFunction_parameter() async {
+    await resolveTestUnit(r'''
 void g(/*=T*/ f/*<T>*/(/*=T*/ x)) {}
 ''');
     expectFunctionType('f', '<T>(T) → T',
         elementTypeParams: '[T]', typeFormals: '[T]');
     SimpleIdentifier f = findIdentifier('f');
     ParameterElementImpl e = f.staticElement;
     FunctionType type = e.type;
     FunctionType ft = type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
-  void test_genericFunction_static() {
-    resolveTestUnit(r'''
+  test_genericFunction_static() async {
+    await resolveTestUnit(r'''
 class C<E> {
   static /*=T*/ f/*<T>*/(/*=T*/ x) => null;
 }
 ''');
     expectFunctionType('f', '<T>(T) → T',
         elementTypeParams: '[T]', typeFormals: '[T]');
     SimpleIdentifier f = findIdentifier('f');
     MethodElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
-  void test_genericFunction_typedef() {
+  test_genericFunction_typedef() async {
     String code = r'''
 typedef T F<T>(T x);
 F f0;
 
 class C {
   static F f1;
   F f2;
   void g(F f3) {
     F f4;
     f0(3);
@@ skipping 10 matching lines @@
   void g(F f3) {
     F f4;
     f0(3);
     f1(3);
     f2(3);
     f3(3);
     f4(3);
   }
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
 
     checkBody(String className) {
       List<Statement> statements =
           AstFinder.getStatementsInMethod(testUnit, className, "g");
 
       for (int i = 1; i <= 5; i++) {
         Expression exp = (statements[i] as ExpressionStatement).expression;
         expect(exp.staticType, typeProvider.dynamicType);
       }
     }
 
     checkBody("C");
     checkBody("D");
   }
 
-  void test_genericFunction_upwardsAndDownwards() {
+  test_genericFunction_upwardsAndDownwards() async {
     // Regression tests for https://github.com/dart-lang/sdk/issues/27151.
-    resolveTestUnit(r'List<num> x = [1, 2];');
+    await resolveTestUnit(r'List<num> x = [1, 2];');
     expectInitializerType('x', 'List<int>');
   }
 
-  void test_genericMethod() {
-    resolveTestUnit(r'''
+  test_genericMethod() async {
+    await resolveTestUnit(r'''
 class C<E> {
   List/*<T>*/ f/*<T>*/(E e) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     expectFunctionType('f', '<T>(E) → List<T>',
         elementTypeParams: '[T]',
         typeParams: '[E]',
         typeArgs: '[E]',
         typeFormals: '[T]');
     SimpleIdentifier c = findIdentifier('cOfString');
     FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
     expect(ft.toString(), '<T>(String) → List<T>');
     ft = ft.instantiate([typeProvider.intType]);
     expect(ft.toString(), '(String) → List<int>');
     expect('${ft.typeArguments}/${ft.typeParameters}', '[String, int]/[E, T]');
   }
 
-  void test_genericMethod_explicitTypeParams() {
-    resolveTestUnit(r'''
+  test_genericMethod_explicitTypeParams() async {
+    await resolveTestUnit(r'''
 class C<E> {
   List/*<T>*/ f/*<T>*/(E e) => null;
 }
 main() {
   C<String> cOfString;
   var x = cOfString.f/*<int>*/('hi');
 }
 ''');
     MethodInvocation f = findIdentifier('f/*<int>*/').parent;
     FunctionType ft = f.staticInvokeType;
     expect(ft.toString(), '(String) → List<int>');
     expect('${ft.typeArguments}/${ft.typeParameters}', '[String, int]/[E, T]');
 
     SimpleIdentifier x = findIdentifier('x');
     expect(x.staticType,
         typeProvider.listType.instantiate([typeProvider.intType]));
   }
 
-  void test_genericMethod_functionExpressionInvocation_explicit() {
-    resolveTestUnit(r'''
+  test_genericMethod_functionExpressionInvocation_explicit() async {
+    await resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(/*=T*/ e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
   static final h = g;
 }
 
 /*=T*/ topF/*<T>*/(/*=T*/ e) => null;
 var topG = topF;
 void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
   var c = new C<int>();
@@ skipping 12 matching lines @@
     expectIdentifierType('methodCall', "int");
     expectIdentifierType('staticCall', "int");
     expectIdentifierType('staticFieldCall', "int");
     expectIdentifierType('topFunCall', "int");
     expectIdentifierType('topFieldCall', "int");
     expectIdentifierType('localCall', "int");
     expectIdentifierType('paramCall', "int");
     expectIdentifierType('lambdaCall', "int");
   }
 
-  void test_genericMethod_functionExpressionInvocation_inferred() {
-    resolveTestUnit(r'''
+  test_genericMethod_functionExpressionInvocation_inferred() async {
+    await resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(/*=T*/ e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
   static final h = g;
 }
 
 /*=T*/ topF/*<T>*/(/*=T*/ e) => null;
 var topG = topF;
 void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
   var c = new C<int>();
@@ skipping 12 matching lines @@
     expectIdentifierType('methodCall', "int");
     expectIdentifierType('staticCall', "int");
     expectIdentifierType('staticFieldCall', "int");
     expectIdentifierType('topFunCall', "int");
     expectIdentifierType('topFieldCall', "int");
     expectIdentifierType('localCall', "int");
     expectIdentifierType('paramCall', "int");
     expectIdentifierType('lambdaCall', "int");
   }
 
-  void test_genericMethod_functionInvocation_explicit() {
-    resolveTestUnit(r'''
+  test_genericMethod_functionInvocation_explicit() async {
+    await resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(/*=T*/ e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
   static final h = g;
 }
 
 /*=T*/ topF/*<T>*/(/*=T*/ e) => null;
 var topG = topF;
 void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
   var c = new C<int>();
   /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
   var methodCall = c.f/*<int>*/(3);
   var staticCall = C.g/*<int>*/(3);
   var staticFieldCall = C.h/*<int>*/(3);
   var topFunCall = topF/*<int>*/(3);
   var topFieldCall = topG/*<int>*/(3);
   var localCall = lf/*<int>*/(3);
   var paramCall = pf/*<int>*/(3);
 }
 ''');
     expectIdentifierType('methodCall', "int");
     expectIdentifierType('staticCall', "int");
     expectIdentifierType('staticFieldCall', "int");
     expectIdentifierType('topFunCall', "int");
     expectIdentifierType('topFieldCall', "int");
     expectIdentifierType('localCall', "int");
     expectIdentifierType('paramCall', "int");
   }
 
-  void test_genericMethod_functionInvocation_inferred() {
-    resolveTestUnit(r'''
+  test_genericMethod_functionInvocation_inferred() async {
+    await resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(/*=T*/ e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
   static final h = g;
 }
 
 /*=T*/ topF/*<T>*/(/*=T*/ e) => null;
 var topG = topF;
 void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
   var c = new C<int>();
   /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
   var methodCall = c.f(3);
   var staticCall = C.g(3);
   var staticFieldCall = C.h(3);
   var topFunCall = topF(3);
   var topFieldCall = topG(3);
   var localCall = lf(3);
   var paramCall = pf(3);
 }
 ''');
     expectIdentifierType('methodCall', "int");
     expectIdentifierType('staticCall', "int");
     expectIdentifierType('staticFieldCall', "int");
     expectIdentifierType('topFunCall', "int");
     expectIdentifierType('topFieldCall', "int");
     expectIdentifierType('localCall', "int");
     expectIdentifierType('paramCall', "int");
   }
 
-  void test_genericMethod_functionTypedParameter() {
-    resolveTestUnit(r'''
+  test_genericMethod_functionTypedParameter() async {
+    await resolveTestUnit(r'''
 class C<E> {
   List/*<T>*/ f/*<T>*/(/*=T*/ f(E e)) => null;
 }
 main() {
   C<String> cOfString;
 }
 ''');
     expectFunctionType('f', '<T>((E) → T) → List<T>',
         elementTypeParams: '[T]',
         typeParams: '[E]',
         typeArgs: '[E]',
         typeFormals: '[T]');
 
     SimpleIdentifier c = findIdentifier('cOfString');
     FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
     expect(ft.toString(), '<T>((String) → T) → List<T>');
     ft = ft.instantiate([typeProvider.intType]);
     expect(ft.toString(), '((String) → int) → List<int>');
   }
 
-  void test_genericMethod_implicitDynamic() {
+  test_genericMethod_implicitDynamic() async {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25100#issuecomment-162047588
     // These should not cause any hints or warnings.
-    resolveTestUnit(r'''
+    await resolveTestUnit(r'''
 class List<E> {
   /*=T*/ map/*<T>*/(/*=T*/ f(E e)) => null;
 }
 void foo() {
   List list = null;
   list.map((e) => e);
   list.map((e) => 3);
 }''');
     expectIdentifierType('map((e) => e);', '<T>((dynamic) → T) → T', isNull);
     expectIdentifierType('map((e) => 3);', '<T>((dynamic) → T) → T', isNull);
 
     MethodInvocation m1 = findIdentifier('map((e) => e);').parent;
     expect(m1.staticInvokeType.toString(), '((dynamic) → dynamic) → dynamic');
     MethodInvocation m2 = findIdentifier('map((e) => 3);').parent;
     expect(m2.staticInvokeType.toString(), '((dynamic) → int) → int');
   }
 
-  void test_genericMethod_max_doubleDouble() {
+  test_genericMethod_max_doubleDouble() async {
     String code = r'''
 import 'dart:math';
 main() {
   var foo = max(1.0, 2.0);
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'double', isNull);
   }
 
-  void test_genericMethod_max_doubleDouble_prefixed() {
+  test_genericMethod_max_doubleDouble_prefixed() async {
     String code = r'''
 import 'dart:math' as math;
 main() {
   var foo = math.max(1.0, 2.0);
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'double', isNull);
   }
 
-  void test_genericMethod_max_doubleInt() {
+  test_genericMethod_max_doubleInt() async {
     String code = r'''
 import 'dart:math';
 main() {
   var foo = max(1.0, 2);
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'num', isNull);
   }
 
-  void test_genericMethod_max_intDouble() {
+  test_genericMethod_max_intDouble() async {
     String code = r'''
 import 'dart:math';
 main() {
   var foo = max(1, 2.0);
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'num', isNull);
   }
 
-  void test_genericMethod_max_intInt() {
+  test_genericMethod_max_intInt() async {
     String code = r'''
 import 'dart:math';
 main() {
   var foo = max(1, 2);
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'int', isNull);
   }
 
-  void test_genericMethod_nestedBound() {
+  test_genericMethod_nestedBound() async {
     String code = r'''
 class Foo<T extends num> {
   void method/*<U extends T>*/(dynamic/*=U*/ u) {
     u.abs();
   }
 }
 ''';
     // Just validate that there is no warning on the call to `.abs()`.
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
   }
 
-  void test_genericMethod_nestedCapture() {
-    resolveTestUnit(r'''
+  test_genericMethod_nestedCapture() async {
+    await resolveTestUnit(r'''
 class C<T> {
   /*=T*/ f/*<S>*/(/*=S*/ x) {
     new C<S>().f/*<int>*/(3);
     new C<S>().f; // tear-off
     return null;
   }
 }
 ''');
     MethodInvocation f = findIdentifier('f/*<int>*/(3);').parent;
     expect(f.staticInvokeType.toString(), '(int) → S');
     FunctionType ft = f.staticInvokeType;
     expect('${ft.typeArguments}/${ft.typeParameters}', '[S, int]/[T, S]');
 
     expectIdentifierType('f;', '<S₀>(S₀) → S');
   }
 
-  void test_genericMethod_nestedFunctions() {
-    resolveTestUnit(r'''
+  test_genericMethod_nestedFunctions() async {
+    await resolveTestUnit(r'''
 /*=S*/ f/*<S>*/(/*=S*/ x) {
   g/*<S>*/(/*=S*/ x) => f;
   return null;
 }
 ''');
     expectIdentifierType('f', '<S>(S) → S');
     expectIdentifierType('g', '<S>(S) → <S>(S) → S');
   }
 
-  void test_genericMethod_override() {
-    resolveTestUnit(r'''
+  test_genericMethod_override() async {
+    await resolveTestUnit(r'''
 class C {
   /*=T*/ f/*<T>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=T*/ f/*<T>*/(/*=T*/ x) => null; // from D
 }
 ''');
     expectFunctionType('f/*<T>*/(/*=T*/ x) => null; // from D', '<T>(T) → T',
         elementTypeParams: '[T]', typeFormals: '[T]');
     SimpleIdentifier f =
         findIdentifier('f/*<T>*/(/*=T*/ x) => null; // from D');
     MethodElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), '(String) → String');
   }
 
-  void test_genericMethod_override_bounds() {
-    resolveTestUnit(r'''
+  test_genericMethod_override_bounds() async {
+    await resolveTestUnit(r'''
 class A {}
 class B extends A {}
 class C {
   /*=T*/ f/*<T extends B>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=T*/ f/*<T extends A>*/(/*=T*/ x) => null;
 }
 ''');
   }
 
-  void test_genericMethod_override_invalidReturnType() {
+  test_genericMethod_override_invalidReturnType() async {
     Source source = addSource(r'''
 class C {
   Iterable/*<T>*/ f/*<T>*/(/*=T*/ x) => null;
 }
 class D extends C {
   String f/*<S>*/(/*=S*/ x) => null;
 }''');
-    assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+    await assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
-  void test_genericMethod_override_invalidTypeParamBounds() {
+  test_genericMethod_override_invalidTypeParamBounds() async {
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 class C {
   /*=T*/ f/*<T extends A>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=T*/ f/*<T extends B>*/(/*=T*/ x) => null;
 }''');
-    assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+    await assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
-  void test_genericMethod_override_invalidTypeParamCount() {
+  test_genericMethod_override_invalidTypeParamCount() async {
     Source source = addSource(r'''
 class C {
   /*=T*/ f/*<T>*/(/*=T*/ x) => null;
 }
 class D extends C {
   /*=S*/ f/*<T, S>*/(/*=T*/ x) => null;
 }''');
-    assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
+    await assertErrors(source, [StrongModeCode.INVALID_METHOD_OVERRIDE]);
     verify([source]);
   }
 
-  void test_genericMethod_propagatedType_promotion() {
+  test_genericMethod_propagatedType_promotion() async {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25340
 
     // Note, after https://github.com/dart-lang/sdk/issues/25486 the original
     // example won't work, as we now compute a static type and therefore discard
     // the propagated type. So a new test was created that doesn't run under
     // strong mode.
-    resolveTestUnit(r'''
+    await resolveTestUnit(r'''
 abstract class Iter {
   List/*<S>*/ map/*<S>*/(/*=S*/ f(x));
 }
 class C {}
 C toSpan(dynamic element) {
   if (element is Iter) {
     var y = element.map(toSpan);
   }
   return null;
 }''');
     expectIdentifierType('y = ', 'List<C>', isNull);
   }
 
-  void test_genericMethod_tearoff() {
-    resolveTestUnit(r'''
+  test_genericMethod_tearoff() async {
+    await resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(E e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
   static final h = g;
 }
 
 /*=T*/ topF/*<T>*/(/*=T*/ e) => null;
 var topG = topF;
 void test/*<S>*/(/*=T*/ pf/*<T>*/(/*=T*/ e)) {
   var c = new C<int>();
   /*=T*/ lf/*<T>*/(/*=T*/ e) => null;
   var methodTearOff = c.f;
   var staticTearOff = C.g;
   var staticFieldTearOff = C.h;
   var topFunTearOff = topF;
   var topFieldTearOff = topG;
   var localTearOff = lf;
   var paramTearOff = pf;
 }
 ''');
     expectIdentifierType('methodTearOff', "<T>(int) → T");
     expectIdentifierType('staticTearOff', "<T>(T) → T");
     expectIdentifierType('staticFieldTearOff', "<T>(T) → T");
     expectIdentifierType('topFunTearOff', "<T>(T) → T");
     expectIdentifierType('topFieldTearOff', "<T>(T) → T");
     expectIdentifierType('localTearOff', "<T>(T) → T");
     expectIdentifierType('paramTearOff', "<T>(T) → T");
   }
 
-  void test_genericMethod_then() {
+  test_genericMethod_then() async {
     String code = r'''
 import 'dart:async';
 String toString(int x) => x.toString();
 main() {
   Future<int> bar = null;
   var foo = bar.then(toString);
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'Future<String>', isNull);
   }
 
-  void test_genericMethod_then_prefixed() {
+  test_genericMethod_then_prefixed() async {
     String code = r'''
 import 'dart:async' as async;
 String toString(int x) => x.toString();
 main() {
   async.Future<int> bar = null;
   var foo = bar.then(toString);
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'Future<String>', isNull);
   }
 
-  void test_genericMethod_then_propagatedType() {
+  test_genericMethod_then_propagatedType() async {
     // Regression test for https://github.com/dart-lang/sdk/issues/25482.
     String code = r'''
 import 'dart:async';
 void main() {
   Future<String> p;
   var foo = p.then((r) => new Future<String>.value(3));
 }
 ''';
     // This should produce no hints or warnings.
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'Future<String>', isNull);
   }
 
-  void test_implicitBounds() {
+  test_implicitBounds() async {
     String code = r'''
 class A<T> {}
 
 class B<T extends num> {}
 
 class C<S extends int, T extends B<S>, U extends B> {}
 
 void test() {
 //
   A ai;
   B bi;
   C ci;
   var aa = new A();
   var bb = new B();
   var cc = new C();
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectIdentifierType('ai', "A<dynamic>");
     expectIdentifierType('bi', "B<num>");
     expectIdentifierType('ci', "C<int, B<int>, B<dynamic>>");
     expectIdentifierType('aa', "A<dynamic>");
     expectIdentifierType('bb', "B<num>");
     expectIdentifierType('cc', "C<int, B<int>, B<dynamic>>");
   }
 
-  void test_objectMethodOnFunctions_Anonymous() {
+  test_objectMethodOnFunctions_Anonymous() async {
     String code = r'''
 void main() {
   var f = (x) => 3;
   // No errors, correct type
   var t0 = f.toString();
   var t1 = f.toString;
   var t2 = f.hashCode;
 
   // Expressions, no errors, correct type
   var t3 = (f).toString();
   var t4 = (f).toString;
   var t5 = (f).hashCode;
 
   // Cascades, no errors
   f..toString();
   f..toString;
   f..hashCode;
 
   // Expression cascades, no errors
   (f)..toString();
   (f)..toString;
   (f)..hashCode;
 }''';
-    objectMethodOnFunctions_helper(code);
+    await _objectMethodOnFunctions_helper2(code);
   }
 
-  void test_objectMethodOnFunctions_Function() {
+  test_objectMethodOnFunctions_Function() async {
     String code = r'''
 void main() {
   Function f;
   // No errors, correct type
   var t0 = f.toString();
   var t1 = f.toString;
   var t2 = f.hashCode;
 
   // Expressions, no errors, correct type
   var t3 = (f).toString();
   var t4 = (f).toString;
   var t5 = (f).hashCode;
 
   // Cascades, no errors
   f..toString();
   f..toString;
   f..hashCode;
 
   // Expression cascades, no errors
   (f)..toString();
   (f)..toString;
   (f)..hashCode;
 }''';
-    objectMethodOnFunctions_helper(code);
+    await _objectMethodOnFunctions_helper2(code);
   }
 
-  void test_objectMethodOnFunctions_Static() {
+  test_objectMethodOnFunctions_Static() async {
     String code = r'''
 int f(int x) => null;
 void main() {
   // No errors, correct type
   var t0 = f.toString();
   var t1 = f.toString;
   var t2 = f.hashCode;
 
   // Expressions, no errors, correct type
   var t3 = (f).toString();
   var t4 = (f).toString;
   var t5 = (f).hashCode;
 
   // Cascades, no errors
   f..toString();
   f..toString;
   f..hashCode;
 
   // Expression cascades, no errors
   (f)..toString();
   (f)..toString;
   (f)..hashCode;
 }''';
-    objectMethodOnFunctions_helper(code);
+    await _objectMethodOnFunctions_helper2(code);
   }
 
-  void test_objectMethodOnFunctions_Typedef() {
+  test_objectMethodOnFunctions_Typedef() async {
     String code = r'''
 typedef bool Predicate<T>(T object);
 
 void main() {
   Predicate<int> f;
   // No errors, correct type
   var t0 = f.toString();
   var t1 = f.toString;
   var t2 = f.hashCode;
 
   // Expressions, no errors, correct type
   var t3 = (f).toString();
   var t4 = (f).toString;
   var t5 = (f).hashCode;
 
   // Cascades, no errors
   f..toString();
   f..toString;
   f..hashCode;
 
   // Expression cascades, no errors
   (f)..toString();
   (f)..toString;
   (f)..hashCode;
 }''';
-    objectMethodOnFunctions_helper(code);
+    await _objectMethodOnFunctions_helper2(code);
   }
 
-  void test_setterWithDynamicTypeIsError() {
+  test_setterWithDynamicTypeIsError() async {
     Source source = addSource(r'''
 class A {
   dynamic set f(String s) => null;
 }
 dynamic set g(int x) => null;
 ''');
-    assertErrors(source, [
+    await assertErrors(source, [
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER,
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER
     ]);
     verify([source]);
   }
 
-  void test_setterWithExplicitVoidType_returningVoid() {
+  test_setterWithExplicitVoidType_returningVoid() async {
     Source source = addSource(r'''
 void returnsVoid() {}
 class A {
   void set f(String s) => returnsVoid();
 }
 void set g(int x) => returnsVoid();
 ''');
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
   }
 
-  void test_setterWithNoVoidType() {
+  test_setterWithNoVoidType() async {
     Source source = addSource(r'''
 class A {
   set f(String s) {
     return '42';
   }
 }
 set g(int x) => 42;
 ''');
-    assertErrors(source, [
+    await assertErrors(source, [
       StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
     ]);
     verify([source]);
   }
 
-  void test_setterWithNoVoidType_returningVoid() {
+  test_setterWithNoVoidType_returningVoid() async {
     Source source = addSource(r'''
 void returnsVoid() {}
 class A {
   set f(String s) => returnsVoid();
 }
 set g(int x) => returnsVoid();
 ''');
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
   }
 
-  void test_setterWithOtherTypeIsError() {
+  test_setterWithOtherTypeIsError() async {
     Source source = addSource(r'''
 class A {
   String set f(String s) => null;
 }
 Object set g(x) => null;
 ''');
-    assertErrors(source, [
+    await assertErrors(source, [
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER,
       StaticWarningCode.NON_VOID_RETURN_FOR_SETTER
     ]);
     verify([source]);
   }
 
-  void test_ternaryOperator_null_left() {
+  test_ternaryOperator_null_left() async {
     String code = r'''
 main() {
   var foo = (true) ? null : 3;
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'int', isNull);
   }
 
-  void test_ternaryOperator_null_right() {
+  test_ternaryOperator_null_right() async {
     String code = r'''
 main() {
   var foo = (true) ? 3 : null;
 }
 ''';
-    resolveTestUnit(code);
+    await resolveTestUnit(code);
     expectInitializerType('foo', 'int', isNull);
   }
 }
 
 @reflectiveTest
 class StrongModeTypePropagationTest extends ResolverTestCase {
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
   }
 
-  void test_foreachInference_dynamic_disabled() {
+  test_foreachInference_dynamic_disabled() async {
     String code = r'''
 main() {
   var list = <int>[];
   for (dynamic v in list) {
     v; // marker
   }
 }''';
-    assertPropagatedIterationType(code, typeProvider.dynamicType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    await assertPropagatedIterationType(code, typeProvider.dynamicType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
   }
 
-  void test_foreachInference_reusedVar_disabled() {
+  test_foreachInference_reusedVar_disabled() async {
     String code = r'''
 main() {
   var list = <int>[];
   var v;
   for (v in list) {
     v; // marker
   }
 }''';
-    assertPropagatedIterationType(code, typeProvider.dynamicType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    await assertPropagatedIterationType(code, typeProvider.dynamicType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
   }
 
-  void test_foreachInference_var() {
+  test_foreachInference_var() async {
     String code = r'''
 main() {
   var list = <int>[];
   for (var v in list) {
     v; // marker
   }
 }''';
-    assertPropagatedIterationType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedIterationType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_foreachInference_var_iterable() {
+  test_foreachInference_var_iterable() async {
     String code = r'''
 main() {
   Iterable<int> list = <int>[];
   for (var v in list) {
     v; // marker
   }
 }''';
-    assertPropagatedIterationType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedIterationType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_foreachInference_var_stream() {
+  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
   }
 }''';
-    assertPropagatedIterationType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedIterationType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_bottom_disabled() {
+  test_localVariableInference_bottom_disabled() async {
     String code = r'''
 main() {
   var v = null;
   v; // marker
 }''';
-    assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    await assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
   }
 
-  void test_localVariableInference_constant() {
+  test_localVariableInference_constant() async {
     String code = r'''
 main() {
   var v = 3;
   v; // marker
 }''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_declaredType_disabled() {
+  test_localVariableInference_declaredType_disabled() async {
     String code = r'''
 main() {
   dynamic v = 3;
   v; // marker
 }''';
-    assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    await assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
   }
 
-  void test_localVariableInference_noInitializer_disabled() {
+  test_localVariableInference_noInitializer_disabled() async {
     String code = r'''
 main() {
   var v;
   v = 3;
   v; // marker
 }''';
-    assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
+    await assertPropagatedAssignedType(code, typeProvider.dynamicType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.dynamicType, null);
   }
 
-  void test_localVariableInference_transitive_field_inferred_lexical() {
+  test_localVariableInference_transitive_field_inferred_lexical() async {
     String code = r'''
 class A {
   final x = 3;
   f() {
     var v = x;
     return v; // marker
   }
 }
 main() {
 }
 ''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_field_inferred_reversed() {
+  test_localVariableInference_transitive_field_inferred_reversed() async {
     String code = r'''
 class A {
   f() {
     var v = x;
     return v; // marker
   }
   final x = 3;
 }
 main() {
 }
 ''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_field_lexical() {
+  test_localVariableInference_transitive_field_lexical() async {
     String code = r'''
 class A {
   int x = 3;
   f() {
     var v = x;
     return v; // marker
   }
 }
 main() {
 }
 ''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_field_reversed() {
+  test_localVariableInference_transitive_field_reversed() async {
     String code = r'''
 class A {
   f() {
     var v = x;
     return v; // marker
   }
   int x = 3;
 }
 main() {
 }
 ''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_list_local() {
+  test_localVariableInference_transitive_list_local() async {
     String code = r'''
 main() {
   var x = <int>[3];
   var v = x[0];
   v; // marker
 }''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_local() {
+  test_localVariableInference_transitive_local() async {
     String code = r'''
 main() {
   var x = 3;
   var v = x;
   v; // marker
 }''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_toplevel_inferred_lexical() {
+  test_localVariableInference_transitive_toplevel_inferred_lexical() async {
     String code = r'''
 final x = 3;
 main() {
   var v = x;
   v; // marker
 }
 ''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_toplevel_inferred_reversed() {
+  test_localVariableInference_transitive_toplevel_inferred_reversed() async {
     String code = r'''
 main() {
   var v = x;
   v; // marker
 }
 final x = 3;
 ''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_toplevel_lexical() {
+  test_localVariableInference_transitive_toplevel_lexical() async {
     String code = r'''
 int x = 3;
 main() {
   var v = x;
   v; // marker
 }
 ''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 
-  void test_localVariableInference_transitive_toplevel_reversed() {
+  test_localVariableInference_transitive_toplevel_reversed() async {
     String code = r'''
 main() {
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
-    assertPropagatedAssignedType(code, typeProvider.intType, null);
-    assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+    await assertPropagatedAssignedType(code, typeProvider.intType, null);
+    await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }