Move lsp handlers to async/await (attempt 2). (#81832)

CyrusNajmabadi · web-flow · commit 5e6a0e1a6d9b · 2026-01-06T13:59:32.000-05:00
diff --git a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionResolveHelper.cs b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionResolveHelper.cs
@@ -211,7 +211,7 @@ await AddTextDocumentEditsAsync(
 
         return new LSP.WorkspaceEdit { DocumentChanges = textDocumentEdits.ToArray() };
 
-        Task AddTextDocumentDeletionsAsync<TTextDocument>(
+        async Task AddTextDocumentDeletionsAsync<TTextDocument>(
             IEnumerable<DocumentId> removedDocuments,
             Func<DocumentId, TTextDocument?> getOldDocument)
             where TTextDocument : TextDocument
@@ -223,8 +223,6 @@ Task AddTextDocumentDeletionsAsync<TTextDocument>(
 
                 textDocumentEdits.Add(new DeleteFile { DocumentUri = oldTextDoc.GetURI() });
             }
-
-            return Task.CompletedTask;
         }
 
         async Task AddTextDocumentAdditionsAsync<TTextDocument>(
diff --git a/src/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs b/src/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs
@@ -44,25 +44,25 @@ public CompletionResolveHandler(IGlobalOptionService globalOptions)
     public LSP.TextDocumentIdentifier? GetTextDocumentIdentifier(LSP.CompletionItem request)
         => GetTextDocumentCacheEntry(request);
 
-    public Task<LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken)
+    public async Task<LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken)
     {
         var completionListCache = context.GetRequiredLspService<CompletionListCache>();
 
         if (!completionListCache.TryGetCompletionListCacheEntry(completionItem, out var cacheEntry))
         {
             // Don't have a cache associated with this completion item, cannot resolve.
             context.TraceWarning("No cache entry found for the provided completion item at resolve time.");
-            return Task.FromResult(completionItem);
+            return completionItem;
         }
 
         var document = context.GetRequiredDocument();
         var capabilityHelper = new CompletionCapabilityHelper(context.GetRequiredClientCapabilities());
 
-        return ResolveCompletionItemAsync(
-            completionItem, cacheEntry.CompletionList, document, _globalOptions, capabilityHelper, cancellationToken);
+        return await ResolveCompletionItemAsync(
+            completionItem, cacheEntry.CompletionList, document, _globalOptions, capabilityHelper, cancellationToken).ConfigureAwait(false);
     }
 
-    public static Task<LSP.CompletionItem> ResolveCompletionItemAsync(
+    public static async Task<LSP.CompletionItem> ResolveCompletionItemAsync(
         LSP.CompletionItem completionItem,
         Document document,
         IGlobalOptionService globalOptions,
@@ -73,11 +73,11 @@ public CompletionResolveHandler(IGlobalOptionService globalOptions)
         if (!completionListCache.TryGetCompletionListCacheEntry(completionItem, out var cacheEntry))
         {
             // Don't have a cache associated with this completion item, cannot resolve.
-            return Task.FromResult(completionItem);
+            return completionItem;
         }
 
-        return ResolveCompletionItemAsync(
-            completionItem, cacheEntry.CompletionList, document, globalOptions, capabilityHelper, cancellationToken);
+        return await ResolveCompletionItemAsync(
+            completionItem, cacheEntry.CompletionList, document, globalOptions, capabilityHelper, cancellationToken).ConfigureAwait(false);
     }
 
     private static async Task<LSP.CompletionItem> ResolveCompletionItemAsync(
diff --git a/src/LanguageServer/Protocol/Handler/Definitions/AbstractGoToDefinitionHandler.cs b/src/LanguageServer/Protocol/Handler/Definitions/AbstractGoToDefinitionHandler.cs
@@ -35,16 +35,16 @@ public AbstractGoToDefinitionHandler(IMetadataAsSourceFileService metadataAsSour
 
     public abstract Task<LSP.Location[]?> HandleRequestAsync(TextDocumentPositionParams request, RequestContext context, CancellationToken cancellationToken);
 
-    protected Task<LSP.Location[]?> GetDefinitionAsync(LSP.TextDocumentPositionParams request, bool forSymbolType, RequestContext context, CancellationToken cancellationToken)
+    protected async Task<LSP.Location[]?> GetDefinitionAsync(LSP.TextDocumentPositionParams request, bool forSymbolType, RequestContext context, CancellationToken cancellationToken)
     {
         var workspace = context.Workspace;
         var document = context.Document;
         if (workspace is null || document is null)
-            return SpecializedTasks.Null<LSP.Location[]>();
+            return null;
 
         var linePosition = ProtocolConversions.PositionToLinePosition(request.Position);
 
-        return GetDefinitionsAsync(_globalOptions, _metadataAsSourceFileService, workspace, document, forSymbolType, linePosition, cancellationToken);
+        return await GetDefinitionsAsync(_globalOptions, _metadataAsSourceFileService, workspace, document, forSymbolType, linePosition, cancellationToken).ConfigureAwait(false);
     }
 
     internal static async Task<LSP.Location[]?> GetDefinitionsAsync(IGlobalOptionService globalOptions, IMetadataAsSourceFileService? metadataAsSourceFileService, Workspace workspace, Document document, bool forSymbolType, LinePosition linePosition, CancellationToken cancellationToken)
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractDocumentPullDiagnosticHandler.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractDocumentPullDiagnosticHandler.cs
@@ -26,7 +26,7 @@ internal abstract class AbstractDocumentPullDiagnosticHandler<TDiagnosticsParams
 
     public abstract TextDocumentIdentifier? GetTextDocumentIdentifier(TDiagnosticsParams diagnosticsParams);
 
-    protected override ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken)
+    protected override async ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken)
     {
         // Note: context.Document may be null in the case where the client is asking about a document that we have
         // since removed from the workspace.  In this case, we don't really have anything to process.
@@ -38,15 +38,15 @@ protected override ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagno
         if (identifier is null || context.TextDocument is null)
         {
             context.TraceDebug("Ignoring diagnostics request because no text document was provided");
-            return new([]);
+            return [];
         }
 
         if (!context.IsTracking(identifier.DocumentUri))
         {
             context.TraceWarning($"Ignoring diagnostics request for untracked document: {identifier.DocumentUri}");
-            return new([]);
+            return [];
         }
 
-        return DiagnosticSourceManager.CreateDocumentDiagnosticSourcesAsync(context, requestDiagnosticCategory, cancellationToken);
+        return await DiagnosticSourceManager.CreateDocumentDiagnosticSourcesAsync(context, requestDiagnosticCategory, cancellationToken).ConfigureAwait(false);
     }
 }
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs
@@ -92,9 +92,8 @@ protected abstract ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagno
     /// Used by public workspace pull diagnostics to allow it to keep the connection open until
     /// changes occur to avoid the client spamming the server with requests.
     /// </summary>
-    protected virtual Task WaitForChangesAsync(string? category, RequestContext context, CancellationToken cancellationToken)
+    protected virtual async Task WaitForChangesAsync(string? category, RequestContext context, CancellationToken cancellationToken)
     {
-        return Task.CompletedTask;
     }
 
     public async Task<TReturn?> HandleRequestAsync(
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs
@@ -59,17 +59,17 @@ public void Dispose()
         _workspaceRegistrationService.LspSolutionChanged -= OnLspSolutionChanged;
     }
 
-    protected override ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken)
+    protected override async ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken)
     {
         if (context.ServerKind == WellKnownLspServerKinds.RazorLspServer)
         {
             // If we're being called from razor, we do not support WorkspaceDiagnostics at all.  For razor, workspace
             // diagnostics will be handled by razor itself, which will operate by calling into Roslyn and asking for
             // document-diagnostics instead.
-            return new([]);
+            return [];
         }
 
-        return DiagnosticSourceManager.CreateWorkspaceDiagnosticSourcesAsync(context, requestDiagnosticCategory, cancellationToken);
+        return await DiagnosticSourceManager.CreateWorkspaceDiagnosticSourcesAsync(context, requestDiagnosticCategory, cancellationToken).ConfigureAwait(false);
     }
 
     private void OnLspSolutionChanged(object? sender, WorkspaceChangeEventArgs e)
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSourceProviders/DocumentSyntaxAndSemanticDiagnosticSourceProvider.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSourceProviders/DocumentSyntaxAndSemanticDiagnosticSourceProvider.cs
@@ -22,9 +22,9 @@ internal abstract class AbstractDocumentSyntaxAndSemanticDiagnosticSourceProvide
 
     public bool IsEnabled(ClientCapabilities clientCapabilities) => true;
 
