Use async/await in all analysis domain tests.

pkg/analysis_server/test/analysis/notification_highlights_test2.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 test.analysis.notification.highlights2;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/constants.dart';
@@ skipping 91 matching lines @@
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     server.options.useAnalysisHighlight2 = true;
     createProject();
   }
 
-  test_ANNOTATION_hasArguments() {
+  test_ANNOTATION_hasArguments() async {
     addTestFile('''
 class AAA {
   const AAA(a, b, c);
 }
 @AAA(1, 2, 3) main() {}
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA(', '@AAA('.length);
-      assertHasRegion(HighlightRegionType.ANNOTATION, ') main', ')'.length);
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA(', '@AAA('.length);
+    assertHasRegion(HighlightRegionType.ANNOTATION, ') main', ')'.length);
   }
 
-  test_ANNOTATION_noArguments() {
+  test_ANNOTATION_noArguments() async {
     addTestFile('''
 const AAA = 42;
 @AAA main() {}
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA');
   }
 
-  test_BUILT_IN_abstract() {
+  test_BUILT_IN_abstract() async {
     addTestFile('''
 abstract class A {};
 abstract class B = Object with A;
 main() {
   var abstract = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class A');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class B');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'abstract = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class A');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class B');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'abstract = 42');
   }
 
-  test_BUILT_IN_as() {
+  test_BUILT_IN_as() async {
     addTestFile('''
 import 'dart:math' as math;
 main() {
   p as int;
   var as = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'as math');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'as int');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'as = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'as math');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'as int');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'as = 42');
   }
 
-  test_BUILT_IN_async() {
+  test_BUILT_IN_async() async {
     addTestFile('''
 fa() async {}
 fb() async* {}
 main() {
   bool async = false;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async');
-      assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async*');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'async = false');
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async');
+    assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async*');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'async = false');
   }
 
-  test_BUILT_IN_await() {
+  test_BUILT_IN_await() async {
     addTestFile('''
 main() async {
   await 42;
   await for (var item in []) {
     print(item);
   }
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'await 42');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'await for');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'await 42');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'await for');
   }
 
-  test_BUILT_IN_deferred() {
+  test_BUILT_IN_deferred() async {
     addTestFile('''
 import 'dart:math' deferred as math;
 main() {
   var deferred = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'deferred as math');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'deferred = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'deferred as math');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'deferred = 42');
   }
 
-  test_BUILT_IN_export() {
+  test_BUILT_IN_export() async {
     addTestFile('''
 export "dart:math";
 main() {
   var export = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'export "dart:');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'export = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'export "dart:');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'export = 42');
   }
 
-  test_BUILT_IN_external() {
+  test_BUILT_IN_external() async {
     addTestFile('''
 class A {
   external A();
   external aaa();
 }
 external main() {
   var external = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'external A()');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'external aaa()');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'external main()');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'external = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'external A()');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'external aaa()');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'external main()');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'external = 42');
   }
 
-  test_BUILT_IN_factory() {
+  test_BUILT_IN_factory() async {
     addTestFile('''
 class A {
   factory A() => null;
 }
 main() {
   var factory = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'factory A()');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'factory = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'factory A()');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'factory = 42');
   }
 
-  test_BUILT_IN_get() {
+  test_BUILT_IN_get() async {
     addTestFile('''
 get aaa => 1;
 class A {
   get bbb => 2;
 }
 main() {
   var get = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'get aaa =>');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'get bbb =>');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'get = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'get aaa =>');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'get bbb =>');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'get = 42');
   }
 
-  test_BUILT_IN_hide() {
+  test_BUILT_IN_hide() async {
     addTestFile('''
 import 'foo.dart' hide Foo;
 main() {
   var hide = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'hide Foo');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'hide = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'hide Foo');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'hide = 42');
   }
 
-  test_BUILT_IN_implements() {
+  test_BUILT_IN_implements() async {
     addTestFile('''
 class A {}
 class B implements A {}
 main() {
   var implements = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'implements A {}');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'implements = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'implements A {}');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'implements = 42');
   }
 
-  test_BUILT_IN_import() {
+  test_BUILT_IN_import() async {
     addTestFile('''
 import "foo.dart";
 main() {
   var import = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'import "');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'import = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'import "');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'import = 42');
   }
 
-  test_BUILT_IN_library() {
+  test_BUILT_IN_library() async {
     addTestFile('''
 library lib;
 main() {
   var library = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'library lib;');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'library = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'library lib;');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'library = 42');
   }
 
-  test_BUILT_IN_native() {
+  test_BUILT_IN_native() async {
     addTestFile('''
 class A native "A_native" {}
 class B {
   bbb() native "bbb_native";
 }
 main() {
   var native = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'native "A_');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'native "bbb_');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'native = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'native "A_');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'native "bbb_');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'native = 42');
   }
 
-  test_BUILT_IN_on() {
+  test_BUILT_IN_on() async {
     addTestFile('''
 main() {
   try {
   } on int catch (e) {
   }
   var on = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'on int');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'on = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'on int');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'on = 42');
   }
 
-  test_BUILT_IN_operator() {
+  test_BUILT_IN_operator() async {
     addTestFile('''
 class A {
   operator +(x) => null;
 }
 main() {
   var operator = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'operator +(');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'operator = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'operator +(');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'operator = 42');
   }
 
-  test_BUILT_IN_part() {
+  test_BUILT_IN_part() async {
     addTestFile('''
 part "my_part.dart";
 main() {
   var part = 42;
 }''');
     addFile('/project/bin/my_part.dart', 'part of lib;');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'part "my_');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'part "my_');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 42');
   }
 
-  test_BUILT_IN_partOf() {
+  test_BUILT_IN_partOf() async {
     addTestFile('''
 part of lib;
 main() {
   var part = 1;
   var of = 2;
 }''');
     _addLibraryForTestPart();
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.BUILT_IN, 'part of', 'part of'.length);
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 1');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'of = 2');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'part of', 'part of'.length);
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 1');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'of = 2');
   }
 
-  test_BUILT_IN_set() {
+  test_BUILT_IN_set() async {
     addTestFile('''
 set aaa(x) {}
 class A
   set bbb(x) {}
 }
 main() {
   var set = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'set aaa(');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'set bbb(');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'set = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'set aaa(');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'set bbb(');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'set = 42');
   }
 
-  test_BUILT_IN_show() {
+  test_BUILT_IN_show() async {
     addTestFile('''
 import 'foo.dart' show Foo;
 main() {
   var show = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'show Foo');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'show = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'show Foo');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'show = 42');
   }
 
-  test_BUILT_IN_static() {
+  test_BUILT_IN_static() async {
     addTestFile('''
 class A {
   static aaa;
   static bbb() {}
 }
 main() {
   var static = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'static aaa;');
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'static bbb()');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'static = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'static aaa;');
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'static bbb()');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'static = 42');
   }
 
-  test_BUILT_IN_sync() {
+  test_BUILT_IN_sync() async {
     addTestFile('''
 fa() sync {}
 fb() sync* {}
 main() {
   bool sync = false;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync');
-      assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync*');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'sync = false');
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync');
+    assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync*');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'sync = false');
   }
 
-  test_BUILT_IN_typedef() {
+  test_BUILT_IN_typedef() async {
     addTestFile('''
 typedef A();
 main() {
   var typedef = 42;
 }''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'typedef A();');
-      assertNoRegion(HighlightRegionType.BUILT_IN, 'typedef = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'typedef A();');
+    assertNoRegion(HighlightRegionType.BUILT_IN, 'typedef = 42');
   }
 
-  test_BUILT_IN_yield() {
+  test_BUILT_IN_yield() async {
     addTestFile('''
 main() async* {
   yield 42;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.BUILT_IN, 'yield 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.BUILT_IN, 'yield 42');
   }
 
-  test_BUILT_IN_yieldStar() {
+  test_BUILT_IN_yieldStar() async {
     addTestFile('''
 main() async* {
   yield* [];
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.BUILT_IN, 'yield*');
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.BUILT_IN, 'yield*');
   }
 
-  test_CLASS() {
+  test_CLASS() async {
     addTestFile('''
 class AAA {}
 AAA aaa;
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.CLASS, 'AAA {}');
-      assertHasRegion(HighlightRegionType.CLASS, 'AAA aaa');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.CLASS, 'AAA {}');
+    assertHasRegion(HighlightRegionType.CLASS, 'AAA aaa');
   }
 
-  test_CLASS_notDynamic() {
+  test_CLASS_notDynamic() async {
     addTestFile('''
 dynamic f() {}
 ''');
-    return prepareHighlights().then((_) {
-      assertNoRegion(HighlightRegionType.CLASS, 'dynamic f()');
-    });
+    await prepareHighlights();
+    assertNoRegion(HighlightRegionType.CLASS, 'dynamic f()');
   }
 
-  test_CLASS_notVoid() {
+  test_CLASS_notVoid() async {
     addTestFile('''
 void f() {}
 ''');
-    return prepareHighlights().then((_) {
-      assertNoRegion(HighlightRegionType.CLASS, 'void f()');
-    });
+    await prepareHighlights();
+    assertNoRegion(HighlightRegionType.CLASS, 'void f()');
   }
 
-  test_COMMENT() {
+  test_COMMENT() async {
     addTestFile('''
 /**
  * documentation comment
- */ 
+ */
 void main() {
   // end-of-line comment
   my_function(1);
 }
 
 void my_function(String a) {
  /* block comment */
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.COMMENT_DOCUMENTATION, '/**', 32);
-      assertHasRegion(HighlightRegionType.COMMENT_END_OF_LINE, '//', 22);
-      assertHasRegion(HighlightRegionType.COMMENT_BLOCK, '/* b', 19);
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.COMMENT_DOCUMENTATION, '/**', 32);
+    assertHasRegion(HighlightRegionType.COMMENT_END_OF_LINE, '//', 22);
+    assertHasRegion(HighlightRegionType.COMMENT_BLOCK, '/* b', 19);
   }
 
-  test_CONSTRUCTOR() {
+  test_CONSTRUCTOR() async {
     addTestFile('''
 class AAA {
   AAA() {}
   AAA.name(p) {}
 }
 main() {
   new AAA();
   new AAA.name(42);
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(p)');
-      assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(42)');
-      assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA() {}');
-      assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA();');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(p)');
+    assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(42)');
+    assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA() {}');
+    assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA();');
   }
 
-  test_DIRECTIVE() {
+  test_DIRECTIVE() async {
     addTestFile('''
 library lib;
 import 'dart:math';
 export 'dart:math';
 part 'part.dart';
 ''');
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.DIRECTIVE, "library lib;");
-      assertHasStringRegion(
-          HighlightRegionType.DIRECTIVE, "import 'dart:math';");
-      assertHasStringRegion(
-          HighlightRegionType.DIRECTIVE, "export 'dart:math';");
-      assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part 'part.dart';");
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.DIRECTIVE, "library lib;");
+    assertHasStringRegion(HighlightRegionType.DIRECTIVE, "import 'dart:math';");
+    assertHasStringRegion(HighlightRegionType.DIRECTIVE, "export 'dart:math';");
+    assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part 'part.dart';");
   }
 
-  test_DIRECTIVE_partOf() {
+  test_DIRECTIVE_partOf() async {
     addTestFile('''
 part of lib;
 ''');
     _addLibraryForTestPart();
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part of lib;");
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part of lib;");
   }
 
-  test_DYNAMIC_LOCAL_VARIABLE() {
+  test_DYNAMIC_LOCAL_VARIABLE() async {
     addTestFile('''
 f() {}
 main(p) {
   var v = f();
   v;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_DECLARATION, 'v = f()');
-      assertHasRegion(
-          HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_REFERENCE, 'v;');
-    });
+    await prepareHighlights();
+    assertHasRegion(
+        HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_DECLARATION, 'v = f()');
+    assertHasRegion(HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_REFERENCE, 'v;');
   }
 
-  test_DYNAMIC_PARAMETER() {
+  test_DYNAMIC_PARAMETER() async {
     addTestFile('''
 main(p) {
   print(p);
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.DYNAMIC_PARAMETER_DECLARATION, 'p)');
-      assertHasRegion(HighlightRegionType.DYNAMIC_PARAMETER_REFERENCE, 'p);');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.DYNAMIC_PARAMETER_DECLARATION, 'p)');
+    assertHasRegion(HighlightRegionType.DYNAMIC_PARAMETER_REFERENCE, 'p);');
   }
 
-  test_DYNAMIC_VARIABLE_field() {
+  test_DYNAMIC_VARIABLE_field() async {
     addTestFile('''
 class A {
   var f;
   m() {
     f = 1;
   }
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'f;');
-      assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'f = 1');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'f;');
+    assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'f = 1');
   }
 
-  test_ENUM() {
+  test_ENUM() async {
     addTestFile('''
 enum MyEnum {A, B, C}
 MyEnum value;
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.ENUM, 'MyEnum {');
-      assertHasRegion(HighlightRegionType.ENUM, 'MyEnum value;');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.ENUM, 'MyEnum {');
+    assertHasRegion(HighlightRegionType.ENUM, 'MyEnum value;');
   }
 
-  test_ENUM_CONSTANT() {
+  test_ENUM_CONSTANT() async {
     addTestFile('''
 enum MyEnum {AAA, BBB}
 main() {
   print(MyEnum.AAA);
   print(MyEnum.BBB);
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA, ');
-      assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB}');
-      assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA);');
-      assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB);');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA, ');
+    assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB}');
+    assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA);');
+    assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB);');
   }
 
-  test_FUNCTION_TYPE_ALIAS() {
+  test_FUNCTION_TYPE_ALIAS() async {
     addTestFile('''
 typedef FFF(p);
 main(FFF fff) {
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF(p)');
-      assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF fff)');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF(p)');
+    assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF fff)');
   }
 
-  test_GETTER() {
+  test_GETTER() async {
     addTestFile('''
 get aaa => null;
 class A {
   get bbb => null;
   static get ccc => null;
 }
 main(A a) {
   aaa;
   a.bbb;
   A.ccc;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.TOP_LEVEL_GETTER_DECLARATION, 'aaa => null');
-      assertHasRegion(
-          HighlightRegionType.INSTANCE_GETTER_DECLARATION, 'bbb => null');
-      assertHasRegion(
-          HighlightRegionType.STATIC_GETTER_DECLARATION, 'ccc => null');
-      assertHasRegion(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'aaa;');
-      assertHasRegion(HighlightRegionType.INSTANCE_GETTER_REFERENCE, 'bbb;');
-      assertHasRegion(HighlightRegionType.STATIC_GETTER_REFERENCE, 'ccc;');
-    });
+    await prepareHighlights();
+    assertHasRegion(
+        HighlightRegionType.TOP_LEVEL_GETTER_DECLARATION, 'aaa => null');
+    assertHasRegion(
+        HighlightRegionType.INSTANCE_GETTER_DECLARATION, 'bbb => null');
+    assertHasRegion(
+        HighlightRegionType.STATIC_GETTER_DECLARATION, 'ccc => null');
+    assertHasRegion(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'aaa;');
+    assertHasRegion(HighlightRegionType.INSTANCE_GETTER_REFERENCE, 'bbb;');
+    assertHasRegion(HighlightRegionType.STATIC_GETTER_REFERENCE, 'ccc;');
   }
 
-  test_IDENTIFIER_DEFAULT() {
+  test_IDENTIFIER_DEFAULT() async {
     addTestFile('''
 main() {
   aaa = 42;
   bbb(84);
   CCC ccc;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'aaa = 42');
-      assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'bbb(84)');
-      assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'CCC ccc');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'aaa = 42');
+    assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'bbb(84)');
+    assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'CCC ccc');
   }
 
-  test_IMPORT_PREFIX() {
+  test_IMPORT_PREFIX() async {
     addTestFile('''
 import 'dart:math' as ma;
 main() {
   ma.max(1, 2);
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma;');
-      assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma.max');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma;');
+    assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma.max');
   }
 
-  test_INSTANCE_FIELD() {
+  test_INSTANCE_FIELD() async {
     addTestFile('''
 class A {
   int aaa = 1;
   int bbb = 2;
   A([this.bbb = 3]);
 }
 main(A a) {
   a.aaa = 4;
   a.bbb = 5;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'aaa = 1');
-      assertHasRegion(
-          HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'bbb = 2');
-      assertHasRegion(HighlightRegionType.INSTANCE_FIELD_REFERENCE, 'bbb = 3');
-      assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'aaa = 4');
-      assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'bbb = 5');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'aaa = 1');
+    assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'bbb = 2');
+    assertHasRegion(HighlightRegionType.INSTANCE_FIELD_REFERENCE, 'bbb = 3');
+    assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'aaa = 4');
+    assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'bbb = 5');
   }
 
-  test_INSTANCE_FIELD_dynamic() {
+  test_INSTANCE_FIELD_dynamic() async {
     addTestFile('''
 class A {
   var f;
   A(this.f);
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'f;');
-      assertHasRegion(HighlightRegionType.INSTANCE_FIELD_REFERENCE, 'f);');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'f;');
+    assertHasRegion(HighlightRegionType.INSTANCE_FIELD_REFERENCE, 'f);');
   }
 
-  test_KEYWORD() {
+  test_KEYWORD() async {
     addTestFile('''
 main() {
   assert(true);
   for (;;) break;
   switch (0) {
     case 0: break;
     default: break;
   }
   try {} catch (e) {}
   const v1 = 0;
@@ skipping 12 matching lines @@
 }
 class A {}
 class B extends A {
   B() : super();
   m() {
     return this;
   }
 }
 class C = Object with A;
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.KEYWORD, 'assert(true)');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'for (;;)');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'for (var v4 in');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'break;');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'case 0:');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'catch (e) {}');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'class A {}');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'const v1');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'continue;');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'default:');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'do {} while');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'if (true)');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'false;');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'final v3 =');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'finally {}');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'in []');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'is int');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'new A();');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'rethrow;');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'return this');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'super();');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'switch (0)');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'this;');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'true;');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'try {');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'while (true) {}');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'while (true);');
-      assertHasRegion(HighlightRegionType.KEYWORD, 'with A;');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.KEYWORD, 'assert(true)');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'for (;;)');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'for (var v4 in');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'break;');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'case 0:');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'catch (e) {}');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'class A {}');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'const v1');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'continue;');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'default:');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'do {} while');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'if (true)');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'false;');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'final v3 =');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'finally {}');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'in []');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'is int');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'new A();');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'rethrow;');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'return this');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'super();');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'switch (0)');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'this;');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'true;');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'try {');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'while (true) {}');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'while (true);');
+    assertHasRegion(HighlightRegionType.KEYWORD, 'with A;');
   }
 
