Make error producing tests ansynchronous.

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:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 42 matching lines @@
     defineReflectiveTests(TypeResolverVisitorTest);
   });
 }
 
 @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() {
+  test_getAddedSources() async {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source1, AnalysisLevel.ALL);
     delta.setAnalysisLevel(source2, AnalysisLevel.ERRORS);
     delta.setAnalysisLevel(source3, AnalysisLevel.NONE);
     List<Source> addedSources = delta.addedSources;
     expect(addedSources, hasLength(2));
     expect(addedSources, unorderedEquals([source1, source2]));
   }
 
-  void test_getAnalysisLevels() {
+  test_getAnalysisLevels() async {
     AnalysisDelta delta = new AnalysisDelta();
     expect(delta.analysisLevels.length, 0);
   }
 
-  void test_setAnalysisLevel() {
+  test_setAnalysisLevel() async {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source1, AnalysisLevel.ALL);
     delta.setAnalysisLevel(source2, AnalysisLevel.ERRORS);
     Map<Source, AnalysisLevel> levels = delta.analysisLevels;
     expect(levels.length, 2);
     expect(levels[source1], AnalysisLevel.ALL);
     expect(levels[source2], AnalysisLevel.ERRORS);
   }
 
-  void test_toString() {
+  test_toString() async {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(new TestSource(), AnalysisLevel.ALL);
     String result = delta.toString();
     expect(result, isNotNull);
     expect(result.length > 0, isTrue);
   }
 }
 
 @reflectiveTest
 class ChangeSetTest extends EngineTestCase {
-  void test_changedContent() {
+  test_changedContent() async {
     TestSource source = new TestSource();
     String content = "";
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedContent(source, content);
     expect(changeSet.addedSources, hasLength(0));
     expect(changeSet.changedSources, hasLength(0));
     Map<Source, String> map = changeSet.changedContents;
     expect(map, hasLength(1));
     expect(map[source], same(content));
     expect(changeSet.changedRanges, hasLength(0));
     expect(changeSet.removedSources, hasLength(0));
     expect(changeSet.removedContainers, hasLength(0));
   }
 
-  void test_changedRange() {
+  test_changedRange() async {
     TestSource source = new TestSource();
     String content = "";
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedRange(source, content, 1, 2, 3);
     expect(changeSet.addedSources, hasLength(0));
     expect(changeSet.changedSources, hasLength(0));
     expect(changeSet.changedContents, hasLength(0));
     Map<Source, ChangeSet_ContentChange> map = changeSet.changedRanges;
     expect(map, hasLength(1));
     ChangeSet_ContentChange change = map[source];
     expect(change, isNotNull);
     expect(change.contents, content);
     expect(change.offset, 1);
     expect(change.oldLength, 2);
     expect(change.newLength, 3);
     expect(changeSet.removedSources, hasLength(0));
     expect(changeSet.removedContainers, hasLength(0));
   }
 
-  void test_toString() {
+  test_toString() async {
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(new TestSource());
     changeSet.changedSource(new TestSource());
     changeSet.changedContent(new TestSource(), "");
     changeSet.changedRange(new TestSource(), "", 0, 0, 0);
     changeSet.removedSource(new TestSource());
     changeSet
         .removedContainer(new SourceContainer_ChangeSetTest_test_toString());
     expect(changeSet.toString(), isNotNull);
   }
 }
 
 @reflectiveTest
 class EnclosedScopeTest extends ResolverTestCase {
-  void test_define_duplicate() {
+  test_define_duplicate() async {
     Scope rootScope = new _RootScope();
     EnclosedScope scope = new EnclosedScope(rootScope);
     SimpleIdentifier identifier = AstTestFactory.identifier3('v');
     VariableElement element1 = ElementFactory.localVariableElement(identifier);
     VariableElement element2 = ElementFactory.localVariableElement(identifier);
     scope.define(element1);
     scope.define(element2);
     expect(scope.lookup(identifier, null), same(element1));
   }
 }
 
 @reflectiveTest
 class ErrorResolverTest extends ResolverTestCase {
-  void test_breakLabelOnSwitchMember() {
+  test_breakLabelOnSwitchMember() async {
     Source source = addSource(r'''
 class A {
   void m(int i) {
     switch (i) {
       l: case 0:
         break;
       case 1:
         break l;
     }
   }
 }''');
-    assertErrors(source, [ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER]);
+    await assertErrors(
+        source, [ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER]);
     verify([source]);
   }
 
-  void test_continueLabelOnSwitch() {
+  test_continueLabelOnSwitch() async {
     Source source = addSource(r'''
 class A {
   void m(int i) {
     l: switch (i) {
       case 0:
         continue l;
     }
   }
 }''');
-    assertErrors(source, [ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]);
+    await assertErrors(source, [ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]);
     verify([source]);
   }
 
-  void test_enclosingElement_invalidLocalFunction() {
+  test_enclosingElement_invalidLocalFunction() async {
     Source source = addSource(r'''
 class C {
   C() {
     int get x => 0;
   }
 }''');
     LibraryElement library = resolve2(source);
     expect(library, isNotNull);
     var unit = library.definingCompilationUnit;
     expect(unit, isNotNull);
     var types = unit.types;
     expect(types, isNotNull);
     expect(types, hasLength(1));
     var type = types[0];
     expect(type, isNotNull);
     var constructors = type.constructors;
     expect(constructors, isNotNull);
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     List<FunctionElement> functions = constructor.functions;
     expect(functions, isNotNull);
     expect(functions, hasLength(1));
     expect(functions[0].enclosingElement, constructor);
-    assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
+    await assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
   }
 }
 
 /**
  * Tests for generic method and function resolution that do not use strong mode.
  */
 @reflectiveTest
 class GenericMethodResolverTest extends StaticTypeAnalyzer2TestShared {
-  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
     // strong mode example won't work, as we now compute a static type and
     // therefore discard the propagated type.
     //
     // So this test does not use 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 = ', 'dynamic', 'List<dynamic>');
   }
 }
 
 @reflectiveTest
 class LibraryImportScopeTest extends ResolverTestCase {
-  void test_creation_empty() {
+  test_creation_empty() async {
     new LibraryImportScope(createDefaultTestLibrary());
   }
 
-  void test_creation_nonEmpty() {
+  test_creation_nonEmpty() async {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl.forNode(
         AstTestFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary(context, "imported");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
         .types = <ClassElement>[importedType];
     LibraryElementImpl definingLibrary =
         createTestLibrary(context, "importing");
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement>[importElement];
     Scope scope = new LibraryImportScope(definingLibrary);
     expect(
         scope.lookup(
             AstTestFactory.identifier3(importedTypeName), definingLibrary),
         importedType);
   }
 
-  void test_prefixedAndNonPrefixed() {
+  test_prefixedAndNonPrefixed() async {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeName = "C";
     String prefixName = "p";
     ClassElement prefixedType = ElementFactory.classElement2(typeName);
     ClassElement nonPrefixedType = ElementFactory.classElement2(typeName);
     LibraryElement prefixedLibrary =
         createTestLibrary(context, "import.prefixed");
     (prefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
         .types = <ClassElement>[prefixedType];
     ImportElementImpl prefixedImport = ElementFactory.importFor(
@@ skipping 15 matching lines @@
         AstTestFactory.identifier5(prefixName, typeName), importingLibrary);
     expect(prefixedElement, same(prefixedType));
     Element nonPrefixedElement =
         scope.lookup(AstTestFactory.identifier3(typeName), importingLibrary);
     expect(nonPrefixedElement, same(nonPrefixedType));
   }
 }
 
 @reflectiveTest
 class LibraryScopeTest extends ResolverTestCase {
-  void test_creation_empty() {
+  test_creation_empty() async {
     new LibraryScope(createDefaultTestLibrary());
   }
 
-  void test_creation_nonEmpty() {
+  test_creation_nonEmpty() async {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl.forNode(
         AstTestFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary(context, "imported");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)
         .types = <ClassElement>[importedType];
     LibraryElementImpl definingLibrary =
         createTestLibrary(context, "importing");
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement>[importElement];
     Scope scope = new LibraryScope(definingLibrary);
     expect(
         scope.lookup(
             AstTestFactory.identifier3(importedTypeName), definingLibrary),
         importedType);
   }
 }
 
 @reflectiveTest
 class PrefixedNamespaceTest extends ResolverTestCase {
-  void test_lookup_missing() {
+  test_lookup_missing() async {
     ClassElement element = ElementFactory.classElement2('A');
     PrefixedNamespace namespace = new PrefixedNamespace('p', _toMap([element]));
     expect(namespace.get('p.B'), isNull);
   }
 
-  void test_lookup_missing_matchesPrefix() {
+  test_lookup_missing_matchesPrefix() async {
     ClassElement element = ElementFactory.classElement2('A');
     PrefixedNamespace namespace = new PrefixedNamespace('p', _toMap([element]));
     expect(namespace.get('p'), isNull);
   }
 
-  void test_lookup_valid() {
+  test_lookup_valid() async {
     ClassElement element = ElementFactory.classElement2('A');
     PrefixedNamespace namespace = new PrefixedNamespace('p', _toMap([element]));
     expect(namespace.get('p.A'), same(element));
   }
 
   HashMap<String, Element> _toMap(List<Element> elements) {
     HashMap<String, Element> map = new HashMap<String, Element>();
     for (Element element in elements) {
       map[element.name] = element;
     }
     return map;
   }
 }
 
 @reflectiveTest
 class ScopeTest extends ResolverTestCase {
-  void test_define_duplicate() {
+  test_define_duplicate() async {
     Scope scope = new _RootScope();
     SimpleIdentifier identifier = AstTestFactory.identifier3('v');
     VariableElement element1 = ElementFactory.localVariableElement(identifier);
     VariableElement element2 = ElementFactory.localVariableElement(identifier);
     scope.define(element1);
     scope.define(element2);
     expect(scope.localLookup('v', null), same(element1));
   }
 
-  void test_isPrivateName_nonPrivate() {
+  test_isPrivateName_nonPrivate() async {
     expect(Scope.isPrivateName("Public"), isFalse);
   }
 
-  void test_isPrivateName_private() {
+  test_isPrivateName_private() async {
     expect(Scope.isPrivateName("_Private"), isTrue);
   }
 }
 
 class SourceContainer_ChangeSetTest_test_toString implements SourceContainer {
   @override
   bool contains(Source source) => false;
 }
 
 /**
@@ skipping 212 matching lines @@
     return "<unknown file- ASTNode is null>";
   }
 }
 
 /**
  * The class `StrictModeTest` contains tests to ensure that the correct errors and warnings
  * are reported when the analysis engine is run in strict mode.
  */
 @reflectiveTest
 class StrictModeTest extends ResolverTestCase {
-  void fail_for() {
+  fail_for() async {
     Source source = addSource(r'''
 int f(List<int> list) {
   num sum = 0;
   for (num i = 0; i < list.length; i++) {
     sum += list[i];
   }
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   @override
   void setUp() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.hint = false;
     resetWithOptions(options);
   }
 
-  void test_assert_is() {
+  test_assert_is() async {
     Source source = addSource(r'''
 int f(num n) {
   assert (n is int);
   return n & 0x0F;
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
-  void test_conditional_and_is() {
+  test_conditional_and_is() async {
     Source source = addSource(r'''
 int f(num n) {
   return (n is int && n > 0) ? n & 0x0F : 0;
 }''');
-    assertNoErrors(source);
+    await assertNoErrors(source);
   }
 
-  void test_conditional_is() {
+  test_conditional_is() async {
     Source source = addSource(r'''
 int f(num n) {
   return (n is int) ? n & 0x0F : 0;
 }''');
-    assertNoErrors(source);
+    await assertNoErrors(source);
   }
 
-  void test_conditional_isNot() {
+  test_conditional_isNot() async {
     Source source = addSource(r'''
 int f(num n) {
   return (n is! int) ? 0 : n & 0x0F;
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
-  void test_conditional_or_is() {
+  test_conditional_or_is() async {
     Source source = addSource(r'''
 int f(num n) {
   return (n is! int || n < 0) ? 0 : n & 0x0F;
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
-  void test_forEach() {
+  test_forEach() async {
     Source source = addSource(r'''
 int f(List<int> list) {
   num sum = 0;
   for (num n in list) {
     sum += n & 0x0F;
   }
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
-  void test_if_and_is() {
+  test_if_and_is() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is int && n > 0) {
     return n & 0x0F;
   }
   return 0;
 }''');
-    assertNoErrors(source);
+    await assertNoErrors(source);
   }
 
-  void test_if_is() {
+  test_if_is() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is int) {
     return n & 0x0F;
   }
   return 0;
 }''');
-    assertNoErrors(source);
+    await assertNoErrors(source);
   }
 
-  void test_if_isNot() {
+  test_if_isNot() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int) {
     return 0;
   } else {
     return n & 0x0F;
   }
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
-  void test_if_isNot_abrupt() {
+  test_if_isNot_abrupt() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int) {
     return 0;
   }
   return n & 0x0F;
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
-  void test_if_or_is() {
+  test_if_or_is() async {
     Source source = addSource(r'''
 int f(num n) {
   if (n is! int || n < 0) {
     return 0;
   } else {
     return n & 0x0F;
   }
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
-  void test_localVar() {
+  test_localVar() async {
     Source source = addSource(r'''
 int f() {
   num n = 1234;
   return n & 0x0F;
 }''');
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    await assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 }
 
 @reflectiveTest
 class SubtypeManagerTest {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
 
   /**
    * The compilation unit element containing all of the types setup in each test.
    */
   CompilationUnitElementImpl _definingCompilationUnit;
 
   void setUp() {
     MemoryResourceProvider resourceProvider = new MemoryResourceProvider();
     AnalysisContext context = AnalysisContextFactory.contextWithCore(
         resourceProvider: resourceProvider);
     Source source = new FileSource(resourceProvider.getFile("/test.dart"));
     _definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     _definingCompilationUnit.librarySource =
         _definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary =
         ElementFactory.library(context, "test");
     definingLibrary.definingCompilationUnit = _definingCompilationUnit;
     _subtypeManager = new SubtypeManager();
   }
 
-  void test_computeAllSubtypes_infiniteLoop() {
+  test_computeAllSubtypes_infiniteLoop() async {
     //
     // class A extends B
     // class B extends A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A");
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     classA.supertype = classB.type;
     _definingCompilationUnit.types = <ClassElement>[classA, classB];
     HashSet<ClassElement> subtypesOfA =
         _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     expect(subtypesOfA, hasLength(2));
     expect(arraySubtypesOfA, unorderedEquals([classA, classB]));
   }
 
-  void test_computeAllSubtypes_manyRecursiveSubtypes() {
+  test_computeAllSubtypes_manyRecursiveSubtypes() async {
     //
     // class A
     // class B extends A
     // class C extends B
     // class D extends B
     // class E extends B
     //
     ClassElementImpl classA = ElementFactory.classElement2("A");
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type);
@@ skipping 11 matching lines @@
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     HashSet<ClassElement> subtypesOfB =
         _subtypeManager.computeAllSubtypes(classB);
     List<ClassElement> arraySubtypesOfB = new List.from(subtypesOfB);
     expect(subtypesOfA, hasLength(4));
     expect(arraySubtypesOfA, unorderedEquals([classB, classC, classD, classE]));
     expect(subtypesOfB, hasLength(3));
     expect(arraySubtypesOfB, unorderedEquals([classC, classD, classE]));
   }
 
-  void test_computeAllSubtypes_noSubtypes() {
+  test_computeAllSubtypes_noSubtypes() async {
     //
     // class A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A");
     _definingCompilationUnit.types = <ClassElement>[classA];
     HashSet<ClassElement> subtypesOfA =
         _subtypeManager.computeAllSubtypes(classA);
     expect(subtypesOfA, hasLength(0));
   }
 
-  void test_computeAllSubtypes_oneSubtype() {
+  test_computeAllSubtypes_oneSubtype() async {
     //
     // class A
     // class B extends A
     //
     ClassElementImpl classA = ElementFactory.classElement2("A");
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     _definingCompilationUnit.types = <ClassElement>[classA, classB];
     HashSet<ClassElement> subtypesOfA =
         _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     expect(subtypesOfA, hasLength(1));
     expect(arraySubtypesOfA, unorderedEquals([classB]));
   }
 }
 
 @reflectiveTest
 class TypeOverrideManagerTest extends EngineTestCase {
-  void test_exitScope_noScopes() {
+  test_exitScope_noScopes() async {
     TypeOverrideManager manager = new TypeOverrideManager();
     expect(() {
       manager.exitScope();
     }, throwsStateError);
   }
 
-  void test_exitScope_oneScope() {
+  test_exitScope_oneScope() async {
     TypeOverrideManager manager = new TypeOverrideManager();
     manager.enterScope();
     manager.exitScope();
     expect(() {
       manager.exitScope();
     }, throwsStateError);
   }
 
-  void test_exitScope_twoScopes() {
+  test_exitScope_twoScopes() async {
     TypeOverrideManager manager = new TypeOverrideManager();
     manager.enterScope();
     manager.exitScope();
     manager.enterScope();
     manager.exitScope();
     expect(() {
       manager.exitScope();
     }, throwsStateError);
   }
 
-  void test_getType_enclosedOverride() {
+  test_getType_enclosedOverride() async {
     TypeOverrideManager manager = new TypeOverrideManager();
     LocalVariableElementImpl element =
         ElementFactory.localVariableElement2("v");
     InterfaceType type = ElementFactory.classElement2("C").type;
     manager.enterScope();
     manager.setType(element, type);
     manager.enterScope();
     expect(manager.getType(element), same(type));
   }
 
-  void test_getType_immediateOverride() {
+  test_getType_immediateOverride() async {
     TypeOverrideManager manager = new TypeOverrideManager();
     LocalVariableElementImpl element =
         ElementFactory.localVariableElement2("v");
     InterfaceType type = ElementFactory.classElement2("C").type;
     manager.enterScope();
     manager.setType(element, type);
     expect(manager.getType(element), same(type));
   }
 
-  void test_getType_noOverride() {
+  test_getType_noOverride() async {
     TypeOverrideManager manager = new TypeOverrideManager();
     manager.enterScope();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 
-  void test_getType_noScope() {
+  test_getType_noScope() async {
     TypeOverrideManager manager = new TypeOverrideManager();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 }
 
 @reflectiveTest
 class TypePropagationTest extends ResolverTestCase {
-  void fail_mergePropagatedTypesAtJoinPoint_1() {
+  fail_mergePropagatedTypesAtJoinPoint_1() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f1(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = '';
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return y; // marker
 }''',
         null,
         typeProvider.dynamicType);
   }
 
-  void fail_mergePropagatedTypesAtJoinPoint_2() {
+  fail_mergePropagatedTypesAtJoinPoint_2() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f2(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return y; // marker
 }''',
         null,
         typeProvider.dynamicType);
   }
 
-  void fail_mergePropagatedTypesAtJoinPoint_3() {
+  fail_mergePropagatedTypesAtJoinPoint_3() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f4(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     y = 1.5;
   }
   // Propagated type is [List] here: incorrect.
   // A correct answer is the least upper bound of [int] and [double],
   // i.e. [num].
   return y; // marker
 }''',
         null,
         typeProvider.numType);
   }
 
-  void fail_mergePropagatedTypesAtJoinPoint_5() {
+  fail_mergePropagatedTypesAtJoinPoint_5() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f6(x,y) {
   var z = [];
   if (x || (z = y) < 0) {
   } else {
     z = 0;
   }
   // Propagated type is [List] here: incorrect.
   // Best we can do is [Object]?
   return z; // marker
 }''',
         null,
         typeProvider.dynamicType);
   }
 
-  void fail_mergePropagatedTypesAtJoinPoint_7() {
+  fail_mergePropagatedTypesAtJoinPoint_7() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In general [continue]s are unsafe for the purposes of
     // [isAbruptTerminationStatement].
     //
     // This is like example 6, but less tricky: the code in the branch that
     // [continue]s is in effect after the [if].
     String code = r'''
 f() {
   var x = 0;
   var c = false;
   var d = true;
   while (d) {
     if (c) {
       d = false;
     } else {
       x = '';
       c = true;
       continue;
     }
     x; // marker
   }
 }''';
-    DartType t = findMarkedIdentifier(code, "; // marker").propagatedType;
+    DartType t =
+        (await findMarkedIdentifier(code, "; // marker")).propagatedType;
     expect(typeProvider.intType.isSubtypeOf(t), isTrue);
     expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
-  void fail_mergePropagatedTypesAtJoinPoint_8() {
+  fail_mergePropagatedTypesAtJoinPoint_8() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In nested loops [breaks]s are unsafe for the purposes of
     // [isAbruptTerminationStatement].
     //
     // This is a combination of 6 and 7: we use an unlabeled [break]
     // like a continue for the outer loop / like a labeled [break] to
     // jump just above the [if].
     String code = r'''
 f() {
   var x = 0;
   var c = false;
   var d = true;
   while (d) {
     while (d) {
       if (c) {
         d = false;
       } else {
         x = '';
         c = true;
         break;
       }
       x; // marker
     }
   }
 }''';
-    DartType t = findMarkedIdentifier(code, "; // marker").propagatedType;
+    DartType t =
+        (await findMarkedIdentifier(code, "; // marker")).propagatedType;
     expect(typeProvider.intType.isSubtypeOf(t), isTrue);
     expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
-  void fail_propagatedReturnType_functionExpression() {
+  fail_propagatedReturnType_functionExpression() async {
     // TODO(scheglov) disabled because we don't resolve function expression
     String code = r'''
 main() {
   var v = (() {return 42;})();
 }''';
-    assertPropagatedAssignedType(
+    await assertPropagatedAssignedType(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
-  void test_as() {
+  test_as() async {
     Source source = addSource(r'''
 class A {
   bool get g => true;
 }
 A f(var p) {
   if ((p as A).g) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_assert() {
+  test_assert() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   assert (p is A);
   return p;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_assignment() {
+  test_assignment() async {
     Source source = addSource(r'''
 f() {
   var v;
   v = 0;
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_assignment_afterInitializer() {
+  test_assignment_afterInitializer() async {
     Source source = addSource(r'''
 f() {
   var v = 0;
   v = 1.0;
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_assignment_null() {
+  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);
-      assertNoErrors(source);
+      await assertNoErrors(source);
       verify([source]);
       unit = resolveCompilationUnit(source, library);
     }
     {
       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));
     }
   }
 
-  void test_CanvasElement_getContext() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(
         unit, code, "context", (node) => node is SimpleIdentifier);
     expect(resolutionMap.propagatedTypeForExpression(identifier).name,
         "CanvasRenderingContext2D");
   }
 
-  void test_forEach() {
+  test_forEach() async {
     String code = r'''
 main() {
   var list = <String> [];
   for (var e in list) {
     e;
   }
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
     }
   }
 
-  void test_forEach_async() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
     }
   }
 
-  void test_forEach_async_inheritedStream() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
     }
   }
 
-  void test_functionExpression_asInvocationArgument() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // 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
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(
         unit, code, "v;", (node) => node is SimpleIdentifier);
     expect(vIdentifier.propagatedType, same(stringType));
     expect(vIdentifier.staticType, same(typeProvider.dynamicType));
   }
 
-  void test_functionExpression_asInvocationArgument_fromInferredInvocation() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // 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));
   }
 
-  void
-      test_functionExpression_asInvocationArgument_functionExpressionInvocation() {
+  test_functionExpression_asInvocationArgument_functionExpressionInvocation() async {
     String code = r'''
 main() {
   (f(String value)) {} ((v) {
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // 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));
   }
 
-  void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // 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));
   }
 
-  void test_functionExpression_asInvocationArgument_notSubtypeOfStaticType() {
+  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);
-    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    await 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));
   }
 
-  void test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // 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));
   }
 
-  void test_Future_then() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // 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));
   }
 
-  void test_initializer() {
+  test_initializer() async {
     Source source = addSource(r'''
 f() {
   var v = 0;
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
     }
   }
 
-  void test_initializer_dereference() {
+  test_initializer_dereference() async {
     Source source = addSource(r'''
 f() {
   var v = 'String';
   v.
 }''');
     LibraryElement library = resolve2(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_initializer_hasStaticType() {
+  test_initializer_hasStaticType() async {
     Source source = addSource(r'''
 f() {
   int v = 0;
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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);
     }
   }
 
-  void test_initializer_hasStaticType_parameterized() {
+  test_initializer_hasStaticType_parameterized() async {
     Source source = addSource(r'''
 f() {
   List<int> v = <int>[];
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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);
       expect(variableName.propagatedType, isNull);
     }
     // Type of 'v' in reference.
     {
       ReturnStatement statement = statements[1] as ReturnStatement;
       SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
       expect(variableName.staticType, isNotNull);
       expect(variableName.propagatedType, isNull);
     }
   }
 
-  void test_initializer_null() {
+  test_initializer_null() async {
     String code = r'''
 main() {
   int v = null;
   return v; // marker
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
       LibraryElement library = resolve2(source);
-      assertNoErrors(source);
+      await assertNoErrors(source);
       verify([source]);
       unit = resolveCompilationUnit(source, library);
     }
     {
       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);
       expect(identifier.staticType, same(typeProvider.intType));
       expect(identifier.propagatedType, same(null));
     }
   }
 
-  void test_invocation_target_prefixed() {
+  test_invocation_target_prefixed() async {
     addNamedSource(
         '/helper.dart',
         '''
 library helper;
 int max(int x, int y) => 0;
 ''');
     String code = '''
 import 'helper.dart' as helper;
 main() {
   helper.max(10, 10); // marker
 }''';
     SimpleIdentifier methodName =
-        findMarkedIdentifier(code, "(10, 10); // marker");
+        await findMarkedIdentifier(code, "(10, 10); // marker");
     MethodInvocation methodInvoke = methodName.parent;
     expect(methodInvoke.methodName.staticElement, isNotNull);
     expect(methodInvoke.methodName.propagatedElement, isNull);
   }
 
-  void test_is_conditional() {
+  test_is_conditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is A) ? p : null;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_is_if() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // 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;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     // "p is A"
     {
       IsExpression isExpression = ifStatement.condition;
       SimpleIdentifier variableName = isExpression.expression;
       expect(variableName.propagatedType, isNull);
     }
     // "return p;"
     {
       ReturnStatement statement =
           (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
       SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
       expect(variableName.propagatedType, same(typeA));
     }
   }
 
-  void test_is_if_lessSpecific() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
 //    ClassDeclaration classA = (ClassDeclaration) unit.getDeclarations().get(0);
 //    InterfaceType typeA = classA.getElement().getType();
     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));
   }
 
-  void test_is_if_logicalAnd() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_is_postConditional() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_is_postIf() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_is_subclass() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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);
   }
 
-  void test_is_while() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_isNot_conditional() {
+  test_isNot_conditional() async {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is! A) ? null : p;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_isNot_if() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_isNot_if_logicalOr() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_isNot_postConditional() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_isNot_postIf() {
+  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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_issue20904BuggyTypePromotionAtIfJoin_5() {
+  test_issue20904BuggyTypePromotionAtIfJoin_5() async {
     // https://code.google.com/p/dart/issues/detail?id=20904
     //
     // This is not an example of the 20904 bug, but rather,
     // an example of something that one obvious fix changes inadvertently: we
     // want to avoid using type information from is-checks when it
     // loses precision. I can't see how to get a bad hint this way, since
     // it seems the propagated type is not used to generate hints when a
     // more precise type would cause no hint. For example, for code like the
     // following, when the propagated type of [x] is [A] -- as happens for the
     // fix these tests aim to warn against -- there is no warning for
 
     // calling a method defined on [B] but not [A] (there aren't any, but
     // pretend), but there is for calling a method not defined on either.
     // By not overriding the propagated type via an is-check that loses
     // precision, we get more precise completion under an is-check. However,
     // I can only imagine strange code would make use of this feature.
     //
     // Here the is-check improves precision, so we use it.
     String code = r'''
 class A {}
 class B extends A {}
 f() {
   var a = new A();
   var b = new B();
   b; // B
   if (a is B) {
     return a; // marker
   }
 }''';
-    DartType tB = findMarkedIdentifier(code, "; // B").propagatedType;
-    assertTypeOfMarkedExpression(code, null, tB);
+    DartType tB = (await findMarkedIdentifier(code, "; // B")).propagatedType;
+    await assertTypeOfMarkedExpression(code, null, tB);
   }
 
-  void test_issue20904BuggyTypePromotionAtIfJoin_6() {
+  test_issue20904BuggyTypePromotionAtIfJoin_6() async {
     // https://code.google.com/p/dart/issues/detail?id=20904
     //
     // The other half of the *_5() test.
     //
     // Here the is-check loses precision, so we don't use it.
     String code = r'''
 class A {}
 class B extends A {}
 f() {
   var b = new B();
   b; // B
   if (b is A) {
     return b; // marker
   }
 }''';
-    DartType tB = findMarkedIdentifier(code, "; // B").propagatedType;
-    assertTypeOfMarkedExpression(code, null, tB);
+    DartType tB = (await findMarkedIdentifier(code, "; // B")).propagatedType;
+    await assertTypeOfMarkedExpression(code, null, tB);
   }
 
-  void test_listLiteral_different() {
+  test_listLiteral_different() async {
     Source source = addSource(r'''
 f() {
   var v = [0, '1', 2];
   return v[2];
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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);
   }
 
-  void test_listLiteral_same() {
+  test_listLiteral_same() async {
     Source source = addSource(r'''
 f() {
   var v = [0, 1, 2];
   return v[2];
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_mapLiteral_different() {
+  test_mapLiteral_different() async {
     Source source = addSource(r'''
 f() {
   var v = {'0' : 0, 1 : '1', '2' : 2};
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_mapLiteral_same() {
+  test_mapLiteral_same() async {
     Source source = addSource(r'''
 f() {
   var v = {'a' : 0, 'b' : 1, 'c' : 2};
   return v;
 }''');
     LibraryElement library = resolve2(source);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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));
   }
 
-  void test_mergePropagatedTypes_afterIfThen_different() {
+  test_mergePropagatedTypes_afterIfThen_different() async {
     String code = r'''
 main() {
   var v = 0;
   if (v != null) {
     v = '';
   }
   return v;
 }''';
     {
-      SimpleIdentifier identifier = findMarkedIdentifier(code, "v;");
+      SimpleIdentifier identifier = await findMarkedIdentifier(code, "v;");
       expect(identifier.propagatedType, null);
     }
     {
-      SimpleIdentifier identifier = findMarkedIdentifier(code, "v = '';");
+      SimpleIdentifier identifier =
+          await findMarkedIdentifier(code, "v = '';");
       expect(identifier.propagatedType, typeProvider.stringType);
     }
   }
 
-  void test_mergePropagatedTypes_afterIfThen_same() {
-    assertTypeOfMarkedExpression(
+  test_mergePropagatedTypes_afterIfThen_same() async {
+    await assertTypeOfMarkedExpression(
         r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   }
   return v; // marker
 }''',
         null,
         typeProvider.intType);
   }
 
-  void test_mergePropagatedTypes_afterIfThenElse_different() {
-    assertTypeOfMarkedExpression(
+  test_mergePropagatedTypes_afterIfThenElse_different() async {
+    await assertTypeOfMarkedExpression(
         r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   } else {
     v = '3';
   }
   return v; // marker
 }''',
         null,
         null);
   }
 
-  void test_mergePropagatedTypes_afterIfThenElse_same() {
-    assertTypeOfMarkedExpression(
+  test_mergePropagatedTypes_afterIfThenElse_same() async {
+    await assertTypeOfMarkedExpression(
         r'''
 main() {
   var v = 1;
   if (v != null) {
     v = 2;
   } else {
     v = 3;
   }
   return v; // marker
 }''',
         null,
         typeProvider.intType);
   }
 
-  void test_mergePropagatedTypesAtJoinPoint_4() {
+  test_mergePropagatedTypesAtJoinPoint_4() async {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f5(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
     return y;
   }
   // Propagated type is [int] here: correct.
   return y; // marker
 }''',
         null,
         typeProvider.intType);
   }
 
-  void test_mutatedOutsideScope() {
+  test_mutatedOutsideScope() async {
     // https://code.google.com/p/dart/issues/detail?id=22732
     Source source = addSource(r'''
 class Base {
 }
 
 class Derived extends Base {
   get y => null;
 }
 
 class C {
   void f() {
     Base x = null;
     if (x is Derived) {
       print(x.y); // BAD
     }
     x = null;
   }
 }
 
 void g() {
   Base x = null;
   if (x is Derived) {
     print(x.y); // GOOD
   }
   x = null;
 }''');
-    assertNoErrors(source);
+    await assertNoErrors(source);
   }
 
-  void test_objectAccessInference_disabled_for_library_prefix() {
+  test_objectAccessInference_disabled_for_library_prefix() async {
     String name = 'hashCode';
     addNamedSource(
         '/helper.dart',
         '''
 library helper;
 dynamic get $name => 42;
 ''');
     String code = '''
 import 'helper.dart' as helper;
 main() {
   helper.$name; // marker
 }''';
 
-    SimpleIdentifier id = findMarkedIdentifier(code, "; // marker");
+    SimpleIdentifier id = await findMarkedIdentifier(code, "; // marker");
     PrefixedIdentifier prefixedId = id.parent;
     expect(id.staticType, typeProvider.dynamicType);
     expect(prefixedId.staticType, typeProvider.dynamicType);
   }
 
-  void test_objectAccessInference_disabled_for_local_getter() {
+  test_objectAccessInference_disabled_for_local_getter() async {
     String name = 'hashCode';
     String code = '''
 dynamic get $name => null;
 main() {
   $name; // marker
 }''';
 
-    SimpleIdentifier getter = findMarkedIdentifier(code, "; // marker");
+    SimpleIdentifier getter = await findMarkedIdentifier(code, "; // marker");
     expect(getter.staticType, typeProvider.dynamicType);
   }
 
-  void test_objectAccessInference_enabled_for_cascades() {
+  test_objectAccessInference_enabled_for_cascades() async {
     String name = 'hashCode';
     String code = '''
 main() {
   dynamic obj;
   obj..$name..$name; // marker
 }''';
-    PropertyAccess access = findMarkedIdentifier(code, "; // marker").parent;
+    PropertyAccess access =
+        (await findMarkedIdentifier(code, "; // marker")).parent;
     expect(access.staticType, typeProvider.dynamicType);
     expect(access.realTarget.staticType, typeProvider.dynamicType);
   }
 
-  void test_objectMethodInference_disabled_for_library_prefix() {
+  test_objectMethodInference_disabled_for_library_prefix() async {
     String name = 'toString';
     addNamedSource(
         '/helper.dart',
         '''
 library helper;
 dynamic $name = (int x) => x + 42');
 ''');
     String code = '''
 import 'helper.dart' as helper;
 main() {
   helper.$name(); // marker
 }''';
-    SimpleIdentifier methodName = findMarkedIdentifier(code, "(); // marker");
+    SimpleIdentifier methodName =
+        await findMarkedIdentifier(code, "(); // marker");
     MethodInvocation methodInvoke = methodName.parent;
     expect(methodName.staticType, typeProvider.dynamicType);
     expect(methodInvoke.staticType, typeProvider.dynamicType);
   }
 
-  void test_objectMethodInference_disabled_for_local_function() {
+  test_objectMethodInference_disabled_for_local_function() async {
     String name = 'toString';
     String code = '''
 main() {
   dynamic $name = () => null;
   $name(); // marker
 }''';
-    SimpleIdentifier identifier = findMarkedIdentifier(code, "$name = ");
+    SimpleIdentifier identifier = await findMarkedIdentifier(code, "$name = ");
     expect(identifier.staticType, typeProvider.dynamicType);
 
-    SimpleIdentifier methodName = findMarkedIdentifier(code, "(); // marker");
+    SimpleIdentifier methodName =
+        await findMarkedIdentifier(code, "(); // marker");
     MethodInvocation methodInvoke = methodName.parent;
     expect(methodName.staticType, typeProvider.dynamicType);
     expect(methodInvoke.staticType, typeProvider.dynamicType);
   }
 
-  void test_objectMethodInference_enabled_for_cascades() {
+  test_objectMethodInference_enabled_for_cascades() async {
     String name = 'toString';
     String code = '''
 main() {
   dynamic obj;
   obj..$name()..$name(); // marker
 }''';
-    SimpleIdentifier methodName = findMarkedIdentifier(code, "(); // marker");
+    SimpleIdentifier methodName =
+        await findMarkedIdentifier(code, "(); // marker");
     MethodInvocation methodInvoke = methodName.parent;
 
     expect(methodInvoke.staticType, typeProvider.dynamicType);
     expect(methodInvoke.realTarget.staticType, typeProvider.dynamicType);
   }
 
-  void test_objectMethodOnDynamicExpression_doubleEquals() {
+  test_objectMethodOnDynamicExpression_doubleEquals() async {
     // https://code.google.com/p/dart/issues/detail?id=20342
     //
     // This was not actually part of Issue 20342, since the spec specifies a
     // static type of [bool] for [==] comparison and the implementation
     // was already consistent with the spec there. But, it's another
     // [Object] method, so it's included here.
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f1(x) {
   var v = (x == x);
   return v; // marker
 }''',
         null,
         typeProvider.boolType);
   }
 
-  void test_objectMethodOnDynamicExpression_hashCode() {
+  test_objectMethodOnDynamicExpression_hashCode() async {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f1(x) {
   var v = x.hashCode;
   return v; // marker
 }''',
         null,
         typeProvider.intType);
   }
 
-  void test_objectMethodOnDynamicExpression_runtimeType() {
+  test_objectMethodOnDynamicExpression_runtimeType() async {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f1(x) {
   var v = x.runtimeType;
   return v; // marker
 }''',
         null,
         typeProvider.typeType);
   }
 
-  void test_objectMethodOnDynamicExpression_toString() {
+  test_objectMethodOnDynamicExpression_toString() async {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    assertTypeOfMarkedExpression(
+    await assertTypeOfMarkedExpression(
         r'''
 f1(x) {
   var v = x.toString();
   return v; // marker
 }''',
         null,
         typeProvider.stringType);
   }
 
-  void test_propagatedReturnType_localFunction() {
+  test_propagatedReturnType_localFunction() async {
     String code = r'''
 main() {
   f() => 42;
   var v = f();
 }''';
-    assertPropagatedAssignedType(
+    await assertPropagatedAssignedType(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
-  void test_query() {
+  test_query() async {
     Source source = addSource(r'''
 import 'dart:html';
 
 main() {
   var v1 = query('a');
   var v2 = query('A');
   var v3 = query('body:active');
   var v4 = query('button[foo="bar"]');
   var v5 = query('div.class');
   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);
-    assertNoErrors(source);
+    await assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     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,
@@ skipping 14 matching lines @@
         resolutionMap.propagatedTypeForExpression(elements[8]).name, "Element");
     expect(
         resolutionMap.propagatedTypeForExpression(elements[9]).name, "Element");
     expect(resolutionMap.propagatedTypeForExpression(elements[10]).name,
         "Element");
   }
 }
 
 @reflectiveTest
 class TypeProviderImplTest extends EngineTestCase {
-  void test_creation() {
+  test_creation() async {
     //
     // 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;
     InterfaceType numType = _classElement("num", objectType).type;
     InterfaceType doubleType = _classElement("double", numType).type;
@@ skipping 98 matching lines @@
   /**
    * The library scope in which types are to be resolved.
    */
   LibraryScope libraryScope;
 
   /**
    * The visitor used to resolve types needed to form the type hierarchy.
    */
   TypeResolverVisitor _visitor;
 
-  void fail_visitConstructorDeclaration() {
+  fail_visitConstructorDeclaration() async {
     fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
-  void fail_visitFunctionTypeAlias() {
+  fail_visitFunctionTypeAlias() async {
     fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
-  void fail_visitVariableDeclaration() {
+  fail_visitVariableDeclaration() async {
     fail("Not yet tested");
     ClassElement type = ElementFactory.classElement2("A");
     VariableDeclaration node = AstTestFactory.variableDeclaration("a");
     AstTestFactory
         .variableDeclarationList(null, AstTestFactory.typeName(type), [node]);
     //resolve(node);
     expect(node.name.staticType, same(type.type));
     _listener.assertNoErrors();
   }
 
   void setUp() {
     _listener = new GatheringErrorListener();
     MemoryResourceProvider resourceProvider = new MemoryResourceProvider();
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore(
         resourceProvider: resourceProvider);
     Source librarySource =
         new FileSource(resourceProvider.getFile("/lib.dart"));
     LibraryElementImpl element = new LibraryElementImpl.forNode(
         context, AstTestFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit =
         new CompilationUnitElementImpl("lib.dart");
     _typeProvider = new TestTypeProvider();
     libraryScope = new LibraryScope(element);
     _visitor = new TypeResolverVisitor(
         element, librarySource, _typeProvider, _listener,
         nameScope: libraryScope);
   }
 
-  void test_modeApi() {
+  test_modeApi() async {
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
 class C extends A with A implements A {
   A f = new A();
   A m() {
     A v1;
   }
 }
 A f([A p = const A()]) {
   A v2;
 }
@@ skipping 80 matching lines @@
       var vd = unit.declarations[2] as TopLevelVariableDeclaration;
       // The type is resolved.
       expect(vd.variables.type.toString(), 'A');
       // The initializer is not resolved.
       VariableDeclaration v = vd.variables.variables[0];
       var vi = v.initializer as InstanceCreationExpression;
       expect(vi.constructorName.type.type, isNull);
     }
   }
 
-  void test_modeLocal_noContext() {
+  test_modeLocal_noContext() async {
     CompilationUnit unit;
     _resolveTypeModeLocal(
         r'''
 class C {
   A f = new A();
   A m([A p = const A()]) {
     A v;
   }
 }
 A f([A p = const A()]) {
@@ skipping 93 matching lines @@
       var g = unit.declarations[3] as FunctionDeclaration;
       // The return type is not resolved.
       expect(g.returnType.type, isNull);
       // The body is resolved.
       var gb = g.functionExpression.body as ExpressionFunctionBody;
       var ge = gb.expression as InstanceCreationExpression;
       expect(ge.constructorName.type.type.toString(), 'A');
     }
   }
 
-  void test_modeLocal_withContext_bad_methodBody() {
+  test_modeLocal_withContext_bad_methodBody() async {
     expect(() {
       _resolveTypeModeLocal(
           r'''
 class C<T1> {
   A m<T2>() {
     T1 v1;
     T2 v2;
   }
 }
 ''', (CompilationUnit u) {
         var c = u.declarations[0] as ClassDeclaration;
         var m = c.members[0] as MethodDeclaration;
         var mb = m.body as BlockFunctionBody;
         return mb;
       });
     }, throwsStateError);
   }
 
-  void test_modeLocal_withContext_bad_topLevelVariable_declaration() {
+  test_modeLocal_withContext_bad_topLevelVariable_declaration() async {
     expect(() {
       _resolveTypeModeLocal(
           r'''
 var v = new A();
 ''', (CompilationUnit u) {
         var tlv = u.declarations[0] as TopLevelVariableDeclaration;
         return tlv.variables.variables[0];
       });
     }, throwsStateError);
   }
 
-  void test_modeLocal_withContext_bad_topLevelVariable_initializer() {
+  test_modeLocal_withContext_bad_topLevelVariable_initializer() async {
     expect(() {
       _resolveTypeModeLocal(
           r'''
 var v = new A();
 ''', (CompilationUnit u) {
         var tlv = u.declarations[0] as TopLevelVariableDeclaration;
         return tlv.variables.variables[0].initializer;
       });
     }, throwsStateError);
   }
 
-  void test_modeLocal_withContext_class() {
+  test_modeLocal_withContext_class() async {
     ClassDeclaration c;
     _resolveTypeModeLocal(
         r'''
 class C<T1> {
   A m<T2>() {
     T1 v1;
     T2 v2;
   }
 }
 ''', (CompilationUnit u) {
@@ skipping 14 matching lines @@
       expect(vd.variables.type.type.toString(), 'T1');
     }
 
     // The type of "v2" is resolved.
     {
       var vd = ms[1] as VariableDeclarationStatement;
       expect(vd.variables.type.type.toString(), 'T2');
     }
   }
 
-  void test_modeLocal_withContext_inClass_constructor() {
+  test_modeLocal_withContext_inClass_constructor() async {
     ConstructorDeclaration cc;
     _resolveTypeModeLocal(
         r'''
 class C<T> {
   C() {
     T v1;
   }
 }
 ''', (CompilationUnit u) {
       var c = u.declarations[0] as ClassDeclaration;
       cc = c.members[0] as ConstructorDeclaration;
       return cc;
     });
 
     var ccb = cc.body as BlockFunctionBody;
     var ccs = ccb.block.statements;
 
     // The type of "v" is resolved.
     {
       var vd = ccs[0] as VariableDeclarationStatement;
       expect(vd.variables.type.type.toString(), 'T');
     }
   }
 
-  void test_modeLocal_withContext_inClass_method() {
+  test_modeLocal_withContext_inClass_method() async {
     MethodDeclaration m;
     _resolveTypeModeLocal(
         r'''
 class C<T1> {
   A m<T2>() {
     T1 v1;
     T2 v2;
   }
 }
 ''', (CompilationUnit u) {
@@ skipping 14 matching lines @@
       expect(vd.variables.type.type.toString(), 'T1');
     }
 
     // The type of "v2" is resolved.
     {
       var vd = ms[1] as VariableDeclarationStatement;
       expect(vd.variables.type.type.toString(), 'T2');
     }
   }
 
-  void test_modeLocal_withContext_topLevelFunction() {
+  test_modeLocal_withContext_topLevelFunction() async {
     FunctionDeclaration f;
     _resolveTypeModeLocal(
         r'''
 A m<T>() {
   T v;
 }
 ''', (CompilationUnit u) {
       f = u.declarations[0] as FunctionDeclaration;
       return f;
     });
 
     // The return type of "f" is not resolved.
     expect(f.returnType.type, isNull);
 
     var fb = f.functionExpression.body as BlockFunctionBody;
     var fs = fb.block.statements;
 
     // The type of "v" is resolved.
     var vd = fs[0] as VariableDeclarationStatement;
     expect(vd.variables.type.type.toString(), 'T');
   }
 
-  void test_modeLocal_withContext_topLevelVariable() {
+  test_modeLocal_withContext_topLevelVariable() async {
     TopLevelVariableDeclaration v;
     _resolveTypeModeLocal(
         r'''
 A v = new A();
 ''', (CompilationUnit u) {
       v = u.declarations[0] as TopLevelVariableDeclaration;
       return v;
     });
 
     // The type of "v" is not resolved.
     expect(v.variables.type.type, isNull);
 
     // The type of "v" initializer is resolved.
     var vi = v.variables.variables[0].initializer as InstanceCreationExpression;
     expect(vi.constructorName.type.type.toString(), 'A');
   }
 
-  void test_visitCatchClause_exception() {
+  test_visitCatchClause_exception() async {
     // catch (e)
     CatchClause clause = AstTestFactory.catchClause("e");
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement =
         new LocalVariableElementImpl.forNode(exceptionParameter);
     _resolveCatchClause(clause, _typeProvider.dynamicType, null);
     _listener.assertNoErrors();
   }
 
-  void test_visitCatchClause_exception_stackTrace() {
+  test_visitCatchClause_exception_stackTrace() async {
     // catch (e, s)
     CatchClause clause = AstTestFactory.catchClause2("e", "s");
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement =
         new LocalVariableElementImpl.forNode(exceptionParameter);
     SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
     stackTraceParameter.staticElement =
         new LocalVariableElementImpl.forNode(stackTraceParameter);
     _resolveCatchClause(
         clause, _typeProvider.dynamicType, _typeProvider.stackTraceType);
     _listener.assertNoErrors();
   }
 
-  void test_visitCatchClause_on_exception() {
+  test_visitCatchClause_on_exception() async {
     // on E catch (e)
     ClassElement exceptionElement = ElementFactory.classElement2("E");
     TypeName exceptionType = AstTestFactory.typeName(exceptionElement);
     CatchClause clause = AstTestFactory.catchClause4(exceptionType, "e");
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement =
         new LocalVariableElementImpl.forNode(exceptionParameter);
     _resolveCatchClause(
         clause, exceptionElement.type, null, [exceptionElement]);
     _listener.assertNoErrors();
   }
 
-  void test_visitCatchClause_on_exception_stackTrace() {
+  test_visitCatchClause_on_exception_stackTrace() async {
     // on E catch (e, s)
     ClassElement exceptionElement = ElementFactory.classElement2("E");
     TypeName exceptionType = AstTestFactory.typeName(exceptionElement);
     (exceptionType.name as SimpleIdentifier).staticElement = exceptionElement;
     CatchClause clause = AstTestFactory.catchClause5(exceptionType, "e", "s");
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement =
         new LocalVariableElementImpl.forNode(exceptionParameter);
     SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
     stackTraceParameter.staticElement =
         new LocalVariableElementImpl.forNode(stackTraceParameter);
     _resolveCatchClause(clause, exceptionElement.type,
         _typeProvider.stackTraceType, [exceptionElement]);
     _listener.assertNoErrors();
   }
 
-  void test_visitClassDeclaration() {
+  test_visitClassDeclaration() async {
     // class A extends B with C implements D {}
     // class B {}
     // class C {}
     // class D {}
     ClassElement elementA = ElementFactory.classElement2("A");
     ClassElement elementB = ElementFactory.classElement2("B");
     ClassElement elementC = ElementFactory.classElement2("C");
     ClassElement elementD = ElementFactory.classElement2("D");
     ExtendsClause extendsClause =
         AstTestFactory.extendsClause(AstTestFactory.typeName(elementB));
     WithClause withClause =
         AstTestFactory.withClause([AstTestFactory.typeName(elementC)]);
     ImplementsClause implementsClause =
         AstTestFactory.implementsClause([AstTestFactory.typeName(elementD)]);
     ClassDeclaration declaration = AstTestFactory.classDeclaration(
         null, "A", null, extendsClause, withClause, implementsClause);
     declaration.name.staticElement = elementA;
     _resolveNode(declaration, [elementA, elementB, elementC, elementD]);
     expect(elementA.supertype, same(elementB.type));
     List<InterfaceType> mixins = elementA.mixins;
     expect(mixins, hasLength(1));
     expect(mixins[0], same(elementC.type));
     List<InterfaceType> interfaces = elementA.interfaces;
     expect(interfaces, hasLength(1));
     expect(interfaces[0], same(elementD.type));
     _listener.assertNoErrors();
   }
 
-  void test_visitClassDeclaration_instanceMemberCollidesWithClass() {
+  test_visitClassDeclaration_instanceMemberCollidesWithClass() async {
     // class A {}
     // class B extends A {
     //   void A() {}
     // }
     ClassElementImpl elementA = ElementFactory.classElement2("A");
     ClassElementImpl elementB = ElementFactory.classElement2("B");
     elementB.methods = <MethodElement>[
       ElementFactory.methodElement("A", VoidTypeImpl.instance)
     ];
     ExtendsClause extendsClause =
         AstTestFactory.extendsClause(AstTestFactory.typeName(elementA));
     ClassDeclaration declaration = AstTestFactory.classDeclaration(
         null, "B", null, extendsClause, null, null);
     declaration.name.staticElement = elementB;
     _resolveNode(declaration, [elementA, elementB]);
     expect(elementB.supertype, same(elementA.type));
     _listener.assertNoErrors();
   }
 
-  void test_visitClassTypeAlias() {
+  test_visitClassTypeAlias() async {
     // class A = B with C implements D;
     ClassElement elementA = ElementFactory.classElement2("A");
     ClassElement elementB = ElementFactory.classElement2("B");
     ClassElement elementC = ElementFactory.classElement2("C");
     ClassElement elementD = ElementFactory.classElement2("D");
     WithClause withClause =
         AstTestFactory.withClause([AstTestFactory.typeName(elementC)]);
     ImplementsClause implementsClause =
         AstTestFactory.implementsClause([AstTestFactory.typeName(elementD)]);
     ClassTypeAlias alias = AstTestFactory.classTypeAlias("A", null, null,
         AstTestFactory.typeName(elementB), withClause, implementsClause);
     alias.name.staticElement = elementA;
     _resolveNode(alias, [elementA, elementB, elementC, elementD]);
     expect(elementA.supertype, same(elementB.type));
     List<InterfaceType> mixins = elementA.mixins;
     expect(mixins, hasLength(1));
     expect(mixins[0], same(elementC.type));
     List<InterfaceType> interfaces = elementA.interfaces;
     expect(interfaces, hasLength(1));
     expect(interfaces[0], same(elementD.type));
     _listener.assertNoErrors();
   }
 
-  void test_visitClassTypeAlias_constructorWithOptionalParams_ignored() {
+  test_visitClassTypeAlias_constructorWithOptionalParams_ignored() async {
     // class T {}
     // class B {
     //   B.c1();
     //   B.c2([T a0]);
     //   B.c3({T a0});
     // }
     // class M {}
     // class C = B with M
     ClassElement classT = ElementFactory.classElement2('T', []);
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
@@ skipping 20 matching lines @@
     ConstructorElement constructor = classC.constructors[0];
     expect(constructor.isFactory, isFalse);
     expect(constructor.isSynthetic, isTrue);
     expect(constructor.name, 'c1');
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, isEmpty);
   }
 
-  void test_visitClassTypeAlias_constructorWithParams() {
+  test_visitClassTypeAlias_constructorWithParams() async {
     // class T {}
     // class B {
     //   B(T a0);
     // }
     // class M {}
     // class C = B with M
     ClassElement classT = ElementFactory.classElement2('T', []);
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
     ConstructorElementImpl constructorB =
         ElementFactory.constructorElement2(classB, '', [classT.type]);
@@ skipping 13 matching lines @@
     expect(constructor.name, '');
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(1));
     expect(constructor.parameters[0].type, equals(classT.type));
     expect(constructor.parameters[0].name,
         equals(constructorB.parameters[0].name));
   }
 
-  void test_visitClassTypeAlias_defaultConstructor() {
+  test_visitClassTypeAlias_defaultConstructor() async {
     // class B {}
     // class M {}
     // class C = B with M
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
     ConstructorElementImpl constructorB =
         ElementFactory.constructorElement2(classB, '', []);
     constructorB.setModifier(Modifier.SYNTHETIC, true);
     classB.constructors = [constructorB];
     ClassElement classM = ElementFactory.classElement2('M', []);
     WithClause withClause =
         AstTestFactory.withClause([AstTestFactory.typeName(classM, [])]);
     ClassElement classC = ElementFactory.classTypeAlias2('C', []);
     ClassTypeAlias alias = AstTestFactory.classTypeAlias(
         'C', null, null, AstTestFactory.typeName(classB, []), withClause, null);
     alias.name.staticElement = classC;
     _resolveNode(alias, [classB, classM, classC]);
     expect(classC.constructors, hasLength(1));
     ConstructorElement constructor = classC.constructors[0];
     expect(constructor.isFactory, isFalse);
     expect(constructor.isSynthetic, isTrue);
     expect(constructor.name, '');
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, isEmpty);
   }
 
-  void test_visitFieldFormalParameter_functionType() {
+  test_visitFieldFormalParameter_functionType() async {
     InterfaceType intType = _typeProvider.intType;
     TypeName intTypeName = AstTestFactory.typeName4("int");
     String innerParameterName = "a";
     SimpleFormalParameter parameter =
         AstTestFactory.simpleFormalParameter3(innerParameterName);
     parameter.identifier.staticElement =
         ElementFactory.requiredParameter(innerParameterName);
     String outerParameterName = "p";
     FormalParameter node = AstTestFactory.fieldFormalParameter(
         null,
         intTypeName,
         outerParameterName,
         AstTestFactory.formalParameterList([parameter]));
     node.identifier.staticElement =
         ElementFactory.requiredParameter(outerParameterName);
     DartType parameterType = _resolveFormalParameter(node, [intType.element]);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionType, FunctionType, parameterType);
     FunctionType functionType = parameterType as FunctionType;
     expect(functionType.returnType, same(intType));
     expect(functionType.parameters, hasLength(1));
     _listener.assertNoErrors();
   }
 
-  void test_visitFieldFormalParameter_noType() {
+  test_visitFieldFormalParameter_noType() async {
     String parameterName = "p";
     FormalParameter node =
         AstTestFactory.fieldFormalParameter(Keyword.VAR, null, parameterName);
     node.identifier.staticElement =
         ElementFactory.requiredParameter(parameterName);
     expect(_resolveFormalParameter(node), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
   }
 
-  void test_visitFieldFormalParameter_type() {
+  test_visitFieldFormalParameter_type() async {
     InterfaceType intType = _typeProvider.intType;
     TypeName intTypeName = AstTestFactory.typeName4("int");
     String parameterName = "p";
     FormalParameter node =
         AstTestFactory.fieldFormalParameter(null, intTypeName, parameterName);
     node.identifier.staticElement =
         ElementFactory.requiredParameter(parameterName);
     expect(_resolveFormalParameter(node, [intType.element]), same(intType));
     _listener.assertNoErrors();
   }
 
-  void test_visitFunctionDeclaration() {
+  test_visitFunctionDeclaration() async {
     // R f(P p) {}
     // class R {}
     // class P {}
     ClassElement elementR = ElementFactory.classElement2('R');
     ClassElement elementP = ElementFactory.classElement2('P');
     FunctionElement elementF = ElementFactory.functionElement('f');
     FunctionDeclaration declaration = AstTestFactory.functionDeclaration(
         AstTestFactory.typeName4('R'),
         null,
         'f',
         AstTestFactory.functionExpression2(
             AstTestFactory.formalParameterList([
               AstTestFactory.simpleFormalParameter4(
                   AstTestFactory.typeName4('P'), 'p')
             ]),
             null));
     declaration.name.staticElement = elementF;
     _resolveNode(declaration, [elementR, elementP]);
     expect(declaration.returnType.type, elementR.type);
     SimpleFormalParameter parameter =
         declaration.functionExpression.parameters.parameters[0];
     expect(parameter.type.type, elementP.type);
     _listener.assertNoErrors();
   }
 
-  void test_visitFunctionDeclaration_typeParameter() {
+  test_visitFunctionDeclaration_typeParameter() async {
     // E f<E>(E e) {}
     TypeParameterElement elementE = ElementFactory.typeParameterElement('E');
     FunctionElementImpl elementF = ElementFactory.functionElement('f');
     elementF.typeParameters = <TypeParameterElement>[elementE];
     FunctionDeclaration declaration = AstTestFactory.functionDeclaration(
         AstTestFactory.typeName4('E'),
         null,
         'f',
         AstTestFactory.functionExpression2(
             AstTestFactory.formalParameterList([
               AstTestFactory.simpleFormalParameter4(
                   AstTestFactory.typeName4('E'), 'e')
             ]),
             null));
     declaration.name.staticElement = elementF;
     _resolveNode(declaration, []);
     expect(declaration.returnType.type, elementE.type);
     SimpleFormalParameter parameter =
         declaration.functionExpression.parameters.parameters[0];
     expect(parameter.type.type, elementE.type);
     _listener.assertNoErrors();
   }
 
-  void test_visitFunctionTypedFormalParameter() {
+  test_visitFunctionTypedFormalParameter() async {
     // R f(R g(P p)) {}
     // class R {}
     // class P {}
     ClassElement elementR = ElementFactory.classElement2('R');
     ClassElement elementP = ElementFactory.classElement2('P');
     FunctionElement elementF = ElementFactory.functionElement('f');
     ParameterElementImpl requiredParameter =
         ElementFactory.requiredParameter('p');
     FunctionTypedFormalParameter parameterDeclaration = AstTestFactory
         .functionTypedFormalParameter(AstTestFactory.typeName4('R'), 'g', [
@@ skipping 10 matching lines @@
     _resolveNode(declaration, [elementR, elementP]);
     expect(declaration.returnType.type, elementR.type);
     FunctionTypedFormalParameter parameter =
         declaration.functionExpression.parameters.parameters[0];
     expect(parameter.returnType.type, elementR.type);
     SimpleFormalParameter innerParameter = parameter.parameters.parameters[0];
     expect(innerParameter.type.type, elementP.type);
     _listener.assertNoErrors();
   }
 
-  void test_visitFunctionTypedFormalParameter_typeParameter() {
+  test_visitFunctionTypedFormalParameter_typeParameter() async {
     // R f(R g<E>(E e)) {}
     // class R {}
     ClassElement elementR = ElementFactory.classElement2('R');
     TypeParameterElement elementE = ElementFactory.typeParameterElement('E');
     FunctionElement elementF = ElementFactory.functionElement('f');
     ParameterElementImpl requiredParameter =
         ElementFactory.requiredParameter('g');
     requiredParameter.typeParameters = <TypeParameterElement>[elementE];
     FunctionTypedFormalParameter parameterDeclaration = AstTestFactory
         .functionTypedFormalParameter(AstTestFactory.typeName4('R'), 'g', [
@@ skipping 10 matching lines @@
     _resolveNode(declaration, [elementR]);
     expect(declaration.returnType.type, elementR.type);
     FunctionTypedFormalParameter parameter =
         declaration.functionExpression.parameters.parameters[0];
     expect(parameter.returnType.type, elementR.type);
     SimpleFormalParameter innerParameter = parameter.parameters.parameters[0];
     expect(innerParameter.type.type, elementE.type);
     _listener.assertNoErrors();
   }
 
-  void test_visitMethodDeclaration() {
+  test_visitMethodDeclaration() async {
     // class A {
     //   R m(P p) {}
     // }
     // class R {}
     // class P {}
     ClassElementImpl elementA = ElementFactory.classElement2('A');
     ClassElement elementR = ElementFactory.classElement2('R');
     ClassElement elementP = ElementFactory.classElement2('P');
     MethodElement elementM = ElementFactory.methodElement('m', null);
     elementA.methods = <MethodElement>[elementM];
     MethodDeclaration declaration = AstTestFactory.methodDeclaration(
         null,
         AstTestFactory.typeName4('R'),
         null,
         null,
         AstTestFactory.identifier3('m'),
         AstTestFactory.formalParameterList([
           AstTestFactory.simpleFormalParameter4(
               AstTestFactory.typeName4('P'), 'p')
         ]));
     declaration.name.staticElement = elementM;
     _resolveNode(declaration, [elementA, elementR, elementP]);
     expect(declaration.returnType.type, elementR.type);
     SimpleFormalParameter parameter = declaration.parameters.parameters[0];
     expect(parameter.type.type, elementP.type);
     _listener.assertNoErrors();
   }
 
-  void test_visitMethodDeclaration_typeParameter() {
+  test_visitMethodDeclaration_typeParameter() async {
     // class A {
     //   E m<E>(E e) {}
     // }
     ClassElementImpl elementA = ElementFactory.classElement2('A');
     TypeParameterElement elementE = ElementFactory.typeParameterElement('E');
     MethodElementImpl elementM = ElementFactory.methodElement('m', null);
     elementM.typeParameters = <TypeParameterElement>[elementE];
     elementA.methods = <MethodElement>[elementM];
     MethodDeclaration declaration = AstTestFactory.methodDeclaration(
         null,
         AstTestFactory.typeName4('E'),
         null,
         null,
         AstTestFactory.identifier3('m'),
         AstTestFactory.formalParameterList([
           AstTestFactory.simpleFormalParameter4(
               AstTestFactory.typeName4('E'), 'e')
         ]));
     declaration.name.staticElement = elementM;
     _resolveNode(declaration, [elementA]);
     expect(declaration.returnType.type, elementE.type);
     SimpleFormalParameter parameter = declaration.parameters.parameters[0];
     expect(parameter.type.type, elementE.type);
     _listener.assertNoErrors();
   }
 
-  void test_visitSimpleFormalParameter_noType() {
+  test_visitSimpleFormalParameter_noType() async {
     // p
     FormalParameter node = AstTestFactory.simpleFormalParameter3("p");
     node.identifier.staticElement =
         new ParameterElementImpl.forNode(AstTestFactory.identifier3("p"));
     expect(_resolveFormalParameter(node), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
   }
 
-  void test_visitSimpleFormalParameter_type() {
+  test_visitSimpleFormalParameter_type() async {
     // int p
     InterfaceType intType = _typeProvider.intType;
     ClassElement intElement = intType.element;
     FormalParameter node = AstTestFactory.simpleFormalParameter4(
         AstTestFactory.typeName(intElement), "p");
     SimpleIdentifier identifier = node.identifier;
     ParameterElementImpl element = new ParameterElementImpl.forNode(identifier);
     identifier.staticElement = element;
     expect(_resolveFormalParameter(node, [intElement]), same(intType));
     _listener.assertNoErrors();
   }
 
-  void test_visitTypeName_noParameters_noArguments() {
+  test_visitTypeName_noParameters_noArguments() async {
     ClassElement classA = ElementFactory.classElement2("A");
     TypeName typeName = AstTestFactory.typeName(classA);
     typeName.type = null;
     _resolveNode(typeName, [classA]);
     expect(typeName.type, same(classA.type));
     _listener.assertNoErrors();
   }
 
-  void test_visitTypeName_noParameters_noArguments_undefined() {
+  test_visitTypeName_noParameters_noArguments_undefined() async {
     SimpleIdentifier id = AstTestFactory.identifier3("unknown")
       ..staticElement = new _StaleElement();
     TypeName typeName = astFactory.typeName(id, null);
     _resolveNode(typeName, []);
     expect(typeName.type, UndefinedTypeImpl.instance);
     expect(typeName.name.staticElement, null);
     _listener.assertErrorsWithCodes([StaticWarningCode.UNDEFINED_CLASS]);
   }
 
-  void test_visitTypeName_parameters_arguments() {
+  test_visitTypeName_parameters_arguments() async {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     ClassElement classB = ElementFactory.classElement2("B");
     TypeName typeName =
         AstTestFactory.typeName(classA, [AstTestFactory.typeName(classB)]);
     typeName.type = null;
     _resolveNode(typeName, [classA, classB]);
     InterfaceType resultType = typeName.type as InterfaceType;
     expect(resultType.element, same(classA));
     List<DartType> resultArguments = resultType.typeArguments;
     expect(resultArguments, hasLength(1));
     expect(resultArguments[0], same(classB.type));
     _listener.assertNoErrors();
   }
 
-  void test_visitTypeName_parameters_noArguments() {
+  test_visitTypeName_parameters_noArguments() async {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     TypeName typeName = AstTestFactory.typeName(classA);
     typeName.type = null;
     _resolveNode(typeName, [classA]);
     InterfaceType resultType = typeName.type as InterfaceType;
     expect(resultType.element, same(classA));
     List<DartType> resultArguments = resultType.typeArguments;
     expect(resultArguments, hasLength(1));
     expect(resultArguments[0], same(DynamicTypeImpl.instance));
     _listener.assertNoErrors();
   }
 
-  void test_visitTypeName_prefixed_noParameters_noArguments_undefined() {
+  test_visitTypeName_prefixed_noParameters_noArguments_undefined() async {
     SimpleIdentifier prefix = AstTestFactory.identifier3("unknownPrefix")
       ..staticElement = new _StaleElement();
     SimpleIdentifier suffix = AstTestFactory.identifier3("unknownSuffix")
       ..staticElement = new _StaleElement();
     TypeName typeName =
         astFactory.typeName(AstTestFactory.identifier(prefix, suffix), null);
     _resolveNode(typeName, []);
     expect(typeName.type, UndefinedTypeImpl.instance);
     expect(prefix.staticElement, null);
     expect(suffix.staticElement, null);
     _listener.assertErrorsWithCodes([StaticWarningCode.UNDEFINED_CLASS]);
   }
 
-  void test_visitTypeName_void() {
+  test_visitTypeName_void() async {
     ClassElement classA = ElementFactory.classElement2("A");
     TypeName typeName = AstTestFactory.typeName4("void");
     _resolveNode(typeName, [classA]);
     expect(typeName.type, same(VoidTypeImpl.instance));
     _listener.assertNoErrors();
   }
 
   /**
    * Analyze the given catch clause and assert that the types of the parameters have been set to the
    * given types. The types can be null if the catch clause does not have the corresponding
@@ skipping 108 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";
 }