-    public ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)
+    public async ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)
     {
-        return new([new DocumentDiagnosticSource(kind, context.GetRequiredDocument())]);
+        return [new DocumentDiagnosticSource(kind, context.GetRequiredDocument())];
     }
 
     [Export(typeof(IDiagnosticSourceProvider)), Shared]
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractProjectDiagnosticSource.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractProjectDiagnosticSource.cs
@@ -59,7 +59,7 @@ public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(
     private sealed class CodeAnalysisDiagnosticSource(Project project, ICodeAnalysisDiagnosticAnalyzerService codeAnalysisService)
         : AbstractProjectDiagnosticSource(project)
     {
-        public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(
+        public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(
             RequestContext context,
             CancellationToken cancellationToken)
         {
@@ -69,7 +69,7 @@ public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(
             // user.  As such, it is definitely not "live" data, and it should be overridden by any subsequent fresh data
             // that has been produced.
             diagnostics = ProtocolConversions.AddBuildTagIfNotPresent(diagnostics);
-            return Task.FromResult(diagnostics);
+            return diagnostics;
         }
     }
 }
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs
@@ -94,7 +94,7 @@ AsyncLazy<ILookup<DocumentId, DiagnosticData>> GetLazyDiagnostics()
     private sealed class CodeAnalysisDiagnosticSource(TextDocument document, ICodeAnalysisDiagnosticAnalyzerService codeAnalysisService)
         : AbstractWorkspaceDocumentDiagnosticSource(document)
     {
-        public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(
+        public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(
             RequestContext context,
             CancellationToken cancellationToken)
         {
@@ -104,7 +104,7 @@ public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(
             // user.  As such, it is definitely not "live" data, and it should be overridden by any subsequent fresh data
             // that has been produced.
             diagnostics = ProtocolConversions.AddBuildTagIfNotPresent(diagnostics);
-            return Task.FromResult(diagnostics);
+            return diagnostics;
         }
     }
 }
diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentNonLocalDiagnosticSourceProvider.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentNonLocalDiagnosticSourceProvider.cs
@@ -28,15 +28,15 @@ internal sealed class PublicDocumentNonLocalDiagnosticSourceProvider(
 
     public bool IsEnabled(ClientCapabilities clientCapabilities) => true;
 
-    public ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)
+    public async ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)
     {
         // Non-local document diagnostics are reported only when full solution analysis is enabled for analyzer execution.
         if (globalOptions.GetBackgroundAnalysisScope(context.GetRequiredDocument().Project.Language) == BackgroundAnalysisScope.FullSolution)
         {
             // NOTE: Compiler does not report any non-local diagnostics, so we only ask to run non-compiler-analyzers.
-            return new([new NonLocalDocumentDiagnosticSource(context.GetRequiredDocument(), AnalyzerFilter.NonCompilerAnalyzer)]);
+            return [new NonLocalDocumentDiagnosticSource(context.GetRequiredDocument(), AnalyzerFilter.NonCompilerAnalyzer)];
         }
 
-        return new([]);
+        return [];
     }
 }
diff --git a/src/LanguageServer/Protocol/Handler/DocumentChanges/DidChangeHandler.cs b/src/LanguageServer/Protocol/Handler/DocumentChanges/DidChangeHandler.cs
@@ -26,15 +26,15 @@ internal class DidChangeHandler() : ILspServiceDocumentRequestHandler<DidChangeT
     public TextDocumentIdentifier GetTextDocumentIdentifier(DidChangeTextDocumentParams request)
         => request.TextDocument;
 
-    public Task<object?> HandleRequestAsync(DidChangeTextDocumentParams request, RequestContext context, CancellationToken cancellationToken)
+    public async Task<object?> HandleRequestAsync(DidChangeTextDocumentParams request, RequestContext context, CancellationToken cancellationToken)
     {
         var text = context.GetTrackedDocumentInfo(request.TextDocument.DocumentUri).SourceText;
 
         text = GetUpdatedSourceText(request.ContentChanges, text);
 
         context.UpdateTrackedDocument(request.TextDocument.DocumentUri, text, request.TextDocument.Version);
 
-        return SpecializedTasks.Default<object>();
+        return null;
     }
 
     internal static bool AreChangesInReverseOrder(TextDocumentContentChangeEvent[] contentChanges)
diff --git a/src/LanguageServer/Protocol/Handler/EditAndContinue/DocumentEditAndContinueDiagnosticSourceProvider.cs b/src/LanguageServer/Protocol/Handler/EditAndContinue/DocumentEditAndContinueDiagnosticSourceProvider.cs
@@ -23,8 +23,8 @@ internal sealed class DocumentEditAndContinueDiagnosticSourceProvider() : IDiagn
 
     public bool IsEnabled(ClientCapabilities capabilities) => true;
 
-    public ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)
+    public async ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)
     {
-        return new([EditAndContinueDiagnosticSource.CreateOpenDocumentSource(context.GetRequiredDocument())]);
+        return [EditAndContinueDiagnosticSource.CreateOpenDocumentSource(context.GetRequiredDocument())];
     }
 }
