Expose FAR to cohosting

src/LanguageServer/Protocol/Handler/References/FindAllReferencesHandler.cs

@@ -14,6 +14,7 @@
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.Text;
 using Roslyn.LanguageServer.Protocol;
 using Roslyn.Utilities;
 using LSP = Roslyn.LanguageServer.Protocol;
@@ -45,7 +46,7 @@ public FindAllReferencesHandler(
 
         public TextDocumentIdentifier GetTextDocumentIdentifier(VSInternalReferenceParams request) => request.TextDocument;
 
-        public async Task<LSP.SumType<VSInternalReferenceItem, LSP.Location>[]?> HandleRequestAsync(
+        public async Task<SumType<VSInternalReferenceItem, LSP.Location>[]?> HandleRequestAsync(
             VSInternalReferenceParams referenceParams,
             RequestContext context,
             CancellationToken cancellationToken)
@@ -55,23 +56,37 @@ public FindAllReferencesHandler(
             Contract.ThrowIfNull(document);
             Contract.ThrowIfNull(workspace);
 
+            var linePosition = ProtocolConversions.PositionToLinePosition(referenceParams.Position);
+            var clientCapabilities = context.GetRequiredClientCapabilities();
+
             using var progress = BufferedProgress.Create(referenceParams.PartialResultToken);
 
-            var findUsagesService = document.GetRequiredLanguageService<IFindUsagesLSPService>();
-            var position = await document.GetPositionFromLinePositionAsync(
-                ProtocolConversions.PositionToLinePosition(referenceParams.Position), cancellationToken).ConfigureAwait(false);
+            await FindReferencesAsync(progress, workspace, document, linePosition, clientCapabilities.HasVisualStudioLspCapability(), _globalOptions, _metadataAsSourceFileService, _asyncListener, cancellationToken).ConfigureAwait(false);
 
-            var clientCapabilities = context.GetRequiredClientCapabilities();
+            return progress.GetFlattenedValues();
+        }
+
+        internal static async Task FindReferencesAsync(
+            IProgress<SumType<VSInternalReferenceItem, LSP.Location>[]> progress,
+            Workspace workspace,
+            Document document,
+            LinePosition linePosition,
+            bool supportsVSExtensions,
+            IGlobalOptionService globalOptions,
+            IMetadataAsSourceFileService metadataAsSourceFileService,
+            IAsynchronousOperationListener asyncListener,
+            CancellationToken cancellationToken)
+        {
+            var findUsagesService = document.GetRequiredLanguageService<IFindUsagesLSPService>();
+            var position = await document.GetPositionFromLinePositionAsync(linePosition, cancellationToken).ConfigureAwait(false);
 
             var findUsagesContext = new FindUsagesLSPContext(
-                progress, workspace, document, position, _metadataAsSourceFileService, _asyncListener, _globalOptions, clientCapabilities, cancellationToken);
+                progress, workspace, document, position, metadataAsSourceFileService, asyncListener, globalOptions, supportsVSExtensions, cancellationToken);
 
             // Finds the references for the symbol at the specific position in the document, reporting them via streaming to the LSP client.
-            var classificationOptions = _globalOptions.GetClassificationOptionsProvider();
+            var classificationOptions = globalOptions.GetClassificationOptionsProvider();
             await findUsagesService.FindReferencesAsync(findUsagesContext, document, position, classificationOptions, cancellationToken).ConfigureAwait(false);
             await findUsagesContext.OnCompletedAsync(cancellationToken).ConfigureAwait(false);
-
-            return progress.GetFlattenedValues();
         }
     }
 }

src/LanguageServer/Protocol/Handler/References/FindUsagesLSPContext.cs

@@ -80,7 +80,7 @@ public FindUsagesLSPContext(
             IMetadataAsSourceFileService metadataAsSourceFileService,
             IAsynchronousOperationListener asyncListener,
             IGlobalOptionService globalOptions,
-            ClientCapabilities clientCapabilities,
+            bool supportsVSExtensions,
             CancellationToken cancellationToken)
         {
             _progress = progress;
@@ -89,7 +89,7 @@ public FindUsagesLSPContext(
             _position = position;
             _metadataAsSourceFileService = metadataAsSourceFileService;
             _globalOptions = globalOptions;
-            _supportsVSExtensions = clientCapabilities.HasVisualStudioLspCapability();
+            _supportsVSExtensions = supportsVSExtensions;
             _workQueue = new AsyncBatchingWorkQueue<SumType<VSInternalReferenceItem, LSP.Location>>(
                 DelayTimeSpan.Medium, ReportReferencesAsync, asyncListener, cancellationToken);
         }

src/Tools/ExternalAccess/Razor/Cohost/Handlers/DocumentSymbols.cs

@@ -19,9 +19,4 @@ public static Task<SumType<DocumentSymbol[], SymbolInformation[]>> GetDocumentSy
         // with a VSImageId. This value should be retrieved from the language server's client capabilities.
         return DocumentSymbolsHandler.GetDocumentSymbolsAsync(document, useHierarchicalSymbols, supportsVSExtensions, cancellationToken);
     }
-
-    [Obsolete("Update to call overload that takes 'supportsVSExtensions' argument.")]
-    public static Task<SumType<DocumentSymbol[], SymbolInformation[]>> GetDocumentSymbolsAsync(
-        Document document, bool useHierarchicalSymbols, CancellationToken cancellationToken)
-        => GetDocumentSymbolsAsync(document, useHierarchicalSymbols, supportsVSExtensions: false, cancellationToken);
 }

src/Tools/ExternalAccess/Razor/Cohost/Handlers/FindAllReferences.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// 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.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.LanguageServer.Handler;
+using Microsoft.CodeAnalysis.MetadataAsSource;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.Text;
+using Roslyn.LanguageServer.Protocol;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.Razor.Cohost.Handlers;
+
+using Location = Roslyn.LanguageServer.Protocol.Location;
+
+internal static class FindAllReferences
+{
+    public static async Task<SumType<VSInternalReferenceItem, Location>[]?> FindReferencesAsync(Workspace workspace, Document document, LinePosition linePosition, bool supportsVSExtensions, CancellationToken cancellationToken)
+    {
+        var globalOptions = document.Project.Solution.Services.ExportProvider.GetService<IGlobalOptionService>();
+        var metadataAsSourceFileService = document.Project.Solution.Services.ExportProvider.GetService<IMetadataAsSourceFileService>();
+
+        // Passing null here means this will just collect items in an array builder
+        var progress = BufferedProgress.Create<SumType<VSInternalReferenceItem, Location>[]>(progress: null);
+
+        await FindAllReferencesHandler.FindReferencesAsync(progress, workspace, document, linePosition, supportsVSExtensions, globalOptions, metadataAsSourceFileService, AsynchronousOperationListenerProvider.NullListener, cancellationToken).ConfigureAwait(false);
+
+        return progress.GetFlattenedValues();
+    }
+}