-  test_KEYWORD_void() {
+  test_KEYWORD_void() async {
     addTestFile('''
 void main() {
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.KEYWORD, 'void main()');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.KEYWORD, 'void main()');
   }
 
-  test_LABEL() {
+  test_LABEL() async {
     addTestFile('''
 main() {
 myLabel:
   while (true) {
     break myLabel;
   }
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.LABEL, 'myLabel:');
-      assertHasRegion(HighlightRegionType.LABEL, 'myLabel;');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.LABEL, 'myLabel:');
+    assertHasRegion(HighlightRegionType.LABEL, 'myLabel;');
   }
 
-  test_LIBRARY_NAME_libraryDirective() {
+  test_LIBRARY_NAME_libraryDirective() async {
     addTestFile('''
 library my.lib.name;
 ''');
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.LIBRARY_NAME, 'my.lib.name');
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.LIBRARY_NAME, 'my.lib.name');
   }
 
-  test_LIBRARY_NAME_partOfDirective() {
+  test_LIBRARY_NAME_partOfDirective() async {
     _addLibraryForTestPart();
     addTestFile('''
 part of my.lib.name;
 ''');
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.LIBRARY_NAME, 'my.lib.name');
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.LIBRARY_NAME, 'my.lib.name');
   }
 
-  test_LITERAL_BOOLEAN() {
+  test_LITERAL_BOOLEAN() async {
     addTestFile('var V = true;');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.LITERAL_BOOLEAN, 'true;');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.LITERAL_BOOLEAN, 'true;');
   }
 
