Improve processing in FindRefs

src/Features/Core/Portable/CodeLens/CodeLensFindReferenceProgress.cs

@@ -58,14 +58,6 @@ public void OnCompleted()
     {
     }
 
-    public void OnFindInDocumentStarted(Document document)
-    {
-    }
-
-    public void OnFindInDocumentCompleted(Document document)
-    {
-    }
-
     private static bool FilterDefinition(ISymbol definition)
     {
         return definition.IsImplicitlyDeclared ||

src/Features/Core/Portable/FindUsages/AbstractFindUsagesService.ProgressAdapter.cs

@@ -5,6 +5,7 @@
 #nullable disable
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
@@ -73,8 +74,6 @@ public IStreamingProgressTracker ProgressTracker
         // any of these.
         public ValueTask OnStartedAsync(CancellationToken cancellationToken) => default;
         public ValueTask OnCompletedAsync(CancellationToken cancellationToken) => default;
-        public ValueTask OnFindInDocumentStartedAsync(Document document, CancellationToken cancellationToken) => default;
-        public ValueTask OnFindInDocumentCompletedAsync(Document document, CancellationToken cancellationToken) => default;
 
         // More complicated forwarding functions.  These need to map from the symbols
         // used by the FAR engine to the INavigableItems used by the streaming FAR 
@@ -107,17 +106,21 @@ public async ValueTask OnDefinitionFoundAsync(SymbolGroup group, CancellationTok
             await context.OnDefinitionFoundAsync(definitionItem, cancellationToken).ConfigureAwait(false);
         }
 
-        public async ValueTask OnReferenceFoundAsync(SymbolGroup group, ISymbol definition, ReferenceLocation location, CancellationToken cancellationToken)
+        public async ValueTask OnReferencesFoundAsync(
+            ImmutableArray<(SymbolGroup group, ISymbol symbol, ReferenceLocation location)> references, CancellationToken cancellationToken)
         {
-            var definitionItem = await GetDefinitionItemAsync(group, cancellationToken).ConfigureAwait(false);
-            var referenceItem = await location.TryCreateSourceReferenceItemAsync(
-                classificationOptions,
-                definitionItem,
-                includeHiddenLocations: false,
-                cancellationToken).ConfigureAwait(false);
-
-            if (referenceItem != null)
-                await context.OnReferenceFoundAsync(referenceItem, cancellationToken).ConfigureAwait(false);
+            foreach (var (group, _, location) in references)
+            {
+                var definitionItem = await GetDefinitionItemAsync(group, cancellationToken).ConfigureAwait(false);
+                var referenceItem = await location.TryCreateSourceReferenceItemAsync(
+                    classificationOptions,
+                    definitionItem,
+                    includeHiddenLocations: false,
+                    cancellationToken).ConfigureAwait(false);
+
+                if (referenceItem != null)
+                    await context.OnReferenceFoundAsync(referenceItem, cancellationToken).ConfigureAwait(false);
+            }
         }
     }
 }

src/Features/Core/Portable/GoToBase/AbstractGoToBaseService.cs

