Run more analysis tests with the new analysis driver.

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.generated.resolver_test;
 
+import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
@@ skipping 27 matching lines @@
     defineReflectiveTests(LibraryImportScopeTest);
     defineReflectiveTests(LibraryScopeTest);
     defineReflectiveTests(PrefixedNamespaceTest);
     defineReflectiveTests(ScopeTest);
     defineReflectiveTests(StrictModeTest);
     defineReflectiveTests(SubtypeManagerTest);
     defineReflectiveTests(TypeOverrideManagerTest);
     defineReflectiveTests(TypePropagationTest);
     defineReflectiveTests(TypeProviderImplTest);
     defineReflectiveTests(TypeResolverVisitorTest);
+    defineReflectiveTests(TypePropagationTest_Driver);
   });
 }
 
 @reflectiveTest
 class AnalysisDeltaTest extends EngineTestCase {
   TestSource source1 = new TestSource('/1.dart');
   TestSource source2 = new TestSource('/2.dart');
   TestSource source3 = new TestSource('/3.dart');
 
   void test_getAddedSources() {
@@ skipping 1020 matching lines @@
 class A {
   bool get g => true;
 }
 A f(var p) {
   if ((p as A).g) {
     return p;
   } else {
     return null;
   }
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_assert() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   assert (p is A);
   return p;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_assignment() async {
     Source source = addSource(r'''
 f() {
   var v;
   v = 0;
   return v;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeProvider.intType));
   }
 
   test_assignment_afterInitializer() async {
     Source source = addSource(r'''
 f() {
   var v = 0;
   v = 1.0;
   return v;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeProvider.doubleType));
   }
 
   test_assignment_null() async {
     String code = r'''
 main() {
   int v; // declare
   v = null;
   return v; // return
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
-      LibraryElement library = resolve2(source);
-      await computeAnalysisResult(source);
+      TestAnalysisResult analysisResult = await computeAnalysisResult(source);
       assertNoErrors(source);
       verify([source]);
-      unit = resolveCompilationUnit(source, library);
+      unit = analysisResult.unit;
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v; // declare", (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v = null;", (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v; // return", (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
   }
 
   test_CanvasElement_getContext() async {
     String code = r'''
 import 'dart:html';
 main(CanvasElement canvas) {
   var context = canvas.getContext('2d');
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     SimpleIdentifier identifier = EngineTestCase.findNode(
         unit, code, "context", (node) => node is SimpleIdentifier);
     expect(resolutionMap.propagatedTypeForExpression(identifier).name,
         "CanvasRenderingContext2D");
   }
 
   test_forEach() async {
     String code = r'''
 main() {
   var list = <String> [];
   for (var e in list) {
     e;
   }
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     InterfaceType stringType = typeProvider.stringType;
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e in", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, same(stringType));
     }
     // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e;", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, same(stringType));
     }
   }
 
   test_forEach_async() async {
     String code = r'''
 import 'dart:async';
 f(Stream<String> stream) async {
   await for (var e in stream) {
     e;
   }
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     InterfaceType stringType = typeProvider.stringType;
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e in", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, same(stringType));
     }
     // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e;", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, same(stringType));
     }
   }
 
   test_forEach_async_inheritedStream() async {
     // From https://github.com/dart-lang/sdk/issues/24191, this ensures that
     // `await for` works for types where the generic parameter doesn't
     // correspond to the type of the Stream's data.
     String code = r'''
 import 'dart:async';
 abstract class MyCustomStream<T> implements Stream<List<T>> {}
 f(MyCustomStream<String> stream) async {
   await for (var e in stream) {
     e;
   }
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     InterfaceType listOfStringType =
         typeProvider.listType.instantiate([typeProvider.stringType]);
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e in", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, equals(listOfStringType));
     }
     // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e;", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, equals(listOfStringType));
     }
   }
 
   test_functionExpression_asInvocationArgument() async {
     String code = r'''
 class MyMap<K, V> {
   forEach(f(K key, V value)) {}
 }
 f(MyMap<int, String> m) {
   m.forEach((k, v) {
     k;
     v;
   });
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     // k
     DartType intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(
         unit, code, "k, ", (node) => node is SimpleFormalParameter);
     expect(kParameter.identifier.propagatedType, same(intType));
     SimpleIdentifier kIdentifier = EngineTestCase.findNode(
         unit, code, "k;", (node) => node is SimpleIdentifier);
     expect(kIdentifier.propagatedType, same(intType));
     expect(kIdentifier.staticType, same(typeProvider.dynamicType));
     // v
@@ skipping 10 matching lines @@
   test_functionExpression_asInvocationArgument_fromInferredInvocation() async {
     String code = r'''
 class MyMap<K, V> {
   forEach(f(K key, V value)) {}
 }
 f(MyMap<int, String> m) {
   var m2 = m;
   m2.forEach((k, v) {});
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     // k
     DartType intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(
         unit, code, "k, ", (node) => node is SimpleFormalParameter);
     expect(kParameter.identifier.propagatedType, same(intType));
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
   }
 
   test_functionExpression_asInvocationArgument_functionExpressionInvocation() async {
     String code = r'''
 main() {
   (f(String value)) {} ((v) {
     v;
   });
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     // v
     DartType dynamicType = typeProvider.dynamicType;
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is FormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
     expect(vParameter.identifier.staticType, same(dynamicType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(
         unit, code, "v;", (node) => node is SimpleIdentifier);
     expect(vIdentifier.propagatedType, same(stringType));
     expect(vIdentifier.staticType, same(dynamicType));
   }
 
   test_functionExpression_asInvocationArgument_keepIfLessSpecific() async {
     String code = r'''
 class MyList {
   forEach(f(Object value)) {}
 }
 f(MyList list) {
   list.forEach((int v) {
     v;
   });
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     // v
     DartType intType = typeProvider.intType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(null));
     expect(vParameter.identifier.staticType, same(intType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(
         unit, code, "v;", (node) => node is SimpleIdentifier);
     expect(vIdentifier.staticType, same(intType));
     expect(vIdentifier.propagatedType, same(null));
   }
 
   test_functionExpression_asInvocationArgument_notSubtypeOfStaticType() async {
     String code = r'''
 class A {
   m(void f(int i)) {}
 }
 x() {
   A a = new A();
   a.m(() => 0);
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
+    CompilationUnit unit = await _computeResolvedUnit(source, noErrors: false);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
     // () => 0
     FunctionExpression functionExpression = EngineTestCase.findNode(
         unit, code, "() => 0)", (node) => node is FunctionExpression);
     expect((functionExpression.staticType as FunctionType).parameters.length,
         same(0));
     expect(functionExpression.propagatedType, same(null));
   }
 
   test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() async {
     String code = r'''
 class MyList<E> {
   forEach(f(E value)) {}
 }
 f(MyList<String> list) {
   list.forEach((Object v) {
     v;
   });
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
     expect(vParameter.identifier.staticType, same(typeProvider.objectType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(
         unit, code, "v;", (node) => node is SimpleIdentifier);
     expect(vIdentifier.propagatedType, same(stringType));
   }
 
   test_Future_then() async {
     String code = r'''
 import 'dart:async';
 main(Future<int> firstFuture) {
   firstFuture.then((p1) {
     return 1.0;
   }).then((p2) {
     return new Future<String>.value('str');
   }).then((p3) {
   });
 }''';
     Source source = addSource(code);
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     // p1
     FormalParameter p1 = EngineTestCase.findNode(
         unit, code, "p1) {", (node) => node is SimpleFormalParameter);
     expect(p1.identifier.propagatedType, same(typeProvider.intType));
     // p2
     FormalParameter p2 = EngineTestCase.findNode(
         unit, code, "p2) {", (node) => node is SimpleFormalParameter);
     expect(p2.identifier.propagatedType, same(typeProvider.doubleType));
     // p3
     FormalParameter p3 = EngineTestCase.findNode(
         unit, code, "p3) {", (node) => node is SimpleFormalParameter);
     expect(p3.identifier.propagatedType, same(typeProvider.stringType));
   }
 
   test_initializer() async {
     Source source = addSource(r'''
 f() {
   var v = 0;
   return v;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement =
           statements[0] as VariableDeclarationStatement;
       SimpleIdentifier variableName = statement.variables.variables[0].name;
       expect(variableName.staticType, same(typeProvider.dynamicType));
       expect(variableName.propagatedType, same(typeProvider.intType));
     }
     // Type of 'v' in reference.
     {
       ReturnStatement statement = statements[1] as ReturnStatement;
       SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
       expect(variableName.propagatedType, same(typeProvider.intType));
     }
   }
 
   test_initializer_dereference() async {
     Source source = addSource(r'''
 f() {
   var v = 'String';
   v.
 }''');
-    LibraryElement library = resolve2(source);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source, noErrors: false);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ExpressionStatement statement =
         body.block.statements[1] as ExpressionStatement;
     PrefixedIdentifier invocation = statement.expression as PrefixedIdentifier;
     SimpleIdentifier variableName = invocation.prefix;
     expect(variableName.propagatedType, same(typeProvider.stringType));
   }
 
   test_initializer_hasStaticType() async {
     Source source = addSource(r'''
 f() {
   int v = 0;
   return v;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement =
           statements[0] as VariableDeclarationStatement;
       SimpleIdentifier variableName = statement.variables.variables[0].name;
       expect(variableName.staticType, same(typeProvider.intType));
       expect(variableName.propagatedType, isNull);
     }
     // Type of 'v' in reference.
     {
       ReturnStatement statement = statements[1] as ReturnStatement;
       SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
       expect(variableName.staticType, same(typeProvider.intType));
       expect(variableName.propagatedType, isNull);
     }
   }
 
   test_initializer_hasStaticType_parameterized() async {
     Source source = addSource(r'''
 f() {
   List<int> v = <int>[];
   return v;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement =
           statements[0] as VariableDeclarationStatement;
       SimpleIdentifier variableName = statement.variables.variables[0].name;
       expect(variableName.staticType, isNotNull);
@@ skipping 10 matching lines @@
 
   test_initializer_null() async {
     String code = r'''
 main() {
   int v = null;
   return v; // marker
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
-      LibraryElement library = resolve2(source);
-      await computeAnalysisResult(source);
-      assertNoErrors(source);
-      verify([source]);
-      unit = resolveCompilationUnit(source, library);
+      unit = await _computeResolvedUnit(source);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v = null;", (node) => node is SimpleIdentifier);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "v; // marker", (node) => node is SimpleIdentifier);
@@ skipping 20 matching lines @@
     expect(methodInvoke.methodName.staticElement, isNotNull);
     expect(methodInvoke.methodName.propagatedElement, isNull);
   }
 
   test_is_conditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is A) ? p : null;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional =
         statement.expression as ConditionalExpression;
     SimpleIdentifier variableName =
         conditional.thenExpression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_is_if() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     return p;
   } else {
     return null;
   }
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     // prepare A
     InterfaceType typeA;
     {
       ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
       typeA = resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     }
     // verify "f"
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
@@ skipping 16 matching lines @@
   test_is_if_lessSpecific() async {
     Source source = addSource(r'''
 class A {}
 A f(A p) {
   if (p is String) {
     return p;
   } else {
     return null;
   }
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
-//    ClassDeclaration classA = (ClassDeclaration) unit.getDeclarations().get(0);
-//    InterfaceType typeA = classA.getElement().getType();
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(null));
   }
 
   test_is_if_logicalAnd() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A && p != null) {
     return p;
   } else {
     return null;
   }
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_is_postConditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is A) ? p : throw null;
   return p;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_is_postIf() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     A a = p;
   } else {
     return null;
   }
   return p;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_is_subclass() async {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   B m() => this;
 }
 A f(A p) {
   if (p is B) {
     return p.m();
   }
   return p;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     expect(invocation.methodName.staticElement, isNotNull);
     expect(invocation.methodName.propagatedElement, isNull);
   }
 
   test_is_while() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   while (p is A) {
     return p;
   }
   return p;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
     ReturnStatement statement =
         (whileStatement.body as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_conditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is! A) ? null : p;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional =
         statement.expression as ConditionalExpression;
     SimpleIdentifier variableName =
         conditional.elseExpression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_if() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   } else {
     return p;
   }
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_if_logicalOr() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A || null == p) {
     return null;
   } else {
     return p;
   }
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source, noErrors: false);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_postConditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is! A) ? throw null : p;
   return p;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   test_isNot_postIf() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   }
   return p;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA =
         resolutionMap.elementDeclaredByClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
@@ skipping 51 matching lines @@
     DartType tB = (await findMarkedIdentifier(code, "; // B")).propagatedType;
     await assertTypeOfMarkedExpression(code, null, tB);
   }
 
   test_listLiteral_different() async {
     Source source = addSource(r'''
 f() {
   var v = [0, '1', 2];
   return v[2];
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     expect(indexExpression.propagatedType, isNull);
   }
 
   test_listLiteral_same() async {
     Source source = addSource(r'''
 f() {
   var v = [0, 1, 2];
   return v[2];
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     expect(indexExpression.propagatedType, isNull);
     Expression v = indexExpression.target;
     InterfaceType propagatedType = v.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.listType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
     expect(typeArguments, hasLength(1));
     expect(typeArguments[0], same(typeProvider.dynamicType));
   }
 
   test_mapLiteral_different() async {
     Source source = addSource(r'''
 f() {
   var v = {'0' : 0, 1 : '1', '2' : 2};
   return v;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.mapType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
     expect(typeArguments, hasLength(2));
     expect(typeArguments[0], same(typeProvider.dynamicType));
     expect(typeArguments[1], same(typeProvider.dynamicType));
   }
 
   test_mapLiteral_same() async {
     Source source = addSource(r'''
 f() {
   var v = {'a' : 0, 'b' : 1, 'c' : 2};
   return v;
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     expect(propagatedType.element, same(typeProvider.mapType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
     expect(typeArguments, hasLength(2));
     expect(typeArguments[0], same(typeProvider.dynamicType));
@@ skipping 287 matching lines @@
   var v6 = query('input#id');
   var v7 = query('select#id');
   // invocation of method
   var m1 = document.query('div');
  // unsupported currently
   var b1 = query('noSuchTag');
   var b2 = query('DART_EDITOR_NO_SUCH_TYPE');
   var b3 = query('body div');
   return [v1, v2, v3, v4, v5, v6, v7, m1, b1, b2, b3];
 }''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
+    CompilationUnit unit = await _computeResolvedUnit(source);
     FunctionDeclaration main = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = main.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[11] as ReturnStatement;
     NodeList<Expression> elements =
         (statement.expression as ListLiteral).elements;
     expect(resolutionMap.propagatedTypeForExpression(elements[0]).name,
         "AnchorElement");
     expect(resolutionMap.propagatedTypeForExpression(elements[1]).name,
         "AnchorElement");
     expect(resolutionMap.propagatedTypeForExpression(elements[2]).name,
         "BodyElement");
     expect(resolutionMap.propagatedTypeForExpression(elements[3]).name,
         "ButtonElement");
     expect(resolutionMap.propagatedTypeForExpression(elements[4]).name,
         "DivElement");
     expect(resolutionMap.propagatedTypeForExpression(elements[5]).name,
         "InputElement");
     expect(resolutionMap.propagatedTypeForExpression(elements[6]).name,
         "SelectElement");
     expect(resolutionMap.propagatedTypeForExpression(elements[7]).name,
         "DivElement");
     expect(
         resolutionMap.propagatedTypeForExpression(elements[8]).name, "Element");
     expect(
         resolutionMap.propagatedTypeForExpression(elements[9]).name, "Element");
     expect(resolutionMap.propagatedTypeForExpression(elements[10]).name,
         "Element");
   }
+
+  /**
+   * Return the resolved unit for the given [source].
+   *
+   * If [noErrors] is not specified or is not `true`, [assertNoErrors].
+   */
+  Future<CompilationUnit> _computeResolvedUnit(Source source,
+      {bool noErrors: true}) async {
+    TestAnalysisResult analysisResult = await computeAnalysisResult(source);
+    if (noErrors) {
+      assertNoErrors(source);
+      verify([source]);
+    }
+    return analysisResult.unit;
+  }
 }
 
 @reflectiveTest
+class TypePropagationTest_Driver extends TypePropagationTest {
+  @override
+  bool get enableNewAnalysisDriver => true;
+
+  @failingTest
+  @override
+  test_query() {
+    return super.test_query();
+  }
+}
+
+@reflectiveTest
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
     //
     // Create a mock library element with the types expected to be in dart:core.
     // We cannot use either ElementFactory or TestTypeProvider (which uses
     // ElementFactory) because we side-effect the elements in ways that would
     // break other tests.
     //
     InterfaceType objectType = _classElement("Object", null).type;
     InterfaceType boolType = _classElement("bool", objectType).type;
@@ skipping 1190 matching lines @@
  */
 class _StaleElement extends ElementImpl {
   _StaleElement() : super("_StaleElement", -1);
 
   @override
   get kind => throw "_StaleElement's kind shouldn't be accessed";
 
   @override
   /*=T*/ accept/*<T>*/(_) => throw "_StaleElement shouldn't be visited";
 }