-  test_LITERAL_DOUBLE() {
+  test_LITERAL_DOUBLE() async {
     addTestFile('var V = 4.2;');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.LITERAL_DOUBLE, '4.2;', '4.2'.length);
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.LITERAL_DOUBLE, '4.2;', '4.2'.length);
   }
 
-  test_LITERAL_INTEGER() {
+  test_LITERAL_INTEGER() async {
     addTestFile('var V = 42;');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.LITERAL_INTEGER, '42;');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.LITERAL_INTEGER, '42;');
   }
 
-  test_LITERAL_LIST() {
+  test_LITERAL_LIST() async {
     addTestFile('var V = <int>[1, 2, 3];');
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.LITERAL_LIST, '<int>[1, 2, 3]');
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.LITERAL_LIST, '<int>[1, 2, 3]');
   }
 
-  test_LITERAL_MAP() {
+  test_LITERAL_MAP() async {
     addTestFile("var V = const <int, String>{1: 'a', 2: 'b', 3: 'c'};");
-    return prepareHighlights().then((_) {
-      assertHasStringRegion(HighlightRegionType.LITERAL_MAP,
-          "const <int, String>{1: 'a', 2: 'b', 3: 'c'}");
-    });
+    await prepareHighlights();
+    assertHasStringRegion(HighlightRegionType.LITERAL_MAP,
+        "const <int, String>{1: 'a', 2: 'b', 3: 'c'}");
   }
 
-  test_LITERAL_STRING() {
+  test_LITERAL_STRING() async {
     addTestFile('var V = "abc";');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.LITERAL_STRING, '"abc";', '"abc"'.length);
-    });
+    await prepareHighlights();
+    assertHasRegion(
+        HighlightRegionType.LITERAL_STRING, '"abc";', '"abc"'.length);
   }
 
