Add a method to FileResolver to find references.

Change-Id: I48cd2dec633e16d6120c921df1debc8f012fd41f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/197103
Commit-Queue: Keerti Parthasarathy <keertip@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>

Author: keertip

pkg/analyzer/lib/src/dart/micro/library_graph.dart

@@ -518,6 +518,10 @@ class FileSystemState {
   /// to batch file reads in systems where file fetches are expensive.
   final void Function(List<String> paths)? prefetchFiles;
 
+  /// A function that returns true if the given file path is likely to be that
+  /// of a file that is generated.
+  final bool Function(String path)? isGenerated;
+
   final FileSystemStateTimers timers2 = FileSystemStateTimers();
 
   final FileSystemStateTestView testView = FileSystemStateTestView();
@@ -533,6 +537,7 @@ class FileSystemState {
     this.featureSetProvider,
     this.getFileDigest,
     this.prefetchFiles,
+    this.isGenerated,
   );
 
   /// Update the state to reflect the fact that the file with the given [path]
@@ -662,6 +667,19 @@ class FileSystemState {
     return file;
   }
 
+  /// Returns a list of files whose contents contains the given string.
+  /// Generated files are not included in the search.
+  List<String> getFilesContaining(String value) {
+    var result = <String>[];
+    _pathToFile.forEach((path, file) {
+      var genFile = isGenerated == null ? false : isGenerated!(path);
+      if (!genFile && file.getContent().contains(value)) {
+        result.add(path);
+      }
+    });
+    return result;
+  }
+
   String? getPathForUri(Uri uri) {
     var source = _sourceFactory.forUri2(uri);
     if (source == null) {

pkg/analyzer/lib/src/dart/micro/resolve_file.dart

@@ -18,10 +18,12 @@ import 'package:analyzer/src/dart/analysis/experiments.dart';
 import 'package:analyzer/src/dart/analysis/feature_set_provider.dart';
 import 'package:analyzer/src/dart/analysis/performance_logger.dart';
 import 'package:analyzer/src/dart/analysis/results.dart';
+import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/micro/analysis_context.dart';
 import 'package:analyzer/src/dart/micro/cider_byte_store.dart';
 import 'package:analyzer/src/dart/micro/library_analyzer.dart';
 import 'package:analyzer/src/dart/micro/library_graph.dart';
+import 'package:analyzer/src/dart/micro/utils.dart';
 import 'package:analyzer/src/exception/exception.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/source.dart';
@@ -36,11 +38,25 @@ import 'package:analyzer/src/task/options.dart';
 import 'package:analyzer/src/util/file_paths.dart' as file_paths;
 import 'package:analyzer/src/util/performance/operation_performance.dart';
 import 'package:analyzer/src/workspace/workspace.dart';
+import 'package:collection/collection.dart';
 import 'package:yaml/yaml.dart';
 
 const M = 1024 * 1024 /*1 MiB*/;
 const memoryCacheSize = 200 * M;
 
+class CiderSearchMatch {
+  final String path;
+  final List<int> offsets;
+
+  CiderSearchMatch(this.path, this.offsets);
+
+  @override
+  bool operator ==(Object object) =>
+      object is CiderSearchMatch &&
+      path == object.path &&
+      const ListEquality<int>().equals(offsets, object.offsets);
+}
+
 class FileContext {
   final AnalysisOptionsImpl analysisOptions;
   final FileState file;
@@ -54,13 +70,15 @@ class FileResolver {
   CiderByteStore byteStore;
   final SourceFactory sourceFactory;
 
-  /*
-   * A function that returns the digest for a file as a String. The function
-   * returns a non null value, can return an empty string if file does
-   * not exist/has no contents.
-   */
+  /// A function that returns the digest for a file as a String. The function
+  /// returns a non null value, can return an empty string if file does
+  /// not exist/has no contents.
   final String Function(String path) getFileDigest;
 
+  /// A function that returns true if the given file path is likely to be that
+  /// of a file that is generated.
+  final bool Function(String path)? isGenerated;
+
   /// A function that fetches the given list of files. This function can be used
   /// to batch file reads in systems where file fetches are expensive.
   final void Function(List<String> paths)? prefetchFiles;
@@ -96,6 +114,7 @@ class FileResolver {
     String Function(String path) getFileDigest,
     void Function(List<String> paths)? prefetchFiles, {
     required Workspace workspace,
+    bool Function(String path)? isGenerated,
     @deprecated Duration? libraryContextResetTimeout,
   }) : this.from(
           logger: logger,
@@ -104,6 +123,8 @@ class FileResolver {
           getFileDigest: getFileDigest,
           prefetchFiles: prefetchFiles,
           workspace: workspace,
+          isGenerated: isGenerated,
+
           // ignore: deprecated_member_use_from_same_package
           libraryContextResetTimeout: libraryContextResetTimeout,
         );
@@ -115,6 +136,7 @@ class FileResolver {
     required String Function(String path) getFileDigest,
     required void Function(List<String> paths)? prefetchFiles,
     required Workspace workspace,
+    bool Function(String path)? isGenerated,
     CiderByteStore? byteStore,
     @deprecated Duration? libraryContextResetTimeout,
   })  : logger = logger,
@@ -123,6 +145,7 @@ class FileResolver {
         getFileDigest = getFileDigest,
         prefetchFiles = prefetchFiles,
         workspace = workspace,
+        isGenerated = isGenerated,
         byteStore = byteStore ?? CiderCachedByteStore(memoryCacheSize);
 
   /// Update the resolver to reflect the fact that the file with the given
@@ -164,6 +187,31 @@ class FileResolver {
   @deprecated
   void dispose() {}
 
+  /// Looks for references to the Element at the given offset and path. All the
+  /// files currently cached by the resolver are searched, generated files are
+  /// ignored.
+  List<CiderSearchMatch> findReferences(int offset, String path,
+      {OperationPerformanceImpl? performance}) {
+    var references = <CiderSearchMatch>[];
+    var unit = resolve(path: path);
+    var node = NodeLocator(offset).searchWithin(unit.unit);
+    var element = getElementOfNode(node);
+    if (element != null) {
+      // TODO(keertip): check if element is named constructor.
+      var result = fsState!.getFilesContaining(element.displayName);
+      result.forEach((filePath) {
+        var resolved = resolve(path: filePath);
+        var collector = ReferencesCollector(element);
+        resolved.unit?.accept(collector);
+        var offsets = collector.offsets;
+        if (offsets.isNotEmpty) {
+          references.add(CiderSearchMatch(filePath, offsets));
+        }
+      });
+    }
+    return references;
+  }
+
   ErrorsResult getErrors({
     required String path,
     OperationPerformanceImpl? performance,
@@ -555,6 +603,7 @@ class FileResolver {
         featureSetProvider,
         getFileDigest,
         prefetchFiles,
+        isGenerated,
       );
     }
 

pkg/analyzer/lib/src/dart/micro/utils.dart

@@ -0,0 +1,176 @@
+// Copyright (c) 2021, 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 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/dart/ast/element_locator.dart';
+
+/// Return the [Element] of the given [node], or `null` if [node] is `null` or
+/// does not have an element.
+Element? getElementOfNode(AstNode? node) {
+  if (node == null) {
+    return null;
+  }
+  if (node is SimpleIdentifier && node.parent is LibraryIdentifier) {
+    node = node.parent;
+  }
+  if (node is LibraryIdentifier) {
+    node = node.parent;
+  }
+  if (node is StringLiteral && node.parent is UriBasedDirective) {
+    return null;
+  }
+  var element = ElementLocator.locate(node);
+  if (node is SimpleIdentifier && element is PrefixElement) {
+    var parent = node.parent;
+    if (parent is ImportDirective) {
+      element = parent.element;
+    } else {
+      element = _getImportElementInfo(node);
+    }
+  }
+  return element;
+}
+
+/// Return the [ImportElement] that declared [prefix] and imports [element].
+///
+/// [libraryElement] - the [LibraryElement] where reference is.
+/// [prefix] - the import prefix, maybe `null`.
+/// [element] - the referenced element.
+/// [importElementsMap] - the cache of [Element]s imported by [ImportElement]s.
+ImportElement? _getImportElement(LibraryElement libraryElement, String prefix,
+    Element element, Map<ImportElement, Set<Element>> importElementsMap) {
+  if (element.enclosingElement is! CompilationUnitElement) {
+    return null;
+  }
+  var usedLibrary = element.library;
+  // find ImportElement that imports used library with used prefix
+  List<ImportElement>? candidates;
+  for (var importElement in libraryElement.imports) {
+    // required library
+    if (importElement.importedLibrary != usedLibrary) {
+      continue;
+    }
+    // required prefix
+    var prefixElement = importElement.prefix;
+    if (prefixElement == null) {
+      continue;
+    }
+    if (prefix != prefixElement.name) {
+      continue;
+    }
+    // no combinators => only possible candidate
+    if (importElement.combinators.isEmpty) {
+      return importElement;
+    }
+    // OK, we have candidate
+    candidates ??= [];
+    candidates.add(importElement);
+  }
+  // no candidates, probably element is defined in this library
+  if (candidates == null) {
+    return null;
+  }
+  // one candidate
+  if (candidates.length == 1) {
+    return candidates[0];
+  }
+  // ensure that each ImportElement has set of elements
+  for (var importElement in candidates) {
+    if (importElementsMap.containsKey(importElement)) {
+      continue;
+    }
+    var namespace = importElement.namespace;
+    var elements = Set<Element>.from(namespace.definedNames.values);
+    importElementsMap[importElement] = elements;
+  }
+  // use import namespace to choose correct one
+  for (var entry in importElementsMap.entries) {
+    var importElement = entry.key;
+    var elements = entry.value;
+    if (elements.contains(element)) {
+      return importElement;
+    }
+  }
+  // not found
+  return null;
+}
+
+/// Returns the [ImportElement] that is referenced by [prefixNode] with a
+/// [PrefixElement], maybe `null`.
+ImportElement? _getImportElementInfo(SimpleIdentifier prefixNode) {
+  // prepare environment
+  var parent = prefixNode.parent;
+  var unit = prefixNode.thisOrAncestorOfType<CompilationUnit>();
+  var libraryElement = unit?.declaredElement?.library;
+  if (libraryElement == null) {
+    return null;
+  }
+  // prepare used element
+  Element? usedElement;
+  if (parent is PrefixedIdentifier) {
+    var prefixed = parent;
+    if (prefixed.prefix == prefixNode) {
+      usedElement = prefixed.staticElement;
+    }
+  } else if (parent is MethodInvocation) {
+    var invocation = parent;
+    if (invocation.target == prefixNode) {
+      usedElement = invocation.methodName.staticElement;
+    }
+  }
+  // we need used Element
+  if (usedElement == null) {
+    return null;
+  }
+  // find ImportElement
+  var prefix = prefixNode.name;
+  var importElementsMap = <ImportElement, Set<Element>>{};
+  return _getImportElement(
+      libraryElement, prefix, usedElement, importElementsMap);
+}
+
+class ReferencesCollector extends GeneralizingAstVisitor<void> {
+  final Element element;
+  final List<int> offsets = [];
+
+  ReferencesCollector(this.element);
+
+  @override
+  void visitAssignmentExpression(AssignmentExpression node) {
+    if (node.writeElement != null &&
+        node.writeElement is PropertyAccessorElement) {
+      var property = node.writeElement as PropertyAccessorElement;
+      if (property.variable == element || property == element) {
+        if (node.leftHandSide is SimpleIdentifier) {
+          offsets.add(node.leftHandSide.offset);
+        } else if (node.leftHandSide is PrefixedIdentifier) {
+          var prefixIdentifier = node.leftHandSide as PrefixedIdentifier;
+          offsets.add(prefixIdentifier.identifier.offset);
+        } else if (node.leftHandSide is PropertyAccess) {
+          var accessor = node.leftHandSide as PropertyAccess;
+          offsets.add(accessor.propertyName.offset);
+        }
+      }
+    }
+    if (node.readElement != null &&
+        node.readElement is PropertyAccessorElement) {
+      var property = node.readElement as PropertyAccessorElement;
+      if (property.variable == element) {
+        offsets.add(node.rightHandSide.offset);
+      }
+    }
+  }
+
+  @override
+  void visitSimpleIdentifier(SimpleIdentifier node) {
+    var e = node.staticElement;
+    if (e == element) {
+      offsets.add(node.offset);
+    } else if (e is PropertyAccessorElement && e.variable == element) {
+      offsets.add(node.offset);
+    }
+  }
+}

pkg/analyzer/test/src/dart/micro/file_resolution.dart

@@ -54,6 +54,7 @@ class FileResolutionTest with ResourceProviderMixin, ResolutionTest {
       getFileDigest: (String path) => _getDigest(path),
       workspace: workspace,
       prefetchFiles: null,
+      isGenerated: null,
     );
     fileResolver.testView = FileResolverTestView();
   }