@@ -44,7 +44,7 @@ await context.ReportNoResultsAsync(
         var (symbol, project) = symbolAndProjectOpt.Value;
 
         var solution = project.Solution;
-        var bases = await FindBaseHelpers.FindBasesAsync(symbol, solution, cancellationToken).ConfigureAwait(false);
+        var bases = FindBaseHelpers.FindBases(symbol, solution, cancellationToken);
         if (bases.Length == 0 && symbol is IMethodSymbol { MethodKind: MethodKind.Constructor } constructor)
         {
             var nextConstructor = await FindNextConstructorInChainAsync(solution, constructor, cancellationToken).ConfigureAwait(false);

src/Features/Core/Portable/GoToBase/FindBaseHelpers.cs

@@ -14,7 +14,7 @@ namespace Microsoft.CodeAnalysis.GoToBase;
 
 internal static class FindBaseHelpers
 {
-    public static ValueTask<ImmutableArray<ISymbol>> FindBasesAsync(
+    public static ImmutableArray<ISymbol> FindBases(
         ISymbol symbol, Solution solution, CancellationToken cancellationToken)
     {
         if (symbol is INamedTypeSymbol
@@ -23,16 +23,12 @@ public static ValueTask<ImmutableArray<ISymbol>> FindBasesAsync(
             } namedTypeSymbol)
         {
             var result = BaseTypeFinder.FindBaseTypesAndInterfaces(namedTypeSymbol).CastArray<ISymbol>();
-            return ValueTaskFactory.FromResult(result);
+            return result;
         }
 
-        if (symbol.Kind is SymbolKind.Property or
-            SymbolKind.Method or
-            SymbolKind.Event)
-        {
-            return BaseTypeFinder.FindOverriddenAndImplementedMembersAsync(symbol, solution, cancellationToken);
-        }
+        if (symbol.Kind is SymbolKind.Property or SymbolKind.Method or SymbolKind.Event)
+            return BaseTypeFinder.FindOverriddenAndImplementedMembers(symbol, solution, cancellationToken);
 
-        return ValueTaskFactory.FromResult(ImmutableArray<ISymbol>.Empty);
+        return [];
     }
 }

src/Features/Core/Portable/ValueTracking/ValueTracker.FindReferencesProgress.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.FindSymbols;
@@ -28,11 +29,16 @@ private class FindReferencesProgress(OperationCollector valueTrackingProgressCol
 
         public ValueTask OnDefinitionFoundAsync(SymbolGroup symbolGroup, CancellationToken _) => new();
 
-        public ValueTask OnFindInDocumentCompletedAsync(Document document, CancellationToken _) => new();
-
-        public ValueTask OnFindInDocumentStartedAsync(Document document, CancellationToken _) => new();
+        public async ValueTask OnReferencesFoundAsync(
+            ImmutableArray<(SymbolGroup group, ISymbol symbol, ReferenceLocation location)> references,
+            CancellationToken cancellationToken)
+        {
+            foreach (var (_, symbol, location) in references)
+                await OnReferenceFoundAsync(symbol, location, cancellationToken).ConfigureAwait(false);
+        }
 
-        public async ValueTask OnReferenceFoundAsync(SymbolGroup _, ISymbol symbol, ReferenceLocation location, CancellationToken cancellationToken)
+        private async ValueTask OnReferenceFoundAsync(
+            ISymbol symbol, ReferenceLocation location, CancellationToken cancellationToken)
         {
             if (!location.Location.IsInSource)
             {

src/Workspaces/Core/Portable/FindSymbols/FindReferences/BaseTypeFinder.cs

@@ -15,10 +15,10 @@ internal static partial class BaseTypeFinder
     public static ImmutableArray<INamedTypeSymbol> FindBaseTypesAndInterfaces(INamedTypeSymbol type)
         => FindBaseTypes(type).AddRange(type.AllInterfaces);
 
-    public static async ValueTask<ImmutableArray<ISymbol>> FindOverriddenAndImplementedMembersAsync(
+    public static ImmutableArray<ISymbol> FindOverriddenAndImplementedMembers(
         ISymbol symbol, Solution solution, CancellationToken cancellationToken)
     {
-        var results = ArrayBuilder<ISymbol>.GetInstance();
+        using var _ = ArrayBuilder<ISymbol>.GetInstance(out var results);
 
         // This is called for all: class, struct or interface member.
         results.AddRange(symbol.ExplicitOrImplicitInterfaceImplementations());
@@ -31,7 +31,7 @@ public static async ValueTask<ImmutableArray<ISymbol>> FindOverriddenAndImplemen
                 cancellationToken.ThrowIfCancellationRequested();
 
                 // Add to results overridden members only. Do not add hidden members.
-                if (await SymbolFinder.IsOverrideAsync(solution, symbol, member, cancellationToken).ConfigureAwait(false))
+                if (SymbolFinder.IsOverride(solution, symbol, member))
                 {
                     results.Add(member);
 
@@ -64,7 +64,8 @@ public static async ValueTask<ImmutableArray<ISymbol>> FindOverriddenAndImplemen
         }
 
         // Remove duplicates from interface implementations before adding their projects.
-        return results.ToImmutableAndFree().Distinct();
+        results.RemoveDuplicates();
+        return results.ToImmutableAndClear();
     }
 
     private static ImmutableArray<INamedTypeSymbol> FindBaseTypes(INamedTypeSymbol type)

src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferenceCache.cs

@@ -32,29 +32,44 @@ public static async ValueTask<FindReferenceCache> GetCacheAsync(Document documen
 
         static async Task<FindReferenceCache> ComputeCacheAsync(Document document, CancellationToken cancellationToken)
         {
+            var text = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
+
             // Find-Refs is not impacted by nullable types at all.  So get a nullable-disabled semantic model to avoid
             // unnecessary costs while binding.
             var model = await document.GetRequiredNullableDisabledSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
-            return new(document, model, root);
+
+            // It's very costly to walk an entire tree.  So if the tree is simple and doesn't contain
+            // any unicode escapes in it, then we do simple string matching to find the tokens.
+            var index = await SyntaxTreeIndex.GetRequiredIndexAsync(document, cancellationToken).ConfigureAwait(false);
+
+            return new(document, text, model, root, index);
         }
     }
 
     public readonly Document Document;
+    public readonly SourceText Text;
     public readonly SemanticModel SemanticModel;
     public readonly SyntaxNode Root;
+    public readonly ISyntaxFactsService SyntaxFacts;
+    public readonly SyntaxTreeIndex SyntaxTreeIndex;
 
     private readonly ConcurrentDictionary<SyntaxNode, SymbolInfo> _symbolInfoCache = [];
     private readonly ConcurrentDictionary<string, ImmutableArray<SyntaxToken>> _identifierCache;
 
     private ImmutableHashSet<string>? _aliasNameSet;
     private ImmutableArray<SyntaxToken> _constructorInitializerCache;
 
-    private FindReferenceCache(Document document, SemanticModel semanticModel, SyntaxNode root)
+    private FindReferenceCache(
+        Document document, SourceText text, SemanticModel semanticModel, SyntaxNode root, SyntaxTreeIndex syntaxTreeIndex)
     {
         Document = document;
+        Text = text;
         SemanticModel = semanticModel;
         Root = root;
+        SyntaxTreeIndex = syntaxTreeIndex;
+        SyntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
+
         _identifierCache = new(comparer: semanticModel.Language switch
         {
             LanguageNames.VisualBasic => StringComparer.OrdinalIgnoreCase,
@@ -81,10 +96,8 @@ public SymbolInfo GetSymbolInfo(SyntaxNode node, CancellationToken cancellationT
         return null;
     }
 
-    public async ValueTask<ImmutableArray<SyntaxToken>> FindMatchingIdentifierTokensAsync(
-        Document document,
-        string identifier,
-        CancellationToken cancellationToken)
+    public ImmutableArray<SyntaxToken> FindMatchingIdentifierTokens(
+        string identifier, CancellationToken cancellationToken)
     {
         if (identifier == "")
         {
@@ -99,53 +112,32 @@ public async ValueTask<ImmutableArray<SyntaxToken>> FindMatchingIdentifierTokens
         if (_identifierCache.TryGetValue(identifier, out var result))
             return result;
 
-        // It's very costly to walk an entire tree.  So if the tree is simple and doesn't contain
-        // any unicode escapes in it, then we do simple string matching to find the tokens.
-        var info = await SyntaxTreeIndex.GetRequiredIndexAsync(document, cancellationToken).ConfigureAwait(false);
-
         // If this document doesn't even contain this identifier (escaped or non-escaped) we don't have to search it at all.
-        if (!info.ProbablyContainsIdentifier(identifier))
+        if (!this.SyntaxTreeIndex.ProbablyContainsIdentifier(identifier))
             return [];
 
-        return await ComputeAndCacheTokensAsync(this, document, identifier, info, cancellationToken).ConfigureAwait(false);
+        // If the identifier was escaped in the file then we'll have to do a more involved search that actually
+        // walks the root and checks all identifier tokens.
+        //
+        // otherwise, we can use the text of the document to quickly find candidates and test those directly.
+        return this.SyntaxTreeIndex.ProbablyContainsEscapedIdentifier(identifier)
+            ? _identifierCache.GetOrAdd(identifier, _ => FindMatchingIdentifierTokensFromTree())
+            : _identifierCache.GetOrAdd(identifier, _ => FindMatchingIdentifierTokensFromText());
 
-        static async ValueTask<ImmutableArray<SyntaxToken>> ComputeAndCacheTokensAsync(
-            FindReferenceCache cache, Document document, string identifier, SyntaxTreeIndex info, CancellationToken cancellationToken)
-        {
-            var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
-            var root = await cache.SemanticModel.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
-
-            // If the identifier was escaped in the file then we'll have to do a more involved search that actually
-            // walks the root and checks all identifier tokens.
-            //
-            // otherwise, we can use the text of the document to quickly find candidates and test those directly.
-            if (info.ProbablyContainsEscapedIdentifier(identifier))
-            {
-                return cache._identifierCache.GetOrAdd(
-                    identifier, _ => FindMatchingIdentifierTokensFromTree(syntaxFacts, identifier, root));
-            }
-            else
-            {
-                var text = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
-                return cache._identifierCache.GetOrAdd(
-                    identifier, _ => FindMatchingIdentifierTokensFromText(syntaxFacts, identifier, root, text, cancellationToken));
-            }
-        }
-
-        static bool IsMatch(ISyntaxFactsService syntaxFacts, string identifier, SyntaxToken token)
-            => !token.IsMissing && syntaxFacts.IsIdentifier(token) && syntaxFacts.TextMatch(token.ValueText, identifier);
+        bool IsMatch(string identifier, SyntaxToken token)
+            => !token.IsMissing && this.SyntaxFacts.IsIdentifier(token) && this.SyntaxFacts.TextMatch(token.ValueText, identifier);
 
-        static ImmutableArray<SyntaxToken> FindMatchingIdentifierTokensFromTree(
-            ISyntaxFactsService syntaxFacts, string identifier, SyntaxNode root)
+        ImmutableArray<SyntaxToken> FindMatchingIdentifierTokensFromTree()
         {
             using var _ = ArrayBuilder<SyntaxToken>.GetInstance(out var result);
             using var obj = SharedPools.Default<Stack<SyntaxNodeOrToken>>().GetPooledObject();
 
             var stack = obj.Object;
-            stack.Push(root);
+            stack.Push(this.Root);
 
             while (stack.TryPop(out var current))
             {
+                cancellationToken.ThrowIfCancellationRequested();
                 if (current.IsNode)
                 {
                     foreach (var child in current.AsNode()!.ChildNodesAndTokens().Reverse())
@@ -154,7 +146,7 @@ static ImmutableArray<SyntaxToken> FindMatchingIdentifierTokensFromTree(
                 else if (current.IsToken)
                 {
                     var token = current.AsToken();
-                    if (IsMatch(syntaxFacts, identifier, token))
+                    if (IsMatch(identifier, token))
                         result.Add(token);
 
                     if (token.HasStructuredTrivia)
@@ -172,19 +164,18 @@ static ImmutableArray<SyntaxToken> FindMatchingIdentifierTokensFromTree(
             return result.ToImmutableAndClear();
         }
 
-        static ImmutableArray<SyntaxToken> FindMatchingIdentifierTokensFromText(
-            ISyntaxFactsService syntaxFacts, string identifier, SyntaxNode root, SourceText sourceText, CancellationToken cancellationToken)
+        ImmutableArray<SyntaxToken> FindMatchingIdentifierTokensFromText()
         {
             using var _ = ArrayBuilder<SyntaxToken>.GetInstance(out var result);
 
             var index = 0;
-            while ((index = sourceText.IndexOf(identifier, index, syntaxFacts.IsCaseSensitive)) >= 0)
+            while ((index = this.Text.IndexOf(identifier, index, this.SyntaxFacts.IsCaseSensitive)) >= 0)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
-                var token = root.FindToken(index, findInsideTrivia: true);
+                var token = this.Root.FindToken(index, findInsideTrivia: true);
                 var span = token.Span;
-                if (span.Start == index && span.Length == identifier.Length && IsMatch(syntaxFacts, identifier, token))
+                if (span.Start == index && span.Length == identifier.Length && IsMatch(identifier, token))
                     result.Add(token);
 
                 var nextIndex = index + identifier.Length;

src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesProgress.cs

@@ -35,12 +35,4 @@ public void OnDefinitionFound(ISymbol symbol)
     public void OnReferenceFound(ISymbol symbol, ReferenceLocation location)
     {
     }
-
-    public void OnFindInDocumentStarted(Document document)
-    {
-    }
-
-    public void OnFindInDocumentCompleted(Document document)
-    {
-    }
 }