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

pkg/analyzer/lib/src/dart/analysis/search.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/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/visitor.dart';
@@ skipping 124 matching lines @@
       unitElement.accessors.forEach(addElement);
       unitElement.enums.forEach(addElement);
       unitElement.functions.forEach(addElement);
       unitElement.functionTypeAliases.forEach(addElement);
       unitElement.topLevelVariables.forEach(addElement);
       unitElement.types.forEach(addElement);
     }
     return elements;
   }
 
+  /**
+   * Returns unresolved references to the given [name].
+   */
+  Future<List<SearchResult>> unresolvedMemberReferences(String name) async {
+    if (name == null) {
+      return const <SearchResult>[];
+    }
+
+    // Prepare the list of files that reference the name.
+    List<String> files = await _driver.getFilesReferencingName(name);
+
+    // Check the index of every file that references the element name.
+    List<SearchResult> results = [];
+    for (String file in files) {
+      AnalysisDriverUnitIndex index = await _driver.getIndex(file);
+      _IndexRequest request = new _IndexRequest(index);
+      var fileResults = await request.getUnresolvedMemberReferences(
+          name,
+          const {
+            IndexRelationKind.IS_READ_BY: SearchResultKind.READ,
+            IndexRelationKind.IS_WRITTEN_BY: SearchResultKind.WRITE,
+            IndexRelationKind.IS_READ_WRITTEN_BY: SearchResultKind.READ_WRITE,
+            IndexRelationKind.IS_INVOKED_BY: SearchResultKind.INVOCATION
+          },
+          () => _driver.getUnitElement(file));
+      results.addAll(fileResults);
+//      await _addResultsInFile(results, element, relationToResultKind, file);

[Brian Wilkerson, 2017/01/23 21:31:12]

Remove?

+    }
+
+    return results;
+
+    // TODO(scheglov)
+  }
+
   Future<Null> _addResults(List<SearchResult> results, Element element,
       Map<IndexRelationKind, SearchResultKind> relationToResultKind) async {
     // Prepare the element name.
     String name = element.displayName;
     if (element is ConstructorElement) {
       name = element.enclosingElement.displayName;
     }
 
     // Prepare the list of files that reference the element name.
     List<String> files = <String>[];
@@ skipping 542 matching lines @@
     for (int i = 0; i < index.unitLibraryUris.length; i++) {
       if (index.unitLibraryUris[i] == libraryUriId &&
           index.unitUnitUris[i] == unitUriId) {
         return i;
       }
     }
     return -1;
   }
 
   /**
+   * Return a list of results where a class members with the given [name] is
+   * referenced with a qualifier, but is not resolved.
+   */
+  Future<List<SearchResult>> getUnresolvedMemberReferences(
+      String name,
+      Map<IndexRelationKind, SearchResultKind> relationToResultKind,
+      Future<CompilationUnitElement> getEnclosingUnitElement()) async {
+    // Find the name identifier.
+    int nameId = getStringId(name);
+    if (nameId == -1) {
+      return const <SearchResult>[];
+    }
+
+    // Find the first usage of the name.
+    int i = _findFirstOccurrence(index.usedNames, nameId);
+    if (i == -1) {
+      return const <SearchResult>[];
+    }
+
+    // Create results for every usage of the name.
+    List<SearchResult> results = <SearchResult>[];
+    CompilationUnitElement enclosingUnitElement = null;
+    for (; i < index.usedNames.length && index.usedNames[i] == nameId; i++) {
+      IndexRelationKind relationKind = index.usedNameKinds[i];
+      SearchResultKind resultKind = relationToResultKind[relationKind];
+      if (resultKind != null) {
+        int offset = index.usedNameOffsets[i];
+        enclosingUnitElement ??= await getEnclosingUnitElement();
+        Element enclosingElement =
+            _getEnclosingElement(enclosingUnitElement, offset);
+        results.add(new SearchResult._(enclosingElement, resultKind, offset,
+            name.length, false, index.usedNameIsQualifiedFlags[i]));
+      }
+    }
+
+    return results;
+  }
+
+  /**
    * Return the identifier of the [uri] in the [index] or `-1` if the [uri] is
    * not used in the [index].
    */
   int getUriId(Uri uri) {
     String str = uri.toString();
     return getStringId(str);
   }
 
   /**
    * Return the index of the first occurrence of the [value] in the [sortedList],
@@ skipping 58 matching lines @@
   }
 
   void _addResult(AstNode node, SearchResultKind kind) {
     bool isQualified = node.parent is Label;
     Element enclosingElement =
         _getEnclosingElement(enclosingUnitElement, node.offset);
     results.add(new SearchResult._(
         enclosingElement, kind, node.offset, node.length, true, isQualified));
   }
 }