diff --git a/src/LanguageServer/Protocol/Handler/AbstractRefreshQueue.cs b/src/LanguageServer/Protocol/Handler/AbstractRefreshQueue.cs index 436a66f1f83f6..be7649213ec92 100644 --- a/src/LanguageServer/Protocol/Handler/AbstractRefreshQueue.cs +++ b/src/LanguageServer/Protocol/Handler/AbstractRefreshQueue.cs @@ -50,10 +50,9 @@ public AbstractRefreshQueue( _notificationManager = notificationManager; } - public Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestContext context, CancellationToken cancellationToken) + public async Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestContext context, CancellationToken cancellationToken) { Initialize(clientCapabilities); - return Task.CompletedTask; } public void Initialize(ClientCapabilities clientCapabilities) @@ -104,7 +103,7 @@ protected void EnqueueRefreshNotification(DocumentUri? documentUri) } } - private ValueTask FilterLspTrackedDocumentsAsync( + private async ValueTask FilterLspTrackedDocumentsAsync( LspWorkspaceManager lspWorkspaceManager, IClientLanguageServerManager notificationManager, ImmutableSegmentedList documentUris, @@ -117,7 +116,7 @@ private ValueTask FilterLspTrackedDocumentsAsync( { try { - return notificationManager.SendRequestAsync(GetWorkspaceRefreshName(), cancellationToken); + await notificationManager.SendRequestAsync(GetWorkspaceRefreshName(), cancellationToken).ConfigureAwait(false); } catch (Exception ex) when (ex is ObjectDisposedException or ConnectionLostException) { @@ -128,7 +127,6 @@ private ValueTask FilterLspTrackedDocumentsAsync( } // LSP is already tracking all changed documents so we don't need to send a refresh request. - return ValueTask.CompletedTask; } public virtual void Dispose() diff --git a/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionResolveHelper.cs b/src/LanguageServer/Protocol/Handler/CodeActions/CodeActionResolveHelper.cs index 43b9ed45e3b73..7e0b42b94c06b 100644 --- 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( + async Task AddTextDocumentDeletionsAsync( IEnumerable removedDocuments, Func getOldDocument) where TTextDocument : TextDocument @@ -223,8 +223,6 @@ Task AddTextDocumentDeletionsAsync( textDocumentEdits.Add(new DeleteFile { DocumentUri = oldTextDoc.GetURI() }); } - - return Task.CompletedTask; } async Task AddTextDocumentAdditionsAsync( diff --git a/src/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs b/src/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs index b683cde8c423a..944dc39f497eb 100644 --- a/src/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs +++ b/src/LanguageServer/Protocol/Handler/Completion/CompletionResolveHandler.cs @@ -44,7 +44,7 @@ public CompletionResolveHandler(IGlobalOptionService globalOptions) public LSP.TextDocumentIdentifier? GetTextDocumentIdentifier(LSP.CompletionItem request) => GetTextDocumentCacheEntry(request); - public Task HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken) + public async Task HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken) { var completionListCache = context.GetRequiredLspService(); @@ -52,17 +52,17 @@ public CompletionResolveHandler(IGlobalOptionService globalOptions) { // 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 ResolveCompletionItemAsync( + public static async Task 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 ResolveCompletionItemAsync( diff --git a/src/LanguageServer/Protocol/Handler/Definitions/AbstractGoToDefinitionHandler.cs b/src/LanguageServer/Protocol/Handler/Definitions/AbstractGoToDefinitionHandler.cs index c6499a9cf4f6a..39ca0567950e2 100644 --- 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 HandleRequestAsync(TextDocumentPositionParams request, RequestContext context, CancellationToken cancellationToken); - protected Task GetDefinitionAsync(LSP.TextDocumentPositionParams request, bool forSymbolType, RequestContext context, CancellationToken cancellationToken) + protected async Task 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(); + 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 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 index aa35b95813701..c61ea8b330837 100644 --- a/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractDocumentPullDiagnosticHandler.cs +++ b/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractDocumentPullDiagnosticHandler.cs @@ -26,7 +26,7 @@ internal abstract class AbstractDocumentPullDiagnosticHandler> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken) + protected override async ValueTask> 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> 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 index b1490635f95ef..5d858f2452d5d 100644 --- a/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs +++ b/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractPullDiagnosticHandler.cs @@ -92,9 +92,8 @@ protected abstract ValueTask> 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. /// - 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 HandleRequestAsync( diff --git a/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs b/src/LanguageServer/Protocol/Handler/Diagnostics/AbstractWorkspacePullDiagnosticsHandler.cs index 2ba8cae14e540..00d487b59e98c 100644 --- 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> GetOrderedDiagnosticSourcesAsync(TDiagnosticsParams diagnosticsParams, string? requestDiagnosticCategory, RequestContext context, CancellationToken cancellationToken) + protected override async ValueTask> 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 index e7be797f951aa..4cd7ef82b419d 100644 --- 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> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken) + public async ValueTask> 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 index fd3cd71ac1f8d..600d07c6189d1 100644 --- 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> GetDiagnosticsAsync( private sealed class CodeAnalysisDiagnosticSource(Project project, ICodeAnalysisDiagnosticAnalyzerService codeAnalysisService) : AbstractProjectDiagnosticSource(project) { - public override Task> GetDiagnosticsAsync( + public override async Task> GetDiagnosticsAsync( RequestContext context, CancellationToken cancellationToken) { @@ -69,7 +69,7 @@ public override Task> 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 index ec1ac69524218..495d795dfcbac 100644 --- a/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs +++ b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSources/AbstractWorkspaceDocumentDiagnosticSource.cs @@ -94,7 +94,7 @@ AsyncLazy> GetLazyDiagnostics() private sealed class CodeAnalysisDiagnosticSource(TextDocument document, ICodeAnalysisDiagnosticAnalyzerService codeAnalysisService) : AbstractWorkspaceDocumentDiagnosticSource(document) { - public override Task> GetDiagnosticsAsync( + public override async Task> GetDiagnosticsAsync( RequestContext context, CancellationToken cancellationToken) { @@ -104,7 +104,7 @@ public override Task> 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 index aac612e5d8fe8..7eeb89d32eb26 100644 --- 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> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken) + public async ValueTask> 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 index f20d2f7712411..83b5b619afe6d 100644 --- a/src/LanguageServer/Protocol/Handler/DocumentChanges/DidChangeHandler.cs +++ b/src/LanguageServer/Protocol/Handler/DocumentChanges/DidChangeHandler.cs @@ -26,7 +26,7 @@ internal class DidChangeHandler() : ILspServiceDocumentRequestHandler request.TextDocument; - public Task HandleRequestAsync(DidChangeTextDocumentParams request, RequestContext context, CancellationToken cancellationToken) + public async Task HandleRequestAsync(DidChangeTextDocumentParams request, RequestContext context, CancellationToken cancellationToken) { var text = context.GetTrackedDocumentInfo(request.TextDocument.DocumentUri).SourceText; @@ -34,7 +34,7 @@ public TextDocumentIdentifier GetTextDocumentIdentifier(DidChangeTextDocumentPar context.UpdateTrackedDocument(request.TextDocument.DocumentUri, text, request.TextDocument.Version); - return SpecializedTasks.Default(); + 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 index a7a223a8e77c4..3f3e35237d313 100644 --- 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> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken) + public async ValueTask> 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 index 1c34bd1f636f5..729d9cd707de9 100644 --- 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 HandleRequestAsync(RequestContext context, CancellationToken cancellationToken) + public async Task 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 index 946363b844c3f..b6c46e6ce6b88 100644 --- 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 HandleRequestAsync(FoldingRangeParams request, RequestContext context, CancellationToken cancellationToken) + public async Task HandleRequestAsync(FoldingRangeParams request, RequestContext context, CancellationToken cancellationToken) { var document = context.Document; if (document is null) - return SpecializedTasks.Null(); + 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 GetFoldingRangesAsync( diff --git a/src/LanguageServer/Protocol/Handler/Highlights/DocumentHighlightHandler.cs b/src/LanguageServer/Protocol/Handler/Highlights/DocumentHighlightHandler.cs index ae1aabe0d4d52..e8e929fe0b4c1 100644 --- 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 HandleRequestAsync(TextDocumentPositionParams request, RequestContext context, CancellationToken cancellationToken) + public async Task HandleRequestAsync(TextDocumentPositionParams request, RequestContext context, CancellationToken cancellationToken) { var document = context.Document; if (document == null) - return SpecializedTasks.Null(); + 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 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 index cd9014d3bc9af..de7eedf1ebfec 100644 --- 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 HandleRequestAsync( + public async Task HandleRequestAsync( LSP.VSInternalDocumentOnAutoInsertParams request, RequestContext context, CancellationToken cancellationToken) { var document = context.Document; if (document == null) - return SpecializedTasks.Null(); + return null; var onAutoInsertEnabled = _globalOptions.GetOption(LspOptionsStorage.LspEnableAutoInsert, document.Project.Language); if (!onAutoInsertEnabled) - return SpecializedTasks.Null(); + 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 GetOnAutoInsertResponseAsync( diff --git a/src/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs b/src/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs index 62fb88c976829..a7905f5abca7c 100644 --- a/src/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs +++ b/src/LanguageServer/Protocol/Handler/ProjectContext/GetTextDocumentWithContextHandler.cs @@ -26,7 +26,7 @@ internal class GetTextDocumentWithContextHandler() : ILspServiceDocumentRequestH public TextDocumentIdentifier GetTextDocumentIdentifier(VSGetProjectContextsParams request) => new() { DocumentUri = request.TextDocument.DocumentUri }; - public Task HandleRequestAsync(VSGetProjectContextsParams request, RequestContext context, CancellationToken cancellationToken) + public async Task HandleRequestAsync(VSGetProjectContextsParams request, RequestContext context, CancellationToken cancellationToken) { Contract.ThrowIfNull(context.Workspace); Contract.ThrowIfNull(context.Solution); @@ -37,7 +37,7 @@ internal class GetTextDocumentWithContextHandler() : ILspServiceDocumentRequestH if (!documentIds.Any()) { - return SpecializedTasks.Null(); + return null; } var contexts = new List(); @@ -57,10 +57,10 @@ internal class GetTextDocumentWithContextHandler() : ILspServiceDocumentRequestH var openDocumentId = documentIds.First(); var currentContextDocumentId = context.Workspace.GetDocumentIdInCurrentContext(openDocumentId); - return Task.FromResult(new VSProjectContextList + return new VSProjectContextList { ProjectContexts = [.. contexts], DefaultIndex = documentIds.IndexOf(d => d == currentContextDocumentId) - }); + }; } } diff --git a/src/LanguageServer/Protocol/Handler/References/FindUsagesLSPContext.cs b/src/LanguageServer/Protocol/Handler/References/FindUsagesLSPContext.cs index 4255fdb8221e4..08861caab5e33 100644 --- a/src/LanguageServer/Protocol/Handler/References/FindUsagesLSPContext.cs +++ b/src/LanguageServer/Protocol/Handler/References/FindUsagesLSPContext.cs @@ -372,10 +372,9 @@ private static ClassifiedTextRun[] GetClassifiedTextRuns( return classifiedTextRuns.ToArray(); } - private ValueTask ReportReferencesAsync(ImmutableSegmentedList> referencesToReport, CancellationToken cancellationToken) + private async ValueTask ReportReferencesAsync(ImmutableSegmentedList> referencesToReport, CancellationToken cancellationToken) { // We can report outside of the lock here since _progress is thread-safe. _progress.Report([.. referencesToReport]); - return ValueTask.CompletedTask; } } diff --git a/src/LanguageServer/Protocol/Handler/ServerLifetime/InitializeHandler.cs b/src/LanguageServer/Protocol/Handler/ServerLifetime/InitializeHandler.cs index e09c98d46bbca..387923e812a5e 100644 --- a/src/LanguageServer/Protocol/Handler/ServerLifetime/InitializeHandler.cs +++ b/src/LanguageServer/Protocol/Handler/ServerLifetime/InitializeHandler.cs @@ -21,7 +21,7 @@ public InitializeHandler() public bool MutatesSolutionState => true; public bool RequiresLSPSolution => false; - public Task HandleRequestAsync(InitializeParams request, RequestContext context, CancellationToken cancellationToken) + public async Task HandleRequestAsync(InitializeParams request, RequestContext context, CancellationToken cancellationToken) { var clientCapabilitiesManager = context.GetRequiredLspService(); var clientCapabilities = clientCapabilitiesManager.TryGetClientCapabilities(); @@ -44,9 +44,9 @@ public Task HandleRequestAsync(InitializeParams request, Reque m["capabilities"] = JsonSerializer.Serialize(serverCapabilities, ProtocolConversions.LspJsonSerializerOptions); })); - return Task.FromResult(new InitializeResult + return new InitializeResult { Capabilities = serverCapabilities, - }); + }; } } diff --git a/src/LanguageServer/Protocol/Handler/ServerLifetime/LspServiceLifeCycleManager.cs b/src/LanguageServer/Protocol/Handler/ServerLifetime/LspServiceLifeCycleManager.cs index e8bec0292d0fe..0c224504a535b 100644 --- a/src/LanguageServer/Protocol/Handler/ServerLifetime/LspServiceLifeCycleManager.cs +++ b/src/LanguageServer/Protocol/Handler/ServerLifetime/LspServiceLifeCycleManager.cs @@ -68,9 +68,7 @@ public async Task ShutdownAsync(string message = "Shutting down") } } - public Task ExitAsync() + public async Task ExitAsync() { - // We don't need any custom logic to run on exit. - return Task.CompletedTask; } } diff --git a/src/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs b/src/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs index 21f56aebf4574..196e036f82817 100644 --- a/src/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs +++ b/src/LanguageServer/Protocol/Handler/SignatureHelp/SignatureHelpHandler.cs @@ -29,15 +29,15 @@ internal sealed class SignatureHelpHandler(SignatureHelpService signatureHelpSer public LSP.TextDocumentIdentifier GetTextDocumentIdentifier(LSP.TextDocumentPositionParams request) => request.TextDocument; - public Task HandleRequestAsync(LSP.TextDocumentPositionParams request, RequestContext context, CancellationToken cancellationToken) + public async Task HandleRequestAsync(LSP.TextDocumentPositionParams request, RequestContext context, CancellationToken cancellationToken) { var document = context.Document; if (document == null) - return SpecializedTasks.Null(); + return null; var supportsVisualStudioExtensions = context.GetRequiredClientCapabilities().HasVisualStudioLspCapability(); var linePosition = ProtocolConversions.PositionToLinePosition(request.Position); - return GetSignatureHelpAsync(signatureHelpService, document, linePosition, supportsVisualStudioExtensions, cancellationToken); + return await GetSignatureHelpAsync(signatureHelpService, document, linePosition, supportsVisualStudioExtensions, cancellationToken).ConfigureAwait(false); } internal static async Task GetSignatureHelpAsync(SignatureHelpService signatureHelpService, Document document, LinePosition linePosition, bool supportsVisualStudioExtensions, CancellationToken cancellationToken) diff --git a/src/LanguageServer/Protocol/Handler/SourceGenerators/SourceGeneratorRefreshQueue.cs b/src/LanguageServer/Protocol/Handler/SourceGenerators/SourceGeneratorRefreshQueue.cs index 3658140436c78..cbfad43eaac30 100644 --- a/src/LanguageServer/Protocol/Handler/SourceGenerators/SourceGeneratorRefreshQueue.cs +++ b/src/LanguageServer/Protocol/Handler/SourceGenerators/SourceGeneratorRefreshQueue.cs @@ -50,17 +50,16 @@ public SourceGeneratorRefreshQueue( _disposalTokenSource.Token); } - public Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestContext context, CancellationToken cancellationToken) + public async Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestContext context, CancellationToken cancellationToken) { if (clientCapabilities.HasVisualStudioLspCapability()) { // VS source generated document content is not provided by LSP. - return Task.CompletedTask; + return; } // After we have initialized we can start listening for workspace changes. _lspWorkspaceRegistrationService.LspSolutionChanged += OnLspSolutionChanged; - return Task.CompletedTask; } private void OnLspSolutionChanged(object? sender, WorkspaceChangeEventArgs e) @@ -120,27 +119,25 @@ await newProject.GetDependentVersionAsync(_disposalTokenSource.Token).ConfigureA } } - private ValueTask RefreshSourceGeneratedDocumentsAsync( + private async ValueTask RefreshSourceGeneratedDocumentsAsync( CancellationToken cancellationToken) { var hasOpenSourceGeneratedDocuments = _lspWorkspaceManager.GetTrackedLspText().Keys.Any(uri => uri.ParsedUri?.Scheme == SourceGeneratedDocumentUri.Scheme); if (!hasOpenSourceGeneratedDocuments) { // There are no opened source generated documents - we don't need to bother asking the client to refresh anything. - return ValueTask.CompletedTask; + return; } try { - return _notificationManager.SendNotificationAsync(RefreshSourceGeneratedDocumentName, cancellationToken); + await _notificationManager.SendNotificationAsync(RefreshSourceGeneratedDocumentName, cancellationToken).ConfigureAwait(false); } catch (Exception ex) when (ex is ObjectDisposedException or ConnectionLostException) { // It is entirely possible that we're shutting down and the connection is lost while we're trying to send a notification // as this runs outside of the guaranteed ordering in the queue. We can safely ignore this exception. } - - return ValueTask.CompletedTask; } public void Dispose() diff --git a/src/LanguageServer/Protocol/Handler/Tasks/DocumentTaskDiagnosticSourceProvider.cs b/src/LanguageServer/Protocol/Handler/Tasks/DocumentTaskDiagnosticSourceProvider.cs index 09804a1157f42..39feacef3b39a 100644 --- a/src/LanguageServer/Protocol/Handler/Tasks/DocumentTaskDiagnosticSourceProvider.cs +++ b/src/LanguageServer/Protocol/Handler/Tasks/DocumentTaskDiagnosticSourceProvider.cs @@ -23,9 +23,9 @@ internal sealed class DocumentTaskDiagnosticSourceProvider([Import] IGlobalOptio public bool IsEnabled(ClientCapabilities capabilities) => capabilities.HasVisualStudioLspCapability(); - public ValueTask> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken) + public async ValueTask> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken) { - return new([new TaskListDiagnosticSource(context.GetRequiredDocument(), globalOptions)]); + return [new TaskListDiagnosticSource(context.GetRequiredDocument(), globalOptions)]; } } diff --git a/src/LanguageServer/Protocol/Handler/Tasks/WorkspaceTaskDiagnosticSourceProvider.cs b/src/LanguageServer/Protocol/Handler/Tasks/WorkspaceTaskDiagnosticSourceProvider.cs index 7b341125f4ec0..29bf846470714 100644 --- a/src/LanguageServer/Protocol/Handler/Tasks/WorkspaceTaskDiagnosticSourceProvider.cs +++ b/src/LanguageServer/Protocol/Handler/Tasks/WorkspaceTaskDiagnosticSourceProvider.cs @@ -25,7 +25,7 @@ internal sealed class WorkspaceTaskDiagnosticSourceProvider([Import] IGlobalOpti public bool IsEnabled(ClientCapabilities capabilities) => capabilities.HasVisualStudioLspCapability(); - public ValueTask> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken) + public async ValueTask> CreateDiagnosticSourcesAsync(RequestContext context, CancellationToken cancellationToken) { Contract.ThrowIfNull(context.Solution); @@ -42,9 +42,9 @@ public ValueTask> CreateDiagnosticSourcesAsync } } - return new(result.ToImmutableAndClear()); + return result.ToImmutableAndClear(); } - return new([]); + return []; } } diff --git a/src/LanguageServer/Protocol/Handler/WorkDoneProgress/WorkDoneProgressCancelledHandler.cs b/src/LanguageServer/Protocol/Handler/WorkDoneProgress/WorkDoneProgressCancelledHandler.cs index 84fe68cc65bfe..7d2fd3cfedf0e 100644 --- a/src/LanguageServer/Protocol/Handler/WorkDoneProgress/WorkDoneProgressCancelledHandler.cs +++ b/src/LanguageServer/Protocol/Handler/WorkDoneProgress/WorkDoneProgressCancelledHandler.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// 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. @@ -21,11 +21,10 @@ internal sealed class WorkDoneProgressCancelledHandler() : ILspServiceNotificati public bool RequiresLSPSolution => false; - public Task HandleNotificationAsync(WorkDoneProgressCancelParams request, RequestContext requestContext, CancellationToken cancellationToken) + public async Task HandleNotificationAsync(WorkDoneProgressCancelParams request, RequestContext requestContext, CancellationToken cancellationToken) { var manager = requestContext.GetRequiredLspService(); // We always create guid tokens, so use the string sumtype directly. manager.CancelWorkDoneProgress(request.Token.Second); - return Task.CompletedTask; } }