diff --git a/src/LanguageServer/Protocol/Handler/EditAndContinue/RegisterSolutionSnapshotHandler.cs b/src/LanguageServer/Protocol/Handler/EditAndContinue/RegisterSolutionSnapshotHandler.cs
@@ -30,10 +30,10 @@ public RegisterSolutionSnapshotHandler(ISolutionSnapshotRegistry registry)
     public bool MutatesSolutionState => false;
     public bool RequiresLSPSolution => true;
 
-    public Task<LspSolutionSnapshotId> HandleRequestAsync(RequestContext context, CancellationToken cancellationToken)
+    public async Task<LspSolutionSnapshotId> HandleRequestAsync(RequestContext context, CancellationToken cancellationToken)
     {
         Contract.ThrowIfNull(context.Solution);
         var id = _registry.RegisterSolutionSnapshot(context.Solution);
-        return Task.FromResult(new LspSolutionSnapshotId(id.Id));
+        return new LspSolutionSnapshotId(id.Id);
     }
 }
diff --git a/src/LanguageServer/Protocol/Handler/FoldingRanges/FoldingRangesHandler.cs b/src/LanguageServer/Protocol/Handler/FoldingRanges/FoldingRangesHandler.cs
@@ -36,14 +36,14 @@ public FoldingRangesHandler(IGlobalOptionService globalOptions)
 
     public TextDocumentIdentifier GetTextDocumentIdentifier(FoldingRangeParams request) => request.TextDocument;
 