-  test_LOCAL_FUNCTION() {
+  test_LOCAL_FUNCTION() async {
     addTestFile('''
 main() {
   fff() {}
   fff();
   fff;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.LOCAL_FUNCTION_DECLARATION, 'fff() {}');
-      assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_REFERENCE, 'fff();');
-      assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_REFERENCE, 'fff;');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_DECLARATION, 'fff() {}');
+    assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_REFERENCE, 'fff();');
+    assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_REFERENCE, 'fff;');
   }
 
-  test_LOCAL_VARIABLE() {
+  test_LOCAL_VARIABLE() async {
     addTestFile('''
 main() {
   int vvv = 0;
   vvv;
   vvv = 1;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.LOCAL_VARIABLE_DECLARATION, 'vvv = 0');
-      assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_REFERENCE, 'vvv;');
-      assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_REFERENCE, 'vvv = 1;');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_DECLARATION, 'vvv = 0');
+    assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_REFERENCE, 'vvv;');
+    assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_REFERENCE, 'vvv = 1;');
   }
 
-  test_METHOD() {
+  test_METHOD() async {
     addTestFile('''
 class A {
   aaa() {}
   static bbb() {}
 }
 main(A a) {
   a.aaa();
   a.aaa;
   A.bbb();
   A.bbb;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.INSTANCE_METHOD_DECLARATION, 'aaa() {}');
-      assertHasRegion(
-          HighlightRegionType.STATIC_METHOD_DECLARATION, 'bbb() {}');
-      assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'aaa();');
-      assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'aaa;');
-      assertHasRegion(HighlightRegionType.STATIC_METHOD_REFERENCE, 'bbb();');
-      assertHasRegion(HighlightRegionType.STATIC_METHOD_REFERENCE, 'bbb;');
-    });
+    await prepareHighlights();
+    assertHasRegion(
+        HighlightRegionType.INSTANCE_METHOD_DECLARATION, 'aaa() {}');
+    assertHasRegion(HighlightRegionType.STATIC_METHOD_DECLARATION, 'bbb() {}');
+    assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'aaa();');
+    assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'aaa;');
+    assertHasRegion(HighlightRegionType.STATIC_METHOD_REFERENCE, 'bbb();');
+    assertHasRegion(HighlightRegionType.STATIC_METHOD_REFERENCE, 'bbb;');
   }
 
-  test_METHOD_bestType() {
+  test_METHOD_bestType() async {
     addTestFile('''
 main(p) {
   if (p is List) {
     p.add(null);
   }
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'add(null)');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'add(null)');
   }
 
-  test_PARAMETER() {
+  test_PARAMETER() async {
     addTestFile('''
 main(int p) {
   p;
   p = 42;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.PARAMETER_DECLARATION, 'p) {');
-      assertHasRegion(HighlightRegionType.PARAMETER_REFERENCE, 'p;');
-      assertHasRegion(HighlightRegionType.PARAMETER_REFERENCE, 'p = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.PARAMETER_DECLARATION, 'p) {');
+    assertHasRegion(HighlightRegionType.PARAMETER_REFERENCE, 'p;');
+    assertHasRegion(HighlightRegionType.PARAMETER_REFERENCE, 'p = 42');
   }
 
-  test_SETTER_DECLARATION() {
+  test_SETTER_DECLARATION() async {
     addTestFile('''
 set aaa(x) {}
 class A {
   set bbb(x) {}
   static set ccc(x) {}
 }
 main(A a) {
   aaa = 1;
   a.bbb = 2;
   A.ccc = 3;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.TOP_LEVEL_SETTER_DECLARATION, 'aaa(x)');
-      assertHasRegion(
-          HighlightRegionType.INSTANCE_SETTER_DECLARATION, 'bbb(x)');
-      assertHasRegion(HighlightRegionType.STATIC_SETTER_DECLARATION, 'ccc(x)');
-      assertHasRegion(
-          HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE, 'aaa = 1');
-      assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'bbb = 2');
-      assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'ccc = 3');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.TOP_LEVEL_SETTER_DECLARATION, 'aaa(x)');
+    assertHasRegion(HighlightRegionType.INSTANCE_SETTER_DECLARATION, 'bbb(x)');
+    assertHasRegion(HighlightRegionType.STATIC_SETTER_DECLARATION, 'ccc(x)');
+    assertHasRegion(HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE, 'aaa = 1');
+    assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'bbb = 2');
+    assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'ccc = 3');
   }
 
