Run the rest of the analysis tests with the new analysis driver.

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';
 
 import '../utils.dart';
 import 'resolver_test_case.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(StrongModeDownwardsInferenceTest);
     defineReflectiveTests(StrongModeStaticTypeAnalyzer2Test);
     defineReflectiveTests(StrongModeTypePropagationTest);
+    defineReflectiveTests(StrongModeDownwardsInferenceTest_Driver);
+    defineReflectiveTests(StrongModeStaticTypeAnalyzer2Test_Driver);
     defineReflectiveTests(StrongModeTypePropagationTest_Driver);
   });
 }
 
 /**
  * Strong mode static analyzer downwards inference tests
  */
 @reflectiveTest
 class StrongModeDownwardsInferenceTest extends ResolverTestCase {
   TypeAssertions _assertions;
@@ skipping 57 matching lines @@
 
         Future g0() { return new Future.value(3); }
         Future g1() async { return new Future.value(3); }
         Future g2() async { return await new Future.value(3); }
 
         Future<int> g3() { return new Future.value(3); }
         Future<int> g4() async { return new Future.value(3); }
         Future<int> g5() async { return await new Future.value(3); }
       }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
 
     void check(String name, Asserter<InterfaceType> typeTest) {
       MethodDeclaration test = AstFinder.getMethodInClass(unit, "A", name);
       FunctionBody body = test.body;
       Expression returnExp;
       if (body is ExpressionFunctionBody) {
         returnExp = body.expression;
       } else {
         ReturnStatement stmt = (body as BlockFunctionBody).block.statements[0];
         returnExp = stmt.expression;
@@ skipping 35 matching lines @@
       Future<int> f5() async => await new Future.value(3);
 
       Future g0() { return new Future.value(3); }
       Future g1() async { return new Future.value(3); }
       Future g2() async { return await new Future.value(3); }
 
       Future<int> g3() { return new Future.value(3); }
       Future<int> g4() async { return new Future.value(3); }
       Future<int> g5() async { return await new Future.value(3); }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
 
     void check(String name, Asserter<InterfaceType> typeTest) {
       FunctionDeclaration test = AstFinder.getTopLevelFunction(unit, name);
       FunctionBody body = test.functionExpression.body;
       Expression returnExp;
       if (body is ExpressionFunctionBody) {
         returnExp = body.expression;
       } else {
         ReturnStatement stmt = (body as BlockFunctionBody).block.statements[0];
         returnExp = stmt.expression;
@@ skipping 26 matching lines @@
     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);
+    CompilationUnit unit = await 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)]));
   }
 
   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);
+    CompilationUnit unit = await 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)]));
   }
 
   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);
+    CompilationUnit unit = await resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     CascadeExpression fetch(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       CascadeExpression exp = decl.initializer;
       return exp;
     }
 
     Element elementA = AstFinder.getClass(unit, "A").element;
 
     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);
   }
 
   test_constructorInitializer_propagation() async {
     String code = r'''
       class A {
         List<String> x;
         A() : this.x = [];
       }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     ConstructorFieldInitializer assignment = constructor.initializers[0];
     Expression exp = assignment.expression;
     _isListOf(_isString)(exp.staticType);
   }
 
   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);
+    CompilationUnit unit = await 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);
   }
 
   test_fieldDeclaration_propagation() async {
     String code = r'''
       class A {
         List<String> f0 = ["hello"];
       }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
 
     VariableDeclaration field = AstFinder.getFieldInClass(unit, "A", "f0");
 
     _isListOf(_isString)(field.initializer.staticType);
   }
 
   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;
      }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
 
     FunctionDeclaration test1 = AstFinder.getTopLevelFunction(unit, "test1");
     ExpressionFunctionBody body = test1.functionExpression.body;
     assertListOfInt(body.expression.staticType);
 
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "test2");
 
@@ skipping 18 matching lines @@
       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);
+    CompilationUnit unit = await 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));
   }
 
   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);
+    CompilationUnit unit = await 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));
   }
 
   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];};
      }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     Expression functionReturnValue(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
       FunctionBody body = exp.body;
       if (body is ExpressionFunctionBody) {
         return body.expression;
       } else {
@@ skipping 16 matching lines @@
       }
 
       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);
         (new Mapper<int, String>().map)((int x) {return 3;});
      }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       FunctionExpressionInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
       return resolutionMap.elementDeclaredByFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
@@ skipping 10 matching lines @@
       }
 
       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);
         (new Mapper<int, String>().map)((x) {return 3;});
      }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       FunctionExpressionInvocation 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));
   }
 
   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);
+    CompilationUnit unit = await 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));
   }
 
   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);
+    CompilationUnit unit = await 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));
@@ skipping 10 matching lines @@
       }
 
       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);
         new Mapper<int, String>().map((int x) {return 3;});
      }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await 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));