-    public Task<FoldingRange[]?> HandleRequestAsync(FoldingRangeParams request, RequestContext context, CancellationToken cancellationToken)
+    public async Task<FoldingRange[]?> HandleRequestAsync(FoldingRangeParams request, RequestContext context, CancellationToken cancellationToken)
     {
         var document = context.Document;
         if (document is null)
-            return SpecializedTasks.Null<FoldingRange[]>();
+            return null;
 
         var lineFoldingOnly = context.GetRequiredClientCapabilities().TextDocument?.FoldingRange?.LineFoldingOnly == true;
-        return SpecializedTasks.AsNullable(GetFoldingRangesAsync(_globalOptions, document, lineFoldingOnly, cancellationToken));
+        return await SpecializedTasks.AsNullable(GetFoldingRangesAsync(_globalOptions, document, lineFoldingOnly, cancellationToken)).ConfigureAwait(false);
     }
 
     internal static Task<FoldingRange[]> GetFoldingRangesAsync(
diff --git a/src/LanguageServer/Protocol/Handler/Highlights/DocumentHighlightHandler.cs b/src/LanguageServer/Protocol/Handler/Highlights/DocumentHighlightHandler.cs
@@ -40,14 +40,14 @@ public DocumentHighlightsHandler(IHighlightingService highlightingService, IGlob
 
     public TextDocumentIdentifier GetTextDocumentIdentifier(TextDocumentPositionParams request) => request.TextDocument;
 
-    public Task<DocumentHighlight[]?> HandleRequestAsync(TextDocumentPositionParams request, RequestContext context, CancellationToken cancellationToken)
+    public async Task<DocumentHighlight[]?> HandleRequestAsync(TextDocumentPositionParams request, RequestContext context, CancellationToken cancellationToken)
     {
         var document = context.Document;
         if (document == null)
-            return SpecializedTasks.Null<DocumentHighlight[]>();
+            return null;
 
         var position = ProtocolConversions.PositionToLinePosition(request.Position);
-        return GetHighlightsAsync(_globalOptions, _highlightingService, document, position, cancellationToken);
+        return await GetHighlightsAsync(_globalOptions, _highlightingService, document, position, cancellationToken).ConfigureAwait(false);
     }
 
     internal static async Task<DocumentHighlight[]?> GetHighlightsAsync(IGlobalOptionService globalOptions, IHighlightingService highlightingService, Document document, LinePosition linePosition, CancellationToken cancellationToken)
diff --git a/src/LanguageServer/Protocol/Handler/OnAutoInsert/OnAutoInsertHandler.cs b/src/LanguageServer/Protocol/Handler/OnAutoInsert/OnAutoInsertHandler.cs
@@ -42,18 +42,18 @@ internal sealed class OnAutoInsertHandler(
 
     public LSP.TextDocumentIdentifier GetTextDocumentIdentifier(LSP.VSInternalDocumentOnAutoInsertParams request) => request.TextDocument;
 
-    public Task<LSP.VSInternalDocumentOnAutoInsertResponseItem?> HandleRequestAsync(
+    public async Task<LSP.VSInternalDocumentOnAutoInsertResponseItem?> HandleRequestAsync(
         LSP.VSInternalDocumentOnAutoInsertParams request,
         RequestContext context,
         CancellationToken cancellationToken)
     {
         var document = context.Document;
         if (document == null)
-            return SpecializedTasks.Null<LSP.VSInternalDocumentOnAutoInsertResponseItem>();
+            return null;
 
         var onAutoInsertEnabled = _globalOptions.GetOption(LspOptionsStorage.LspEnableAutoInsert, document.Project.Language);
         if (!onAutoInsertEnabled)
-            return SpecializedTasks.Null<LSP.VSInternalDocumentOnAutoInsertResponseItem>();
+            return null;
 
         var servicesForDocument = _braceCompletionServices.SelectAsArray(s => s.Metadata.Language == document.Project.Language, s => s.Value);
         var isRazorRequest = context.ServerKind == WellKnownLspServerKinds.RazorLspServer;
@@ -63,7 +63,7 @@ internal sealed class OnAutoInsertHandler(
         // We want adjust the braces after enter for razor and non-VS clients.
         // We don't do this via on type formatting as it does not support snippets.
         var includeNewLineBraceFormatting = isRazorRequest || !supportsVSExtensions;
-        return GetOnAutoInsertResponseAsync(_globalOptions, servicesForDocument, document, position, request.Character, request.Options, includeNewLineBraceFormatting, cancellationToken);
+        return await GetOnAutoInsertResponseAsync(_globalOptions, servicesForDocument, document, position, request.Character, request.Options, includeNewLineBraceFormatting, cancellationToken).ConfigureAwait(false);
     }
 
     internal static async Task<LSP.VSInternalDocumentOnAutoInsertResponseItem?> GetOnAutoInsertResponseAsync(
diff --git a/src/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs b/src/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs
diff --git a/src/LanguageServer/Protocol/Handler/References/FindUsagesLSPContext.cs b/src/LanguageServer/Protocol/Handler/References/FindUsagesLSPContext.cs
diff --git a/src/LanguageServer/Protocol/Handler/ServerLifetime/InitializeHandler.cs b/src/LanguageServer/Protocol/Handler/ServerLifetime/InitializeHandler.cs
diff --git a/src/LanguageServer/Protocol/Handler/ServerLifetime/LspServiceLifeCycleManager.cs b/src/LanguageServer/Protocol/Handler/ServerLifetime/LspServiceLifeCycleManager.cs
diff --git a/src/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs b/src/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs
diff --git a/src/LanguageServer/Protocol/Handler/Tasks/DocumentTaskDiagnosticSourceProvider.cs b/src/LanguageServer/Protocol/Handler/Tasks/DocumentTaskDiagnosticSourceProvider.cs
diff --git a/src/LanguageServer/Protocol/Handler/Tasks/WorkspaceTaskDiagnosticSourceProvider.cs b/src/LanguageServer/Protocol/Handler/Tasks/WorkspaceTaskDiagnosticSourceProvider.cs
diff --git a/src/LanguageServer/Protocol/Handler/WorkDoneProgress/WorkDoneProgressCancelledHandler.cs b/src/LanguageServer/Protocol/Handler/WorkDoneProgress/WorkDoneProgressCancelledHandler.cs

Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,7 @@ await AddTextDocumentEditsAsync(`
`211`	`211`
`212`	`212`	`return new LSP.WorkspaceEdit { DocumentChanges = textDocumentEdits.ToArray() };`
`213`	`213`
`214`		`- Task AddTextDocumentDeletionsAsync<TTextDocument>(`
	`214`	`+ async Task AddTextDocumentDeletionsAsync<TTextDocument>(`
`215`	`215`	`IEnumerable<DocumentId> removedDocuments,`
`216`	`216`	`Func<DocumentId, TTextDocument?> getOldDocument)`
`217`	`217`	`where TTextDocument : TextDocument`
`@@ -223,8 +223,6 @@ Task AddTextDocumentDeletionsAsync<TTextDocument>(`
`223`	`223`
`224`	`224`	`textDocumentEdits.Add(new DeleteFile { DocumentUri = oldTextDoc.GetURI() });`
`225`	`225`	`}`
`226`		`-`
`227`		`- return Task.CompletedTask;`
`228`	`226`	`}`
`229`	`227`
`230`	`228`	`async Task AddTextDocumentAdditionsAsync<TTextDocument>(`
Original file line number	Diff line number	Diff line change
`@@ -44,25 +44,25 @@ public CompletionResolveHandler(IGlobalOptionService globalOptions)`
`44`	`44`	`public LSP.TextDocumentIdentifier? GetTextDocumentIdentifier(LSP.CompletionItem request)`
`45`	`45`	`=> GetTextDocumentCacheEntry(request);`
`46`	`46`
`47`		`- public Task<LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken)`
	`47`	`+ public async Task<LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken)`
`48`	`48`	`{`
`49`	`49`	`var completionListCache = context.GetRequiredLspService<CompletionListCache>();`
`50`	`50`
`51`	`51`	`if (!completionListCache.TryGetCompletionListCacheEntry(completionItem, out var cacheEntry))`
`52`	`52`	`{`
`53`	`53`	`// Don't have a cache associated with this completion item, cannot resolve.`
`54`	`54`	`context.TraceWarning("No cache entry found for the provided completion item at resolve time.");`
`55`		`- return Task.FromResult(completionItem);`
	`55`	`+ return completionItem;`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`var document = context.GetRequiredDocument();`
`59`	`59`	`var capabilityHelper = new CompletionCapabilityHelper(context.GetRequiredClientCapabilities());`
`60`	`60`
`61`		`- return ResolveCompletionItemAsync(`
`62`		`- completionItem, cacheEntry.CompletionList, document, _globalOptions, capabilityHelper, cancellationToken);`
	`61`	`+ return await ResolveCompletionItemAsync(`
	`62`	`+ completionItem, cacheEntry.CompletionList, document, _globalOptions, capabilityHelper, cancellationToken).ConfigureAwait(false);`
`63`	`63`	`}`
`64`	`64`
`65`		`- public static Task<LSP.CompletionItem> ResolveCompletionItemAsync(`
	`65`	`+ public static async Task<LSP.CompletionItem> ResolveCompletionItemAsync(`
`66`	`66`	`LSP.CompletionItem completionItem,`
`67`	`67`	`Document document,`
`68`	`68`	`IGlobalOptionService globalOptions,`
`@@ -73,11 +73,11 @@ public CompletionResolveHandler(IGlobalOptionService globalOptions)`
`73`	`73`	`if (!completionListCache.TryGetCompletionListCacheEntry(completionItem, out var cacheEntry))`
`74`	`74`	`{`
`75`	`75`	`// Don't have a cache associated with this completion item, cannot resolve.`
`76`		`- return Task.FromResult(completionItem);`
	`76`	`+ return completionItem;`
`77`	`77`	`}`
`78`	`78`
`79`		`- return ResolveCompletionItemAsync(`
`80`		`- completionItem, cacheEntry.CompletionList, document, globalOptions, capabilityHelper, cancellationToken);`
	`79`	`+ return await ResolveCompletionItemAsync(`
	`80`	`+ completionItem, cacheEntry.CompletionList, document, globalOptions, capabilityHelper, cancellationToken).ConfigureAwait(false);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`private static async Task<LSP.CompletionItem> ResolveCompletionItemAsync(`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ internal abstract class AbstractDocumentPullDiagnosticHandler<TDiagnosticsParams`
`26`	`26`
`27`	`27`	`public abstract TextDocumentIdentifier? GetTextDocumentIdentifier(TDiagnosticsParams diagnosticsParams);`
`28`	`28`
`29`		`- protected override ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken)`
	`29`	`+ protected override async ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken)`
`30`	`30`	`{`
`31`	`31`	`// Note: context.Document may be null in the case where the client is asking about a document that we have`
`32`	`32`	`// since removed from the workspace. In this case, we don't really have anything to process.`
`@@ -38,15 +38,15 @@ protected override ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagno`
`38`	`38`	`if (identifier is null \|\| context.TextDocument is null)`
`39`	`39`	`{`
`40`	`40`	`context.TraceDebug("Ignoring diagnostics request because no text document was provided");`
`41`		`- return new([]);`
	`41`	`+ return [];`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`if (!context.IsTracking(identifier.DocumentUri))`
`45`	`45`	`{`
`46`	`46`	`context.TraceWarning($"Ignoring diagnostics request for untracked document: {identifier.DocumentUri}");`
`47`		`- return new([]);`
	`47`	`+ return [];`
`48`	`48`	`}`
`49`	`49`
`50`		`- return DiagnosticSourceManager.CreateDocumentDiagnosticSourcesAsync(context, requestDiagnosticCategory, cancellationToken);`
	`50`	`+ return await DiagnosticSourceManager.CreateDocumentDiagnosticSourcesAsync(context, requestDiagnosticCategory, cancellationToken).ConfigureAwait(false);`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,9 +92,8 @@ protected abstract ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagno`
`92`	`92`	`/// Used by public workspace pull diagnostics to allow it to keep the connection open until`
`93`	`93`	`/// changes occur to avoid the client spamming the server with requests.`
`94`	`94`	`/// </summary>`
`95`		`- protected virtual Task WaitForChangesAsync(string? category, RequestContext context, CancellationToken cancellationToken)`
	`95`	`+ protected virtual async Task WaitForChangesAsync(string? category, RequestContext context, CancellationToken cancellationToken)`
`96`	`96`	`{`
`97`		`- return Task.CompletedTask;`
`98`	`97`	`}`
`99`	`98`
`100`	`99`	`public async Task<TReturn?> HandleRequestAsync(`
Original file line number	Diff line number	Diff line change
`@@ -59,17 +59,17 @@ public void Dispose()`
`59`	`59`	`_workspaceRegistrationService.LspSolutionChanged -= OnLspSolutionChanged;`
`60`	`60`	`}`
`61`	`61`
`62`		`- protected override ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken)`
	`62`	`+ protected override async ValueTask<ImmutableArray<IDiagnosticSource>> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken)`
`63`	`63`	`{`
`64`	`64`	`if (context.ServerKind == WellKnownLspServerKinds.RazorLspServer)`
`65`	`65`	`{`
`66`	`66`	`// If we're being called from razor, we do not support WorkspaceDiagnostics at all. For razor, workspace`
`67`	`67`	`// diagnostics will be handled by razor itself, which will operate by calling into Roslyn and asking for`
`68`	`68`	`// document-diagnostics instead.`
`69`		`- return new([]);`
	`69`	`+ return [];`
`70`	`70`	`}`
`71`	`71`
`72`		`- return DiagnosticSourceManager.CreateWorkspaceDiagnosticSourcesAsync(context, requestDiagnosticCategory, cancellationToken);`
	`72`	`+ return await DiagnosticSourceManager.CreateWorkspaceDiagnosticSourcesAsync(context, requestDiagnosticCategory, cancellationToken).ConfigureAwait(false);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`private void OnLspSolutionChanged(object? sender, WorkspaceChangeEventArgs e)`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,9 @@ internal abstract class AbstractDocumentSyntaxAndSemanticDiagnosticSourceProvide`
`22`	`22`
`23`	`23`	`public bool IsEnabled(ClientCapabilities clientCapabilities) => true;`
`24`	`24`
`25`		`- public ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)`
	`25`	`+ public async ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)`
`26`	`26`	`{`
`27`		`- return new([new DocumentDiagnosticSource(kind, context.GetRequiredDocument())]);`
	`27`	`+ return [new DocumentDiagnosticSource(kind, context.GetRequiredDocument())];`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`[Export(typeof(IDiagnosticSourceProvider)), Shared]`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(`
`59`	`59`	`private sealed class CodeAnalysisDiagnosticSource(Project project, ICodeAnalysisDiagnosticAnalyzerService codeAnalysisService)`
`60`	`60`	`: AbstractProjectDiagnosticSource(project)`
`61`	`61`	`{`
`62`		`- public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(`
	`62`	`+ public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(`
`63`	`63`	`RequestContext context,`
`64`	`64`	`CancellationToken cancellationToken)`
`65`	`65`	`{`
`@@ -69,7 +69,7 @@ public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(`
`69`	`69`	`// user. As such, it is definitely not "live" data, and it should be overridden by any subsequent fresh data`
`70`	`70`	`// that has been produced.`
`71`	`71`	`diagnostics = ProtocolConversions.AddBuildTagIfNotPresent(diagnostics);`
`72`		`- return Task.FromResult(diagnostics);`
	`72`	`+ return diagnostics;`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ AsyncLazy<ILookup<DocumentId, DiagnosticData>> GetLazyDiagnostics()`
`94`	`94`	`private sealed class CodeAnalysisDiagnosticSource(TextDocument document, ICodeAnalysisDiagnosticAnalyzerService codeAnalysisService)`
`95`	`95`	`: AbstractWorkspaceDocumentDiagnosticSource(document)`
`96`	`96`	`{`
`97`		`- public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(`
	`97`	`+ public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(`
`98`	`98`	`RequestContext context,`
`99`	`99`	`CancellationToken cancellationToken)`
`100`	`100`	`{`
`@@ -104,7 +104,7 @@ public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(`
`104`	`104`	`// user. As such, it is definitely not "live" data, and it should be overridden by any subsequent fresh data`
`105`	`105`	`// that has been produced.`
`106`	`106`	`diagnostics = ProtocolConversions.AddBuildTagIfNotPresent(diagnostics);`
`107`		`- return Task.FromResult(diagnostics);`
	`107`	`+ return diagnostics;`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,15 +28,15 @@ internal sealed class PublicDocumentNonLocalDiagnosticSourceProvider(`
`28`	`28`
`29`	`29`	`public bool IsEnabled(ClientCapabilities clientCapabilities) => true;`
`30`	`30`
`31`		`- public ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)`
	`31`	`+ public async ValueTask<ImmutableArray<IDiagnosticSource>> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken)`
`32`	`32`	`{`
`33`	`33`	`// Non-local document diagnostics are reported only when full solution analysis is enabled for analyzer execution.`
`34`	`34`	`if (globalOptions.GetBackgroundAnalysisScope(context.GetRequiredDocument().Project.Language) == BackgroundAnalysisScope.FullSolution)`
`35`	`35`	`{`
`36`	`36`	`// NOTE: Compiler does not report any non-local diagnostics, so we only ask to run non-compiler-analyzers.`
`37`		`- return new([new NonLocalDocumentDiagnosticSource(context.GetRequiredDocument(), AnalyzerFilter.NonCompilerAnalyzer)]);`
	`37`	`+ return [new NonLocalDocumentDiagnosticSource(context.GetRequiredDocument(), AnalyzerFilter.NonCompilerAnalyzer)];`
`38`	`38`	`}`
`39`	`39`
`40`		`- return new([]);`
	`40`	`+ return [];`
`41`	`41`	`}`
`42`	`42`	`}`