-  test_STATIC_FIELD() {
+  test_STATIC_FIELD() async {
     addTestFile('''
 class A {
   static aaa = 1;
   static get bbb => null;
   static set ccc(x) {}
 }
 main() {
   A.aaa = 2;
   A.bbb;
   A.ccc = 3;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.STATIC_FIELD_DECLARATION, 'aaa = 1');
-      assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'aaa = 2');
-      assertHasRegion(HighlightRegionType.STATIC_GETTER_REFERENCE, 'bbb;');
-      assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'ccc = 3');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.STATIC_FIELD_DECLARATION, 'aaa = 1');
+    assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'aaa = 2');
+    assertHasRegion(HighlightRegionType.STATIC_GETTER_REFERENCE, 'bbb;');
+    assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'ccc = 3');
   }
 
-  test_TOP_LEVEL_FUNCTION() {
+  test_TOP_LEVEL_FUNCTION() async {
     addTestFile('''
 fff(p) {}
 main() {
   fff(42);
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.TOP_LEVEL_FUNCTION_DECLARATION, 'fff(p) {}');
-      assertHasRegion(
-          HighlightRegionType.TOP_LEVEL_FUNCTION_REFERENCE, 'fff(42)');
-    });
+    await prepareHighlights();
+    assertHasRegion(
+        HighlightRegionType.TOP_LEVEL_FUNCTION_DECLARATION, 'fff(p) {}');
+    assertHasRegion(
+        HighlightRegionType.TOP_LEVEL_FUNCTION_REFERENCE, 'fff(42)');
   }
 
