Wait for analysis in search domain. Rewrite with async/await.

pkg/analysis_server/test/search/element_references_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 test.search.element_references;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol.dart';
 import 'package:unittest/unittest.dart';
@@ skipping 10 matching lines @@
 
 @reflectiveTest
 class ElementReferencesTest extends AbstractSearchDomainTest {
   Element searchElement;
 
   void assertHasRef(SearchResultKind kind, String search, bool isPotential) {
     assertHasResult(kind, search);
     expect(result.isPotential, isPotential);
   }
 
-  Future findElementReferences(String search, bool includePotential) {
+  Future findElementReferences(String search, bool includePotential) async {
     int offset = findOffset(search);
-    return waitForTasksFinished().then((_) {
-      Request request = new SearchFindElementReferencesParams(
-          testFile,
-          offset,
-          includePotential).toRequest('0');
-      Response response = handleSuccessfulRequest(request);
-      var result = new SearchFindElementReferencesResult.fromResponse(response);
-      searchId = result.id;
-      searchElement = result.element;
-      results.clear();
-      searchDone = false;
-      if (searchId == null) {
-        return null;
-      } else {
-        return waitForSearchResults();
-      }
-    });
+    await waitForTasksFinished();
+    Request request = new SearchFindElementReferencesParams(
+        testFile,
+        offset,
+        includePotential).toRequest('0');
+    Response response = await waitResponse(request);
+    var result = new SearchFindElementReferencesResult.fromResponse(response);
+    searchId = result.id;
+    searchElement = result.element;
+    if (searchId == null) {
+      return null;
+    } else {
+      return waitForSearchResults();
+    }
   }
 
-  test_constructor_named() {
+  test_constructor_named() async {
     addTestFile('''
 class A {
   A.named(p);
 }
 main() {
   new A.named(1);
   new A.named(2);
 }
 ''');
-    return findElementReferences('named(p)', false).then((_) {
-      expect(searchElement.kind, ElementKind.CONSTRUCTOR);
-      assertHasResult(SearchResultKind.REFERENCE, '.named(1)', 6);
-      assertHasResult(SearchResultKind.REFERENCE, '.named(2)', 6);
-    });
+    await findElementReferences('named(p)', false);
+    expect(searchElement.kind, ElementKind.CONSTRUCTOR);
+    assertHasResult(SearchResultKind.REFERENCE, '.named(1)', 6);
+    assertHasResult(SearchResultKind.REFERENCE, '.named(2)', 6);
   }
 
-  test_constructor_named_potential() {
+  test_constructor_named_potential() async {
     // Constructors in other classes shouldn't be considered potential matches,
     // nor should unresolved method calls, since constructor call sites are
     // statically bound to their targets).
     addTestFile('''
 class A {
   A.named(p); // A
 }
 class B {
   B.named(p);
 }
 f(x) {
   new A.named(1);
   new B.named(2);
   x.named(3);
 }
 ''');
-    return findElementReferences('named(p); // A', true).then((_) {
-      expect(searchElement.kind, ElementKind.CONSTRUCTOR);
-      assertHasResult(SearchResultKind.DECLARATION, '.named(p)', 6);
-      assertHasResult(SearchResultKind.REFERENCE, '.named(1)', 6);
-      expect(results, hasLength(2));
-    });
+    await findElementReferences('named(p); // A', true);
+    expect(searchElement.kind, ElementKind.CONSTRUCTOR);
+    assertHasResult(SearchResultKind.DECLARATION, '.named(p)', 6);
+    assertHasResult(SearchResultKind.REFERENCE, '.named(1)', 6);
+    expect(results, hasLength(2));
   }
 
-  test_constructor_unnamed() {
+  test_constructor_unnamed() async {
     addTestFile('''
 class A {
   A(p);
 }
 main() {
   new A(1);
   new A(2);
 }
 ''');
-    return findElementReferences('A(p)', false).then((_) {
-      expect(searchElement.kind, ElementKind.CONSTRUCTOR);
-      assertHasResult(SearchResultKind.REFERENCE, '(1)', 0);
-      assertHasResult(SearchResultKind.REFERENCE, '(2)', 0);
-    });
+    await findElementReferences('A(p)', false);
+    expect(searchElement.kind, ElementKind.CONSTRUCTOR);
+    assertHasResult(SearchResultKind.REFERENCE, '(1)', 0);
+    assertHasResult(SearchResultKind.REFERENCE, '(2)', 0);
   }
 
-  test_constructor_unnamed_potential() {
+  test_constructor_unnamed_potential() async {
     // Constructors in other classes shouldn't be considered potential matches,
     // even if they are also unnamed (since constructor call sites are
     // statically bound to their targets).
     // Also, assignments to local variables shouldn't be considered potential
     // matches.
     addTestFile('''
 class A {
   A(p); // A
 }
 class B {
   B(p);
   foo() {
     int k;
     k = 3;
   }
 }
 main() {
   new A(1);
   new B(2);
 }
 ''');
-    return findElementReferences('A(p)', true).then((_) {
-      expect(searchElement.kind, ElementKind.CONSTRUCTOR);
-      assertHasResult(SearchResultKind.DECLARATION, '(p); // A', 0);
-      assertHasResult(SearchResultKind.REFERENCE, '(1)', 0);
-      expect(results, hasLength(2));
-    });
+    await findElementReferences('A(p)', true);
+    expect(searchElement.kind, ElementKind.CONSTRUCTOR);
+    assertHasResult(SearchResultKind.DECLARATION, '(p); // A', 0);
+    assertHasResult(SearchResultKind.REFERENCE, '(1)', 0);
+    expect(results, hasLength(2));
   }
 
-  test_field_explicit() {
+  test_field_explicit() async {
     addTestFile('''
 class A {
   var fff; // declaration
   A(this.fff); // in constructor
   m() {
     fff = 2;
     fff += 3;
     print(fff); // in m()
     fff(); // in m()
   }
 }
 main(A a) {
   a.fff = 20;
   a.fff += 30;
   print(a.fff); // in main()
   a.fff(); // in main()
 }
 ''');
-    return findElementReferences('fff; // declaration', false).then((_) {
-      expect(searchElement.kind, ElementKind.FIELD);
-      expect(results, hasLength(10));
-      assertHasResult(SearchResultKind.DECLARATION, 'fff; // declaration');
-      assertHasResult(SearchResultKind.REFERENCE, 'fff); // in constructor');
-      // m()
-      assertHasResult(SearchResultKind.WRITE, 'fff = 2;');
-      assertHasResult(SearchResultKind.WRITE, 'fff += 3;');
-      assertHasResult(SearchResultKind.READ, 'fff); // in m()');
-      assertHasResult(SearchResultKind.INVOCATION, 'fff(); // in m()');
-      // main()
-      assertHasResult(SearchResultKind.WRITE, 'fff = 20;');
-      assertHasResult(SearchResultKind.WRITE, 'fff += 30;');
-      assertHasResult(SearchResultKind.READ, 'fff); // in main()');
-      assertHasResult(SearchResultKind.INVOCATION, 'fff(); // in main()');
-    });
+    await findElementReferences('fff; // declaration', false);
+    expect(searchElement.kind, ElementKind.FIELD);
+    expect(results, hasLength(10));
+    assertHasResult(SearchResultKind.DECLARATION, 'fff; // declaration');
+    assertHasResult(SearchResultKind.REFERENCE, 'fff); // in constructor');
+    // m()
+    assertHasResult(SearchResultKind.WRITE, 'fff = 2;');
+    assertHasResult(SearchResultKind.WRITE, 'fff += 3;');
+    assertHasResult(SearchResultKind.READ, 'fff); // in m()');
+    assertHasResult(SearchResultKind.INVOCATION, 'fff(); // in m()');
+    // main()
+    assertHasResult(SearchResultKind.WRITE, 'fff = 20;');
+    assertHasResult(SearchResultKind.WRITE, 'fff += 30;');
+    assertHasResult(SearchResultKind.READ, 'fff); // in main()');
+    assertHasResult(SearchResultKind.INVOCATION, 'fff(); // in main()');
   }
 
-  test_field_implicit() {
+  test_field_implicit() async {
     addTestFile('''
 class A {
   var  get fff => null;
   void set fff(x) {}
   m() {
     print(fff); // in m()
     fff = 1;
   }
 }
 main(A a) {
   print(a.fff); // in main()
   a.fff = 10;
 }
 ''');
-    return findElementReferences('fff =>', false).then((_) {
+    {
+      await findElementReferences('fff =>', false);
       expect(searchElement.kind, ElementKind.FIELD);
       expect(results, hasLength(4));
       assertHasResult(SearchResultKind.READ, 'fff); // in m()');
       assertHasResult(SearchResultKind.WRITE, 'fff = 1;');
       assertHasResult(SearchResultKind.READ, 'fff); // in main()');
       assertHasResult(SearchResultKind.WRITE, 'fff = 10;');
-      return findElementReferences('fff(x) {}', false);
-    }).then((_) {
+    }
+    {
+      await findElementReferences('fff(x) {}', false);
       expect(results, hasLength(4));
       assertHasResult(SearchResultKind.READ, 'fff); // in m()');
       assertHasResult(SearchResultKind.WRITE, 'fff = 1;');
       assertHasResult(SearchResultKind.READ, 'fff); // in main()');
       assertHasResult(SearchResultKind.WRITE, 'fff = 10;');
-    });
+    }
   }
 
-  test_field_inFormalParameter() {
+  test_field_inFormalParameter() async {
     addTestFile('''
 class A {
   var fff; // declaration
   A(this.fff); // in constructor
   m() {
     fff = 2;
     print(fff); // in m()
   }
 }
 ''');
-    return findElementReferences('fff); // in constructor', false).then((_) {
-      expect(searchElement.kind, ElementKind.FIELD);
-      expect(results, hasLength(4));
-      assertHasResult(SearchResultKind.DECLARATION, 'fff; // declaration');
-      assertHasResult(SearchResultKind.REFERENCE, 'fff); // in constructor');
-      assertHasResult(SearchResultKind.WRITE, 'fff = 2;');
-      assertHasResult(SearchResultKind.READ, 'fff); // in m()');
-    });
+    await findElementReferences('fff); // in constructor', false);
+    expect(searchElement.kind, ElementKind.FIELD);
+    expect(results, hasLength(4));
+    assertHasResult(SearchResultKind.DECLARATION, 'fff; // declaration');
+    assertHasResult(SearchResultKind.REFERENCE, 'fff); // in constructor');
+    assertHasResult(SearchResultKind.WRITE, 'fff = 2;');
+    assertHasResult(SearchResultKind.READ, 'fff); // in m()');
   }
 
-  test_function() {
+  test_function() async {
     addTestFile('''
 fff(p) {}
 main() {
   fff(1);
   print(fff);
 }
 ''');
-    return findElementReferences('fff(p) {}', false).then((_) {
-      expect(searchElement.kind, ElementKind.FUNCTION);
-      expect(results, hasLength(2));
-      assertHasResult(SearchResultKind.INVOCATION, 'fff(1)');
-      assertHasResult(SearchResultKind.REFERENCE, 'fff);');
-    });
+    await findElementReferences('fff(p) {}', false);
+    expect(searchElement.kind, ElementKind.FUNCTION);
+    expect(results, hasLength(2));
+    assertHasResult(SearchResultKind.INVOCATION, 'fff(1)');
+    assertHasResult(SearchResultKind.REFERENCE, 'fff);');
   }
 
-  test_hierarchy_field_explicit() {
+  test_hierarchy_field_explicit() async {
     addTestFile('''
   class A {
     int fff; // in A
   }
   class B extends A {
     int fff; // in B
   }
   class C extends B {
     int fff; // in C
   }
   main(A a, B b, C c) {
     a.fff = 10;
     b.fff = 20;
     c.fff = 30;
   }
   ''');
-    return findElementReferences('fff; // in B', false).then((_) {
-      expect(searchElement.kind, ElementKind.FIELD);
-      assertHasResult(SearchResultKind.DECLARATION, 'fff; // in A');
-      assertHasResult(SearchResultKind.DECLARATION, 'fff; // in B');
-      assertHasResult(SearchResultKind.DECLARATION, 'fff; // in C');
-      assertHasResult(SearchResultKind.WRITE, 'fff = 10;');
-      assertHasResult(SearchResultKind.WRITE, 'fff = 20;');
-      assertHasResult(SearchResultKind.WRITE, 'fff = 30;');
-    });
+    await findElementReferences('fff; // in B', false);
+    expect(searchElement.kind, ElementKind.FIELD);
+    assertHasResult(SearchResultKind.DECLARATION, 'fff; // in A');
+    assertHasResult(SearchResultKind.DECLARATION, 'fff; // in B');
+    assertHasResult(SearchResultKind.DECLARATION, 'fff; // in C');
+    assertHasResult(SearchResultKind.WRITE, 'fff = 10;');
+    assertHasResult(SearchResultKind.WRITE, 'fff = 20;');
+    assertHasResult(SearchResultKind.WRITE, 'fff = 30;');
   }
 
-  test_hierarchy_method() {
+  test_hierarchy_method() async {
     addTestFile('''
 class A {
   mmm() {} // in A
 }
 class B extends A {
   mmm() {} // in B
 }
 class C extends B {
   mmm() {} // in C
 }
 main(A a, B b, C c) {
   a.mmm(10);
   b.mmm(20);
   c.mmm(30);
 }
 ''');
-    return findElementReferences('mmm() {} // in B', false).then((_) {
-      expect(searchElement.kind, ElementKind.METHOD);
-      assertHasResult(SearchResultKind.INVOCATION, 'mmm(10)');
-      assertHasResult(SearchResultKind.INVOCATION, 'mmm(20)');
-      assertHasResult(SearchResultKind.INVOCATION, 'mmm(30)');
-    });
+    await findElementReferences('mmm() {} // in B', false);
+    expect(searchElement.kind, ElementKind.METHOD);
+    assertHasResult(SearchResultKind.INVOCATION, 'mmm(10)');
+    assertHasResult(SearchResultKind.INVOCATION, 'mmm(20)');
+    assertHasResult(SearchResultKind.INVOCATION, 'mmm(30)');
   }
 
-  test_label() {
+  test_label() async {
     addTestFile('''
 main() {
 myLabel:
   for (int i = 0; i < 10; i++) {
     if (i == 2) {
       continue myLabel; // continue
     }
     break myLabel; // break
   }
 }
 ''');
-    return findElementReferences('myLabel; // break', false).then((_) {
-      expect(searchElement.kind, ElementKind.LABEL);
-      expect(results, hasLength(3));
-      assertHasResult(SearchResultKind.DECLARATION, 'myLabel:');
-      assertHasResult(SearchResultKind.REFERENCE, 'myLabel; // continue');
-      assertHasResult(SearchResultKind.REFERENCE, 'myLabel; // break');
-    });
+    await findElementReferences('myLabel; // break', false);
+    expect(searchElement.kind, ElementKind.LABEL);
+    expect(results, hasLength(3));
+    assertHasResult(SearchResultKind.DECLARATION, 'myLabel:');
+    assertHasResult(SearchResultKind.REFERENCE, 'myLabel; // continue');
+    assertHasResult(SearchResultKind.REFERENCE, 'myLabel; // break');
   }
 
-  test_localVariable() {
+  test_localVariable() async {
     addTestFile('''
 main() {
   var vvv = 1;
   print(vvv);
   vvv += 3;
   vvv = 2;
   vvv();
 }
 ''');
-    return findElementReferences('vvv = 1', false).then((_) {
-      expect(searchElement.kind, ElementKind.LOCAL_VARIABLE);
-      expect(results, hasLength(5));
-      assertHasResult(SearchResultKind.DECLARATION, 'vvv = 1');
-      assertHasResult(SearchResultKind.READ, 'vvv);');
-      assertHasResult(SearchResultKind.READ_WRITE, 'vvv += 3');
-      assertHasResult(SearchResultKind.WRITE, 'vvv = 2');
-      assertHasResult(SearchResultKind.INVOCATION, 'vvv();');
-    });
+    await findElementReferences('vvv = 1', false);
+    expect(searchElement.kind, ElementKind.LOCAL_VARIABLE);
+    expect(results, hasLength(5));
+    assertHasResult(SearchResultKind.DECLARATION, 'vvv = 1');
+    assertHasResult(SearchResultKind.READ, 'vvv);');
+    assertHasResult(SearchResultKind.READ_WRITE, 'vvv += 3');
+    assertHasResult(SearchResultKind.WRITE, 'vvv = 2');
+    assertHasResult(SearchResultKind.INVOCATION, 'vvv();');
   }
 
-  test_method() {
+  test_method() async {
     addTestFile('''
 class A {
   mmm(p) {}
   m() {
     mmm(1);
     print(mmm); // in m()
   }
 }
 main(A a) {
   a.mmm(10);
   print(a.mmm); // in main()
 }
 ''');
-    return findElementReferences('mmm(p) {}', false).then((_) {
-      expect(searchElement.kind, ElementKind.METHOD);
-      expect(results, hasLength(4));
-      assertHasResult(SearchResultKind.INVOCATION, 'mmm(1);');
-      assertHasResult(SearchResultKind.REFERENCE, 'mmm); // in m()');
-      assertHasResult(SearchResultKind.INVOCATION, 'mmm(10);');
-      assertHasResult(SearchResultKind.REFERENCE, 'mmm); // in main()');
-    });
+    await findElementReferences('mmm(p) {}', false);
+    expect(searchElement.kind, ElementKind.METHOD);
+    expect(results, hasLength(4));
+    assertHasResult(SearchResultKind.INVOCATION, 'mmm(1);');
+    assertHasResult(SearchResultKind.REFERENCE, 'mmm); // in m()');
+    assertHasResult(SearchResultKind.INVOCATION, 'mmm(10);');
+    assertHasResult(SearchResultKind.REFERENCE, 'mmm); // in main()');
   }
 
-  test_method_propagatedType() {
+  test_method_propagatedType() async {
     addTestFile('''
 class A {
   mmm(p) {}
 }
 main() {
   var a = new A();
   a.mmm(10);
   print(a.mmm);
 }
 ''');
-    return findElementReferences('mmm(p) {}', false).then((_) {
-      expect(searchElement.kind, ElementKind.METHOD);
-      expect(results, hasLength(2));
-      assertHasResult(SearchResultKind.INVOCATION, 'mmm(10);');
-      assertHasResult(SearchResultKind.REFERENCE, 'mmm);');
-    });
+    await findElementReferences('mmm(p) {}', false);
+    expect(searchElement.kind, ElementKind.METHOD);
+    expect(results, hasLength(2));
+    assertHasResult(SearchResultKind.INVOCATION, 'mmm(10);');
+    assertHasResult(SearchResultKind.REFERENCE, 'mmm);');
   }
 
-  test_noElement() {
+  test_noElement() async {
     addTestFile('''
 main() {
   print(noElement);
 }
 ''');
-    return findElementReferences('noElement', false).then((_) {
-      expect(searchId, isNull);
-    });
+    await findElementReferences('noElement', false);
+    expect(searchId, isNull);
   }
 
-  test_oneUnit_twoLibraries() {
+  test_oneUnit_twoLibraries() async {
     var pathA = '/project/bin/libA.dart';
     var pathB = '/project/bin/libB.dart';
     var codeA = '''
 library lib;
 part 'test.dart';
 main() {
   fff(1);
 }
 ''';
     var codeB = '''
 library lib;
 part 'test.dart';
 main() {
   fff(2);
 }
 ''';
     addFile(pathA, codeA);
     addFile(pathB, codeB);
     addTestFile('''
 part of lib;
 fff(p) {}
 ''');
-    return findElementReferences('fff(p) {}', false).then((_) {
-      expect(searchElement.kind, ElementKind.FUNCTION);
-      expect(results, hasLength(2));
-      findResult(
-          SearchResultKind.INVOCATION,
-          pathA,
-          codeA.indexOf('fff(1)'),
-          3,
-          true);
-      findResult(
-          SearchResultKind.INVOCATION,
-          pathB,
-          codeB.indexOf('fff(2)'),
-          3,
-          true);
-    });
+    await findElementReferences('fff(p) {}', false);
+    expect(searchElement.kind, ElementKind.FUNCTION);
+    expect(results, hasLength(2));
+    findResult(
+        SearchResultKind.INVOCATION,
+        pathA,
+        codeA.indexOf('fff(1)'),
+        3,
+        true);
+    findResult(
+        SearchResultKind.INVOCATION,
+        pathB,
+        codeB.indexOf('fff(2)'),
+        3,
+        true);
   }
 
-  test_oneUnit_zeroLibraries() {
+  test_oneUnit_zeroLibraries() async {
     addTestFile('''
 part of lib;
 fff(p) {}
 main() {
   fff(10);
 }
 ''');
-    return findElementReferences('fff(p) {}', false).then((_) {
-      expect(results, isEmpty);
-    });
+    await findElementReferences('fff(p) {}', false);
+    expect(results, isEmpty);
   }
 
-  test_parameter() {
+  test_parameter() async {
     addTestFile('''
 main(ppp) {
   print(ppp);
   ppp += 3;
   ppp = 2;
   ppp();
 }
 ''');
-    return findElementReferences('ppp) {', false).then((_) {
-      expect(searchElement.kind, ElementKind.PARAMETER);
-      expect(results, hasLength(5));
-      assertHasResult(SearchResultKind.DECLARATION, 'ppp) {');
-      assertHasResult(SearchResultKind.READ, 'ppp);');
-      assertHasResult(SearchResultKind.READ_WRITE, 'ppp += 3');
-      assertHasResult(SearchResultKind.WRITE, 'ppp = 2');
-      assertHasResult(SearchResultKind.INVOCATION, 'ppp();');
-    });
+    await findElementReferences('ppp) {', false);
+    expect(searchElement.kind, ElementKind.PARAMETER);
+    expect(results, hasLength(5));
+    assertHasResult(SearchResultKind.DECLARATION, 'ppp) {');
+    assertHasResult(SearchResultKind.READ, 'ppp);');
+    assertHasResult(SearchResultKind.READ_WRITE, 'ppp += 3');
+    assertHasResult(SearchResultKind.WRITE, 'ppp = 2');
+    assertHasResult(SearchResultKind.INVOCATION, 'ppp();');
   }
 
-  test_path_inConstructor_named() {
+  test_path_inConstructor_named() async {
     addTestFile('''
 library my_lib;
 class A {}
 class B {
   B.named() {
     A a = null;
   }
 }
 ''');
-    return findElementReferences('A {}', false).then((_) {
-      assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
-      expect(getPathString(result.path), '''
+    await findElementReferences('A {}', false);
+    assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
+    expect(getPathString(result.path), '''
 LOCAL_VARIABLE a
 CONSTRUCTOR named
 CLASS B
 COMPILATION_UNIT test.dart
 LIBRARY my_lib''');
-    });
   }
 
-  test_path_inConstructor_unnamed() {
+  test_path_inConstructor_unnamed() async {
     addTestFile('''
 library my_lib;
 class A {}
 class B {
   B() {
     A a = null;
   }
 }
 ''');
-    return findElementReferences('A {}', false).then((_) {
-      assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
-      expect(getPathString(result.path), '''
+    await findElementReferences('A {}', false);
+    assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
+    expect(getPathString(result.path), '''
 LOCAL_VARIABLE a
 CONSTRUCTOR 
 CLASS B
 COMPILATION_UNIT test.dart
 LIBRARY my_lib''');
-    });
   }
 
-  test_path_inFunction() {
+  test_path_inFunction() async {
     addTestFile('''
 library my_lib;
 class A {}
 main() {
   A a = null;
 }
 ''');
-    return findElementReferences('A {}', false).then((_) {
-      assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
-      expect(getPathString(result.path), '''
+    await findElementReferences('A {}', false);
+    assertHasResult(SearchResultKind.REFERENCE, 'A a = null;');
+    expect(getPathString(result.path), '''
 LOCAL_VARIABLE a
 FUNCTION main
 COMPILATION_UNIT test.dart
 LIBRARY my_lib''');
-    });
   }
 
-  test_potential_disabled() {
+  test_potential_disabled() async {
     addTestFile('''
 class A {
   test(p) {}
 }
 main(A a, p) {
   a.test(1);
   p.test(2);
 }
 ''');
-    return findElementReferences('test(p) {}', false).then((_) {
-      assertHasResult(SearchResultKind.INVOCATION, 'test(1);');
-      assertNoResult(SearchResultKind.INVOCATION, 'test(2);');
-    });
+    await findElementReferences('test(p) {}', false);
+    assertHasResult(SearchResultKind.INVOCATION, 'test(1);');
+    assertNoResult(SearchResultKind.INVOCATION, 'test(2);');
   }
 
-  test_potential_field() {
+  test_potential_field() async {
     addTestFile('''
 class A {
   var test; // declaration
 }
 main(A a, p) {
   a.test = 1;
   p.test = 2;
   print(p.test); // p
 }
 ''');
-    return findElementReferences('test; // declaration', true).then((_) {
-      {
-        assertHasResult(SearchResultKind.WRITE, 'test = 1;');
-        expect(result.isPotential, isFalse);
-      }
-      {
-        assertHasResult(SearchResultKind.WRITE, 'test = 2;');
-        expect(result.isPotential, isTrue);
-      }
-      {
-        assertHasResult(SearchResultKind.READ, 'test); // p');
-        expect(result.isPotential, isTrue);
-      }
-    });
+    await findElementReferences('test; // declaration', true);
+    {
+      assertHasResult(SearchResultKind.WRITE, 'test = 1;');
+      expect(result.isPotential, isFalse);
+    }
+    {
+      assertHasResult(SearchResultKind.WRITE, 'test = 2;');
+      expect(result.isPotential, isTrue);
+    }
+    {
+      assertHasResult(SearchResultKind.READ, 'test); // p');
+      expect(result.isPotential, isTrue);
+    }
   }
 
-  test_potential_method() {
+  test_potential_method() async {
     addTestFile('''
 class A {
   test(p) {}
 }
 main(A a, p) {
   a.test(1);
   p.test(2);
 }
 ''');
-    return findElementReferences('test(p) {}', true).then((_) {
-      {
-        assertHasResult(SearchResultKind.INVOCATION, 'test(1);');
-        expect(result.isPotential, isFalse);
-      }
-      {
-        assertHasResult(SearchResultKind.INVOCATION, 'test(2);');
-        expect(result.isPotential, isTrue);
-      }
-    });
+    await findElementReferences('test(p) {}', true);
+    {
+      assertHasResult(SearchResultKind.INVOCATION, 'test(1);');
+      expect(result.isPotential, isFalse);
+    }
+    {
+      assertHasResult(SearchResultKind.INVOCATION, 'test(2);');
+      expect(result.isPotential, isTrue);
+    }
   }
 
-  test_potential_method_definedInSubclass() {
+  test_potential_method_definedInSubclass() async {
     addTestFile('''
 class Base {
   methodInBase() {
     test(1);
   }
 }
 class Derived extends Base {
   test(_) {} // of Derived
   methodInDerived() {
     test(2);
   }
 }
 globalFunction(Base b) {
   b.test(3);
 }
 ''');
-    return findElementReferences('test(_) {} // of Derived', true).then((_) {
-      assertHasRef(SearchResultKind.INVOCATION, 'test(1);', true);
-      assertHasRef(SearchResultKind.INVOCATION, 'test(2);', false);
-      assertHasRef(SearchResultKind.INVOCATION, 'test(3);', true);
-    });
+    await findElementReferences('test(_) {} // of Derived', true);
+    assertHasRef(SearchResultKind.INVOCATION, 'test(1);', true);
+    assertHasRef(SearchResultKind.INVOCATION, 'test(2);', false);
+    assertHasRef(SearchResultKind.INVOCATION, 'test(3);', true);
   }
 
-  test_prefix() {
+  test_prefix() async {
     addTestFile('''
 import 'dart:async' as ppp;
 main() {
   ppp.Future a;
   ppp.Stream b;
 }
 ''');
-    return findElementReferences("ppp;", false).then((_) {
-      expect(searchElement.kind, ElementKind.PREFIX);
-      expect(searchElement.name, 'ppp');
-      expect(searchElement.location.startLine, 1);
-      expect(results, hasLength(3));
-      assertHasResult(SearchResultKind.DECLARATION, 'ppp;');
-      assertHasResult(SearchResultKind.REFERENCE, 'ppp.Future');
-      assertHasResult(SearchResultKind.REFERENCE, 'ppp.Stream');
-    });
+    await findElementReferences("ppp;", false);
+    expect(searchElement.kind, ElementKind.PREFIX);
+    expect(searchElement.name, 'ppp');
+    expect(searchElement.location.startLine, 1);
+    expect(results, hasLength(3));
+    assertHasResult(SearchResultKind.DECLARATION, 'ppp;');
+    assertHasResult(SearchResultKind.REFERENCE, 'ppp.Future');
+    assertHasResult(SearchResultKind.REFERENCE, 'ppp.Stream');
   }
 
-  test_prefix_null() {
+  test_prefix_null() async {
     addTestFile('''
 import 'dart:async';
 main() {
   Future a;
   Stream b;
 }
 ''');
-    return findElementReferences("import ", false).then((_) {
-      expect(searchElement, isNull);
-    });
+    await findElementReferences("import ", false);
+    expect(searchElement, isNull);
   }
 
-  test_topLevelVariable_explicit() {
+  test_topLevelVariable_explicit() async {
     addTestFile('''
 var vvv = 1;
 main() {
   print(vvv);
   vvv += 3;
   vvv = 2;
   vvv();
 }
 ''');
-    return findElementReferences('vvv = 1', false).then((_) {
-      expect(searchElement.kind, ElementKind.TOP_LEVEL_VARIABLE);
-      expect(results, hasLength(5));
-      assertHasResult(SearchResultKind.DECLARATION, 'vvv = 1;');
-      assertHasResult(SearchResultKind.READ, 'vvv);');
-      assertHasResult(SearchResultKind.WRITE, 'vvv += 3');
-      assertHasResult(SearchResultKind.WRITE, 'vvv = 2');
-      assertHasResult(SearchResultKind.INVOCATION, 'vvv();');
-    });
+    await findElementReferences('vvv = 1', false);
+    expect(searchElement.kind, ElementKind.TOP_LEVEL_VARIABLE);
+    expect(results, hasLength(5));
+    assertHasResult(SearchResultKind.DECLARATION, 'vvv = 1;');
+    assertHasResult(SearchResultKind.READ, 'vvv);');
+    assertHasResult(SearchResultKind.WRITE, 'vvv += 3');
+    assertHasResult(SearchResultKind.WRITE, 'vvv = 2');
+    assertHasResult(SearchResultKind.INVOCATION, 'vvv();');
   }
 
-  test_topLevelVariable_implicit() {
+  test_topLevelVariable_implicit() async {
     addTestFile('''
 get vvv => null;
 set vvv(x) {}
 main() {
   print(vvv);
   vvv = 1;
 }
 ''');
-    return findElementReferences('vvv =>', false).then((_) {
+    {
+      await findElementReferences('vvv =>', false);
       expect(searchElement.kind, ElementKind.TOP_LEVEL_VARIABLE);
       expect(results, hasLength(2));
       assertHasResult(SearchResultKind.READ, 'vvv);');
       assertHasResult(SearchResultKind.WRITE, 'vvv = 1;');
-      return findElementReferences('vvv(x) {}', false);
-    }).then((_) {
+    }
+    {
+      await findElementReferences('vvv(x) {}', false);
       expect(results, hasLength(2));
       assertHasResult(SearchResultKind.READ, 'vvv);');
       assertHasResult(SearchResultKind.WRITE, 'vvv = 1;');
-    });
+    }
   }
 
-  test_typeReference_class() {
+  test_typeReference_class() async {
     addTestFile('''
 main() {
   int a = 1;
   int b = 2;
 }
 ''');
-    return findElementReferences('int a', false).then((_) {
-      expect(searchElement.kind, ElementKind.CLASS);
-      assertHasResult(SearchResultKind.REFERENCE, 'int a');
-      assertHasResult(SearchResultKind.REFERENCE, 'int b');
-    });
+    await findElementReferences('int a', false);
+    expect(searchElement.kind, ElementKind.CLASS);
+    assertHasResult(SearchResultKind.REFERENCE, 'int a');
+    assertHasResult(SearchResultKind.REFERENCE, 'int b');
   }
 
-  test_typeReference_functionType() {
+  test_typeReference_functionType() async {
     addTestFile('''
 typedef F();
 main(F f) {
 }
 ''');
-    return findElementReferences('F()', false).then((_) {
-      expect(searchElement.kind, ElementKind.FUNCTION_TYPE_ALIAS);
-      expect(results, hasLength(1));
-      assertHasResult(SearchResultKind.REFERENCE, 'F f');
-    });
+    await findElementReferences('F()', false);
+    expect(searchElement.kind, ElementKind.FUNCTION_TYPE_ALIAS);
+    expect(results, hasLength(1));
+    assertHasResult(SearchResultKind.REFERENCE, 'F f');
   }
 
-  test_typeReference_typeVariable() {
+  test_typeReference_typeVariable() async {
     addTestFile('''
 class A<T> {
   T f;
   T m() => null;
 }
 ''');
-    return findElementReferences('T> {', false).then((_) {
-      expect(searchElement.kind, ElementKind.TYPE_PARAMETER);
-      expect(results, hasLength(2));
-      assertHasResult(SearchResultKind.REFERENCE, 'T f;');
-      assertHasResult(SearchResultKind.REFERENCE, 'T m()');
-    });
+    await findElementReferences('T> {', false);
+    expect(searchElement.kind, ElementKind.TYPE_PARAMETER);
+    expect(results, hasLength(2));
+    assertHasResult(SearchResultKind.REFERENCE, 'T f;');
+    assertHasResult(SearchResultKind.REFERENCE, 'T m()');
   }
 }