@@ skipping 10 matching lines @@
       }
 
       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);
         new Mapper<int, String>().map((x) {return 3;});
      }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await 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));
   }
 
   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();
      }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     Expression functionReturnValue(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
       FunctionBody body = exp.body;
       if (body is ExpressionFunctionBody) {
         return body.expression;
       } else {
@@ skipping 28 matching lines @@
       abstract class A {
         Map<int, List<int>> get map;
       }
       class B extends A {
         var map = { 42: [] };
       }
       class C extends A {
         get map => { 43: [] };
       }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
     Asserter<InterfaceType> assertMapOfIntToListOfInt =
         _isMapOf(_isInt, (DartType type) => assertListOfInt(type));
 
     VariableDeclaration mapB = AstFinder.getFieldInClass(unit, "B", "map");
     MethodDeclaration mapC = AstFinder.getMethodInClass(unit, "C", "map");
     assertMapOfIntToListOfInt(
         resolutionMap.elementDeclaredByVariableDeclaration(mapB).type);
     assertMapOfIntToListOfInt(
@@ skipping 96 matching lines @@
       }
       void test9() { // Check named and optional arguments
         A<int, String> a0 = new F(3, "hello", a: [3], b: ["hello"]);
         A<int, String> a1 = new F(3, "hello", a: ["hello"], b:[3]);
         A<int, String> a2 = new F.named(3, "hello", 3, "hello");
         A<int, String> a3 = new F.named(3, "hello");
         A<int, String> a4 = new F.named(3, "hello", "hello", 3);
         A<int, String> a5 = new F.named(3, "hello", "hello");
       }
     }''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
 
     Expression rhs(VariableDeclarationStatement stmt) {
       VariableDeclaration decl = stmt.variables.variables[0];
       Expression exp = decl.initializer;
       return exp;
     }
 
     void hasType(Asserter<DartType> assertion, Expression exp) =>
         assertion(exp.staticType);
 
@@ skipping 114 matching lines @@
 
   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);
+    CompilationUnit unit = await resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     ListLiteral literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       ListLiteral exp = decl.initializer;
       return exp;
     }
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
@@ skipping 12 matching lines @@
 
   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);
+    CompilationUnit unit = await 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));
   }
 
   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);
+    CompilationUnit unit = await 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));
   }
 
   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);
+    CompilationUnit unit = await 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));
   }
 
   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);
+    CompilationUnit unit = await 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));
   }
 
   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);
+    CompilationUnit unit = await resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     MapLiteral literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       MapLiteral exp = decl.initializer;
       return exp;
     }
 
     Asserter<InterfaceType> assertListOfString = _isListOf(_isString);
@@ skipping 15 matching lines @@
   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);
+    CompilationUnit unit = await 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));
   }
 
   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);
+    CompilationUnit unit = await 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));
   }
 
   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);
+    CompilationUnit unit = await 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);
   }
 
   test_redirectingConstructor_propagation() async {
     String code = r'''
       class A {
         A() : this.named([]);
         A.named(List<String> x);
       }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
 
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     RedirectingConstructorInvocation invocation = constructor.initializers[0];
     Expression exp = invocation.argumentList.arguments[0];
     _isListOf(_isString)(exp.staticType);
   }
 
   test_superConstructorInvocation_propagation() async {
     String code = r'''
       class B {
         B(List<String>);
       }
       class A extends B {
         A() : super([]);
       }
    ''';
-    CompilationUnit unit = resolveSource(code);
+    CompilationUnit unit = await resolveSource(code);
 
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     SuperConstructorInvocation invocation = constructor.initializers[0];
     Expression exp = invocation.argumentList.arguments[0];
     _isListOf(_isString)(exp.staticType);
   }
 
   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);
+    CompilationUnit unit = await 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)));
   }
 
   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);
+    CompilationUnit unit = await 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("f0", _isListOf(_isDynamic));
     check("f1", _isListOf(_isDynamic));
 
     check("f2", _isListOf(_isInt));
     check("f3", _isListOf((DartType type) => _isListOf(_isInt)(type)));
   }
 }
 
+@reflectiveTest
+class StrongModeDownwardsInferenceTest_Driver
+    extends StrongModeDownwardsInferenceTest {
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  @failingTest
+  @override
+  test_inference_hints() {
+    return super.test_inference_hints();
+  }
+}
+
 /**
  * Strong mode static analyzer end to end tests
  */
 @reflectiveTest
 class StrongModeStaticTypeAnalyzer2Test extends StaticTypeAnalyzer2TestShared {
   fail_genericMethod_tearoff_instantiated() async {
     await resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(E e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
@@ skipping 859 matching lines @@
     expectIdentifierType('t0', "String");
     expectIdentifierType('t1', "() → String");
     expectIdentifierType('t2', "int");
     expectIdentifierType('t3', "String");
     expectIdentifierType('t4', "() → String");
     expectIdentifierType('t5', "int");
   }
 }
 
 @reflectiveTest
+class StrongModeStaticTypeAnalyzer2Test_Driver
+    extends StrongModeStaticTypeAnalyzer2Test {
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  @failingTest
+  @override
+  test_genericFunction_parameter() {
+    return super.test_genericFunction_parameter();
+  }
+
+  @failingTest
+  @override
+  test_genericMethod_functionExpressionInvocation_explicit() {
+    return super.test_genericMethod_functionExpressionInvocation_explicit();
+  }
+
+  @failingTest
+  @override
+  test_genericMethod_functionExpressionInvocation_inferred() {
+    return super.test_genericMethod_functionExpressionInvocation_inferred();
+  }
+
+  @failingTest
+  @override
+  test_genericMethod_functionInvocation_explicit() {
+    return super.test_genericMethod_functionInvocation_explicit();
+  }
+
+  @failingTest
+  @override
+  test_genericMethod_functionInvocation_inferred() {
+    return super.test_genericMethod_functionInvocation_inferred();
+  }
+
+  @failingTest
+  @override
+  test_genericMethod_tearoff() {
+    return super.test_genericMethod_tearoff();
+  }
+}
+
+@reflectiveTest
 class StrongModeTypePropagationTest extends ResolverTestCase {
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWith(options: options);
   }
 
   test_foreachInference_dynamic_disabled() async {
@@ skipping 233 matching lines @@
     await assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }
 
 @reflectiveTest
 class StrongModeTypePropagationTest_Driver
     extends StrongModeTypePropagationTest {
   @override
   bool get enableNewAnalysisDriver => true;
 }