-  test_TOP_LEVEL_VARIABLE() {
+  test_TOP_LEVEL_VARIABLE() async {
     addTestFile('''
 const V1 = 1;
 var V2 = 2;
 @V1 // annotation
 main() {
   print(V1);
   V2 = 3;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(
-          HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 'V1 = 1');
-      assertHasRegion(
-          HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 'V2 = 2');
-      assertHasRegion(
-          HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'V1 // annotation');
-      assertHasRegion(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'V1);');
-      assertHasRegion(HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE, 'V2 = 3');
-    });
+    await prepareHighlights();
+    assertHasRegion(
+        HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 'V1 = 1');
+    assertHasRegion(
+        HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 'V2 = 2');
+    assertHasRegion(
+        HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'V1 // annotation');
+    assertHasRegion(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'V1);');
+    assertHasRegion(HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE, 'V2 = 3');
   }
 
-  test_TYPE_NAME_DYNAMIC() {
+  test_TYPE_NAME_DYNAMIC() async {
     addTestFile('''
 dynamic main() {
   dynamic = 42;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic main()');
-      assertNoRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'dynamic main()');
-      assertNoRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic = 42');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic main()');
+    assertNoRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'dynamic main()');
+    assertNoRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic = 42');
   }
 
-  test_TYPE_PARAMETER() {
+  test_TYPE_PARAMETER() async {
     addTestFile('''
 class A<T> {
   T fff;
   T mmm(T p) => null;
 }
 ''');
-    return prepareHighlights().then((_) {
-      assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T> {');
-      assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T fff;');
-      assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T mmm(');
-      assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T p)');
-    });
+    await prepareHighlights();
+    assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T> {');
+    assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T fff;');
+    assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T mmm(');
+    assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T p)');
   }
 
-  test_UNRESOLVED_INSTANCE_MEMBER_REFERENCE_dynamicVarTarget() {
+  test_UNRESOLVED_INSTANCE_MEMBER_REFERENCE_dynamicVarTarget() async {
     addTestFile('''
 main(p) {
   p.aaa;
   p.aaa++;
   p.aaa += 0;
   ++p.aaa; // ++
   p.aaa = 0;
   p.bbb(0);
   ''.length.ccc().ddd();
 }
 ''');
-    return prepareHighlights().then((_) {
-      HighlightRegionType type =
-          HighlightRegionType.UNRESOLVED_INSTANCE_MEMBER_REFERENCE;
-      assertHasRegion(type, 'aaa');
-      assertHasRegion(type, 'aaa++');
-      assertHasRegion(type, 'aaa += 0');
-      assertHasRegion(type, 'aaa; // ++');
-      assertHasRegion(type, 'aaa =');
-      assertHasRegion(type, 'bbb(');
-      assertHasRegion(type, 'ddd()');
-    });
+    await prepareHighlights();
+    HighlightRegionType type =
+        HighlightRegionType.UNRESOLVED_INSTANCE_MEMBER_REFERENCE;
+    assertHasRegion(type, 'aaa');
+    assertHasRegion(type, 'aaa++');
+    assertHasRegion(type, 'aaa += 0');
+    assertHasRegion(type, 'aaa; // ++');
+    assertHasRegion(type, 'aaa =');
+    assertHasRegion(type, 'bbb(');
+    assertHasRegion(type, 'ddd()');
   }
 
-  test_UNRESOLVED_INSTANCE_MEMBER_REFERENCE_nonDynamicTarget() {
+  test_UNRESOLVED_INSTANCE_MEMBER_REFERENCE_nonDynamicTarget() async {
     addTestFile('''
 import 'dart:math' as math;
 main(String str) {
   new Object().aaa();
   math.bbb();
   str.ccc();
 }
 class A {
   m() {
     unresolved(1);
     this.unresolved(2);
     super.unresolved(3);
   }
 }
 ''');
-    return prepareHighlights().then((_) {
-      HighlightRegionType type = HighlightRegionType.IDENTIFIER_DEFAULT;
-      assertHasRegion(type, 'aaa()');
-      assertHasRegion(type, 'bbb()');
-      assertHasRegion(type, 'ccc()');
-      assertHasRegion(type, 'unresolved(1)');
-      assertHasRegion(type, 'unresolved(2)');
-      assertHasRegion(type, 'unresolved(3)');
-    });
+    await prepareHighlights();
+    HighlightRegionType type = HighlightRegionType.IDENTIFIER_DEFAULT;
+    assertHasRegion(type, 'aaa()');
+    assertHasRegion(type, 'bbb()');
+    assertHasRegion(type, 'ccc()');
+    assertHasRegion(type, 'unresolved(1)');
+    assertHasRegion(type, 'unresolved(2)');
+    assertHasRegion(type, 'unresolved(3)');
   }
 
   void _addLibraryForTestPart() {
     addFile(
         '$testFolder/my_lib.dart',
         '''
 library lib;
 part 'test.dart';
     ''');
   }
 }
 
 @reflectiveTest
 class HighlightTypeTest {
   void test_constructor() {
     expect(HighlightRegionType.CLASS,
         new HighlightRegionType(HighlightRegionType.CLASS.name));
   }
 
   void test_toString() {
     expect(HighlightRegionType.CLASS.toString(), 'HighlightRegionType.CLASS');
   }
 
   void test_valueOf_unknown() {
     expect(() {
       new HighlightRegionType('no-such-type');
     }, throws);
   }
 }