Issue 28386. Implement search for potential usages with the new analysis driver.

pkg/analyzer/test/src/dart/analysis/search_test.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
@@ skipping 81 matching lines @@
   }
 
   test_classMembers_importNotDart() async {
     await _resolveTestUnit('''
 import 'not-dart.txt';
 ''');
     RegExp regExp = new RegExp(r'^test$');
     expect(await driver.search.classMembers(regExp), isEmpty);
   }
 
+  test_searchMemberReferences_qualified_resolved() async {
+    await _resolveTestUnit('''
+class C {
+  var test;
+}
+main(C c) {
+  print(c.test);
+  c.test = 1;
+  c.test += 2;
+  c.test();
+}
+''');
+    await _verifyNameReferences('test', []);
+  }
+
+  test_searchMemberReferences_qualified_unresolved() async {
+    await _resolveTestUnit('''
+main(p) {
+  print(p.test);
+  p.test = 1;
+  p.test += 2;
+  p.test();
+}
+''');
+    Element main = _findElement('main');
+    await _verifyNameReferences('test', <ExpectedResult>[
+      _expectIdQU(main, SearchResultKind.READ, 'test);'),
+      _expectIdQU(main, SearchResultKind.WRITE, 'test = 1;'),
+      _expectIdQU(main, SearchResultKind.READ_WRITE, 'test += 2;'),
+      _expectIdQU(main, SearchResultKind.INVOCATION, 'test();'),
+    ]);
+  }
+
+  test_searchMemberReferences_unqualified_resolved() async {
+    await _resolveTestUnit('''
+class C {
+  var test;
+  main() {
+    print(test);
+    test = 1;
+    test += 2;
+    test();
+  }
+}
+''');
+    await _verifyNameReferences('test', []);
+  }
+
+  test_searchMemberReferences_unqualified_unresolved() async {
+    await _resolveTestUnit('''
+class C {
+  main() {
+    print(test);
+    test = 1;
+    test += 2;
+    test();
+  }
+}
+''');
+    Element main = _findElement('main');
+    await _verifyNameReferences('test', <ExpectedResult>[
+      _expectIdU(main, SearchResultKind.READ, 'test);'),
+      _expectIdU(main, SearchResultKind.WRITE, 'test = 1;'),
+      _expectIdU(main, SearchResultKind.READ_WRITE, 'test += 2;'),
+      _expectIdU(main, SearchResultKind.INVOCATION, 'test();'),
+    ]);
+  }
+
   test_searchReferences_ClassElement_definedInside() async {
     await _resolveTestUnit('''
 class A {};
 main(A p) {
   A v;
 }
 class B1 extends A {} // extends
 class B2 implements A {} // implements
 class B3 extends Object with A {} // with
 List<A> v2 = null;
@@ skipping 894 matching lines @@
 
   /**
    * Create [ExpectedResult] for a qualified and resolved match.
    */
   ExpectedResult _expectIdQ(
       Element element, SearchResultKind kind, String search,
       {int length, bool isResolved: true}) {
     return _expectId(element, kind, search, isQualified: true, length: length);
   }
 
+  /**
+   * Create [ExpectedResult] for a qualified and unresolved match.
+   */
+  ExpectedResult _expectIdQU(
+      Element element, SearchResultKind kind, String search,
+      {int length}) {
+    return _expectId(element, kind, search,
+        isQualified: true, isResolved: false, length: length);
+  }
+
+  /**
+   * Create [ExpectedResult] for a unqualified and unresolved match.
+   */
+  ExpectedResult _expectIdU(
+      Element element, SearchResultKind kind, String search,
+      {int length}) {
+    return _expectId(element, kind, search,
+        isQualified: false, isResolved: false, length: length);
+  }
+
   Element _findElement(String name, [ElementKind kind]) {
     return findChildElement(testUnit.element, name, kind);
   }
 
   Element _findElementAtString(String search) {
     int offset = findOffset(search);
     AstNode node = new NodeLocator(offset).searchWithin(testUnit);
     return ElementLocator.locate(node);
   }
 
   String _p(String path) => provider.convertPath(path);
 
   Future<Null> _resolveTestUnit(String code) async {
     addTestFile(code);
     if (testUnit == null) {
       AnalysisResult result = await driver.getResult(testFile);
       testUnit = result.unit;
       testUnitElement = testUnit.element;
       testLibraryElement = testUnitElement.library;
     }
   }
 
+  Future<Null> _verifyNameReferences(
+      String name, List<ExpectedResult> expectedMatches) async {
+    List<SearchResult> results =
+        await driver.search.unresolvedMemberReferences(name);
+    _assertResults(results, expectedMatches);
+    expect(results, hasLength(expectedMatches.length));
+  }
+
   Future _verifyReferences(
       Element element, List<ExpectedResult> expectedMatches) async {
     List<SearchResult> results = await driver.search.references(element);
     _assertResults(results, expectedMatches);
     expect(results, hasLength(expectedMatches.length));
   }
 
   static void _assertResults(
       List<SearchResult> matches, List<ExpectedResult> expectedMatches) {
     expect(matches, unorderedEquals(expectedMatches));
   }
 }