Move everything in LSP *except* handlers to async/await.

src/LanguageServer/ExternalAccess/VisualDiagnostics/Internal/VisualDiagnosticsServiceFactory.cs

@@ -58,11 +58,10 @@ public void Dispose()
             (_visualDiagnosticsLanguageService as IDisposable)?.Dispose();
         }
 
-        public Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestContext context, CancellationToken cancellationToken)
+        public async Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestContext context, CancellationToken cancellationToken)
         {
             _cancellationToken = cancellationToken;
             _taskCompletionSource.TrySetResult(true);
-            return Task.CompletedTask;
         }
 
         public void OnServiceBrokerInitialized(IServiceBroker serviceBroker)

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/LspFileChangeWatcherTests.cs

@@ -118,21 +118,17 @@ private sealed class DynamicCapabilitiesRpcTarget
         public readonly ConcurrentDictionary<string, Registration> Registrations = new();
 
         [JsonRpcMethod("client/registerCapability", UseSingleObjectParameterDeserialization = true)]
-        public Task RegisterCapabilityAsync(RegistrationParams registrationParams, CancellationToken _)
+        public async Task RegisterCapabilityAsync(RegistrationParams registrationParams, CancellationToken _)
         {
             foreach (var registration in registrationParams.Registrations)
                 Assert.True(Registrations.TryAdd(registration.Id, registration));
-
-            return Task.CompletedTask;
         }
 
         [JsonRpcMethod("client/unregisterCapability", UseSingleObjectParameterDeserialization = true)]
-        public Task UnregisterCapabilityAsync(UnregistrationParams unregistrationParams, CancellationToken _)
+        public async Task UnregisterCapabilityAsync(UnregistrationParams unregistrationParams, CancellationToken _)
         {
             foreach (var unregistration in unregistrationParams.Unregistrations)
                 Assert.True(Registrations.TryRemove(unregistration.Id, out var _));
-
-            return Task.CompletedTask;
         }
     }
 }

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/BrokeredServices/BrokeredServiceContainer.cs

@@ -42,7 +42,7 @@ internal static async Task<BrokeredServiceContainer> CreateAsync(ExportProvider
         container.ProfferIntrinsicService(
             FrameworkServices.Authorization,
             new ServiceRegistration(VisualStudio.Shell.ServiceBroker.ServiceAudience.Local, null, allowGuestClients: true),
-            (moniker, options, serviceBroker, cancellationToken) => new(new NoOpAuthorizationService()));
+            async (moniker, options, serviceBroker, cancellationToken) => new NoOpAuthorizationService());
 
         var mefServiceBroker = exportProvider.GetExportedValue<MefServiceBrokerOfExportedServices>();
         mefServiceBroker.SetContainer(container);
@@ -62,14 +62,14 @@ private class NoOpAuthorizationService : IAuthorizationService
 
         public event EventHandler? AuthorizationChanged;
 
-        public ValueTask<bool> CheckAuthorizationAsync(ProtectedOperation operation, CancellationToken cancellationToken = default)
+        public async ValueTask<bool> CheckAuthorizationAsync(ProtectedOperation operation, CancellationToken cancellationToken = default)
         {
-            return new(true);
+            return true;
         }
 
-        public ValueTask<IReadOnlyDictionary<string, string>> GetCredentialsAsync(CancellationToken cancellationToken = default)
+        public async ValueTask<IReadOnlyDictionary<string, string>> GetCredentialsAsync(CancellationToken cancellationToken = default)
         {
-            return new(ImmutableDictionary<string, string>.Empty);
+            return ImmutableDictionary<string, string>.Empty;
         }
 
         protected virtual void OnCredentialsChanged(EventArgs args) => this.CredentialsChanged?.Invoke(this, args);

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/BrokeredServices/Services/BrokeredServiceBridgeManifest/BrokeredServiceBridgeManifestService.cs

@@ -38,20 +38,19 @@ public BrokeredServiceBridgeManifest(ServiceBrokerFactory serviceBrokerFactory,
     /// <summary>
     /// Returns a subset of services registered to Microsoft.VisualStudio.Code.Server container that are proferred by the Language Server process.
     /// </summary>
-    public ValueTask<IReadOnlyCollection<ServiceMoniker>> GetAvailableServicesAsync(CancellationToken cancellationToken)
+    public async ValueTask<IReadOnlyCollection<ServiceMoniker>> GetAvailableServicesAsync(CancellationToken cancellationToken)
     {
         var services = (IReadOnlyCollection<ServiceMoniker>)[.. _serviceBrokerFactory.GetRequiredServiceBrokerContainer().GetRegisteredServices()
             .Select(s => s.Key)
             .Where(s => s.Name.StartsWith("Microsoft.CodeAnalysis.LanguageServer.", StringComparison.Ordinal) ||
                         s.Name.StartsWith("Microsoft.VisualStudio.LanguageServer.", StringComparison.Ordinal) ||
                         s.Name.StartsWith("Microsoft.VisualStudio.LanguageServices.", StringComparison.Ordinal))];
         _logger.LogDebug($"Proffered services: {string.Join(',', services.Select(s => s.ToString()))}");
-        return ValueTask.FromResult(services);
+        return services;
     }
 
-    public Task InitializeAsync(CancellationToken cancellationToken)
+    public async Task InitializeAsync(CancellationToken cancellationToken)
     {
-        return Task.CompletedTask;
     }
 }
 #pragma warning restore RS0030 // Do not used banned APIs

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/CanonicalMiscFilesProjectLoader.cs

@@ -276,10 +276,9 @@ private TextDocument CreatePrimordialProjectAndAddDocument_NoLock(string documen
         };
     }
 
-    protected override ValueTask OnProjectUnloadedAsync(string projectFilePath)
+    protected override async ValueTask OnProjectUnloadedAsync(string projectFilePath)
     {
         // Nothing special to do on unload for canonical project
-        return ValueTask.CompletedTask;
     }
 
     protected override async ValueTask TransitionPrimordialProjectToLoaded_NoLockAsync(

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/FileBasedProgramsProjectSystem.cs

@@ -222,9 +222,8 @@ public async ValueTask<bool> TryRemoveMiscellaneousDocumentAsync(DocumentUri uri
         };
     }
 
-    protected override ValueTask OnProjectUnloadedAsync(string projectFilePath)
+    protected override async ValueTask OnProjectUnloadedAsync(string projectFilePath)
     {
-        return ValueTask.CompletedTask;
     }
 
     protected override async ValueTask TransitionPrimordialProjectToLoaded_NoLockAsync(

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/FileWatching/LspDidChangeWatchedFilesHandler.cs

@@ -23,10 +23,9 @@ public LspDidChangeWatchedFilesHandler()
     public bool MutatesSolutionState => false;
     public bool RequiresLSPSolution => false;
 
-    Task INotificationHandler<DidChangeWatchedFilesParams, RequestContext>.HandleNotificationAsync(DidChangeWatchedFilesParams request, RequestContext requestContext, CancellationToken cancellationToken)
+    async Task INotificationHandler<DidChangeWatchedFilesParams, RequestContext>.HandleNotificationAsync(DidChangeWatchedFilesParams request, RequestContext requestContext, CancellationToken cancellationToken)
     {
         NotificationRaised?.Invoke(this, request);
-        return Task.CompletedTask;
     }
 
     public event EventHandler<DidChangeWatchedFilesParams>? NotificationRaised;

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerProjectSystem.cs

@@ -102,10 +102,9 @@ public async Task OpenProjectsAsync(ImmutableArray<string> projectFilePaths)
         };
     }
 
-    protected override ValueTask OnProjectUnloadedAsync(string projectFilePath)
+    protected override async ValueTask OnProjectUnloadedAsync(string projectFilePath)
     {
         // Nothing else to unload for ordinary projects.
-        return ValueTask.CompletedTask;
     }
 
     protected override async ValueTask TransitionPrimordialProjectToLoaded_NoLockAsync(

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/Razor/RazorInitializer.cs

@@ -17,13 +17,13 @@ namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace.Razor;
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
 internal sealed class RazorInitializer(Lazy<LanguageServerWorkspaceFactory> workspaceFactory, [Import(AllowDefault = true)] ITelemetryReporter? telemetryReporter) : ILspService, IOnInitialized
 {
-    public Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestContext context, CancellationToken cancellationToken)
+    public async Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestContext context, CancellationToken cancellationToken)
     {
         var razorInitializerService = context.GetService<AbstractRazorInitializer>();
         if (razorInitializerService is null)
         {
             // No initializer service registered, nothing to do.
-            return Task.CompletedTask;
+            return;
         }
 
         razorInitializerService.Initialize(workspaceFactory.Value.HostWorkspace);
@@ -33,7 +33,5 @@ public Task OnInitializedAsync(ClientCapabilities clientCapabilities, RequestCon
         {
             razorTelemetryReporter.Initialize(new TelemetryReporterWrapper(telemetryReporter));
         }
-
-        return Task.CompletedTask;
     }
 }

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/WorkspaceProjectFactoryService.cs

@@ -65,10 +65,10 @@ public async Task<IWorkspaceProject> CreateAndAddProjectAsync(WorkspaceProjectCr
         }
     }
 
-    public Task<IReadOnlyCollection<string>> GetSupportedBuildSystemPropertiesAsync(CancellationToken _)
+    public async Task<IReadOnlyCollection<string>> GetSupportedBuildSystemPropertiesAsync(CancellationToken _)
     {
         // TODO: implement
-        return Task.FromResult((IReadOnlyCollection<string>)[]);
+        return [];
     }
 }
 #pragma warning restore RS0030 // Do not used banned APIs

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/LanguageServer/Handler/DebugConfiguration/WorkspaceDebugConfigurationHandler.cs

@@ -28,15 +28,15 @@ public WorkspaceDebugConfigurationHandler(ProjectTargetFrameworkManager targetFr
 
     public bool RequiresLSPSolution => true;
 
-    public Task<ProjectDebugConfiguration[]> HandleRequestAsync(WorkspaceDebugConfigurationParams request, RequestContext context, CancellationToken cancellationToken)
+    public async Task<ProjectDebugConfiguration[]> HandleRequestAsync(WorkspaceDebugConfigurationParams request, RequestContext context, CancellationToken cancellationToken)
     {
         Contract.ThrowIfNull(context.Solution, nameof(context.Solution));
 
         var projects = context.Solution.Projects
             .Where(p => p.FilePath != null && p.OutputFilePath != null)
             .Where(p => IsProjectInWorkspace(request.WorkspacePath, p))
             .Select(GetProjectDebugConfiguration).ToArray();
-        return Task.FromResult(projects);
+        return projects;
     }
 
     private static bool IsProjectInWorkspace(DocumentUri workspacePath, Project project)

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/LanguageServer/Handler/Logging/UpdateLogLevelHandler.cs

@@ -22,11 +22,10 @@ internal sealed class UpdateLogLevelHandler(ServerConfiguration serverConfigurat
 
     public bool RequiresLSPSolution => false;
 
-    public Task HandleNotificationAsync(UpdateLogLevelParams request, RequestContext requestContext, CancellationToken cancellationToken)
+    public async Task HandleNotificationAsync(UpdateLogLevelParams request, RequestContext requestContext, CancellationToken cancellationToken)
     {
         var level = Enum.Parse<LogLevel>(request.LogLevelValue);
         serverConfiguration.LogConfiguration.UpdateLogLevel(level);
-        return Task.CompletedTask;
     }
 }
 

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/LanguageServer/Handler/Restore/RestorableProjectsHandler.cs

@@ -25,7 +25,7 @@ internal sealed class RestorableProjectsHandler(ProjectTargetFrameworkManager pr
 
     public bool RequiresLSPSolution => true;
 
-    public Task<string[]> HandleRequestAsync(RequestContext context, CancellationToken cancellationToken)
+    public async Task<string[]> HandleRequestAsync(RequestContext context, CancellationToken cancellationToken)
     {
         Contract.ThrowIfNull(context.Solution);
 
@@ -43,6 +43,6 @@ public Task<string[]> HandleRequestAsync(RequestContext context, CancellationTok
             }
         }
 
-        return Task.FromResult(projects.ToArray());
+        return projects.ToArray();
     }
 }

src/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.Example/ExampleRequestContextFactory.cs

@@ -16,12 +16,12 @@ public ExampleRequestContextFactory(ILspServices lspServices)
         _lspServices = lspServices;
     }
 
-    public override Task<ExampleRequestContext> CreateRequestContextAsync<TRequestParam>(IQueueItem<ExampleRequestContext> queueItem, IMethodHandler methodHandler, TRequestParam requestParam, CancellationToken cancellationToken)
+    public override async Task<ExampleRequestContext> CreateRequestContextAsync<TRequestParam>(IQueueItem<ExampleRequestContext> queueItem, IMethodHandler methodHandler, TRequestParam requestParam, CancellationToken cancellationToken)
     {
         var logger = _lspServices.GetRequiredService<ILspLogger>();
 
         var requestContext = new ExampleRequestContext(_lspServices, logger);
 
-        return Task.FromResult(requestContext);
+        return requestContext;
     }
 }

src/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/Mocks/TestRequestContext.cs

@@ -13,7 +13,7 @@ internal sealed class Factory : AbstractRequestContextFactory<TestRequestContext
     {
         public static readonly Factory Instance = new();
 
-        public override Task<TestRequestContext> CreateRequestContextAsync<TRequestParam>(IQueueItem<TestRequestContext> queueItem, IMethodHandler methodHandler, TRequestParam requestParam, CancellationToken cancellationToken)
-            => Task.FromResult(new TestRequestContext());
+        public override async Task<TestRequestContext> CreateRequestContextAsync<TRequestParam>(IQueueItem<TestRequestContext> queueItem, IMethodHandler methodHandler, TRequestParam requestParam, CancellationToken cancellationToken)
+            => new TestRequestContext();
     }
 }

src/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework.UnitTests/TestExampleLanguageServer.cs

@@ -60,16 +60,14 @@ public TestLifeCycleManager(TaskCompletionSource<int> shuttingDownSource, TaskCo
             _exitingSource = exitingSource;
         }
 
-        public Task ExitAsync()
+        public async Task ExitAsync()
         {
             _exitingSource.SetResult(0);
-            return Task.CompletedTask;
         }
 
-        public Task ShutdownAsync(string message = "Shutting down")
+        public async Task ShutdownAsync(string message = "Shutting down")
         {
             _shuttingDownSource.SetResult(0);
-            return Task.CompletedTask;
         }
     }
 

src/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializeHandler.cs

@@ -23,12 +23,12 @@ public InitializeHandler(IInitializeManager<TRequest, TResponse> capabilitiesMan
 
     public bool MutatesSolutionState => true;
 
-    public Task<TResponse> HandleRequestAsync(TRequest request, TRequestContext context, CancellationToken cancellationToken)
+    public async Task<TResponse> HandleRequestAsync(TRequest request, TRequestContext context, CancellationToken cancellationToken)
     {
         _capabilitiesManager.SetInitializeParams(request);
 
         var serverCapabilities = _capabilitiesManager.GetInitializeResult();
 
-        return Task.FromResult(serverCapabilities);
+        return serverCapabilities;
     }
 }

src/LanguageServer/Microsoft.CommonLanguageServerProtocol.Framework/Handlers/InitializedHandler.cs

@@ -18,15 +18,13 @@ internal sealed class InitializedHandler<TRequest, TRequestContext> : INotificat
 
     public bool MutatesSolutionState => true;
 
-    public Task HandleNotificationAsync(TRequest request, TRequestContext requestContext, CancellationToken cancellationToken)
+    public async Task HandleNotificationAsync(TRequest request, TRequestContext requestContext, CancellationToken cancellationToken)
     {
         if (HasBeenInitialized)
         {
             throw new InvalidOperationException("initialized was called twice");
         }
 
         HasBeenInitialized = true;
-
-        return Task.CompletedTask;
     }
 }

src/LanguageServer/Protocol.TestUtilities/LanguageServer/AbstractLanguageServerProtocolTests.cs

@@ -78,15 +78,15 @@ internal sealed class TestSpanMapper : ISpanMappingService
         /// </summary>
         public bool SupportsMappingImportDirectives => true;
 
-        public Task<ImmutableArray<MappedSpanResult>> MapSpansAsync(Document document, IEnumerable<TextSpan> spans, CancellationToken cancellationToken)
+        public async Task<ImmutableArray<MappedSpanResult>> MapSpansAsync(Document document, IEnumerable<TextSpan> spans, CancellationToken cancellationToken)
         {
             ImmutableArray<MappedSpanResult> mappedResult = default;
             if (document.Name == GeneratedFileName)
             {
                 mappedResult = [.. spans.Select(span => new MappedSpanResult(s_mappedFilePath, s_mappedLinePosition, new TextSpan(0, 5)))];
             }
 
-            return Task.FromResult(mappedResult);
+            return mappedResult;
         }
 
         public Task<ImmutableArray<(string mappedFilePath, TextChange mappedTextChange)>> GetMappedTextChangesAsync(
@@ -103,7 +103,7 @@ private protected sealed class OrderLocations : Comparer<LSP.Location?>
         public override int Compare(LSP.Location? x, LSP.Location? y) => CompareLocations(x, y);
     }
 
-    protected virtual ValueTask<ExportProvider> CreateExportProviderAsync() => ValueTask.FromResult(Composition.ExportProviderFactory.CreateExportProvider());
+    protected virtual async ValueTask<ExportProvider> CreateExportProviderAsync() => Composition.ExportProviderFactory.CreateExportProvider();
     protected virtual TestComposition Composition => FeaturesLspComposition;
 
     private protected virtual TestAnalyzerReferenceByLanguage CreateTestAnalyzersReference()

src/LanguageServer/Protocol.TestUtilities/Workspaces/LspTestWorkspace.cs

@@ -36,11 +36,10 @@ internal LspTestWorkspace(
 
     bool ILspWorkspace.SupportsMutation => _supportsLspMutation;
 
-    ValueTask ILspWorkspace.UpdateTextIfPresentAsync(DocumentId documentId, SourceText sourceText, CancellationToken cancellationToken)
+    async ValueTask ILspWorkspace.UpdateTextIfPresentAsync(DocumentId documentId, SourceText sourceText, CancellationToken cancellationToken)
     {
         Contract.ThrowIfFalse(_supportsLspMutation);
         OnDocumentTextChanged(documentId, sourceText, PreservationMode.PreserveIdentity, requireDocumentPresent: false);
-        return ValueTask.CompletedTask;
     }
 
     internal override ValueTask TryOnDocumentClosedAsync(DocumentId documentId, CancellationToken cancellationToken)

src/LanguageServer/Protocol/Features/DecompiledSource/AssemblyResolver.cs

@@ -48,14 +48,14 @@ void BuildReferenceCache()
         }
     }
 
-    public Task<MetadataFile> ResolveAsync(IAssemblyReference name)
+    public async Task<MetadataFile> ResolveAsync(IAssemblyReference name)
     {
-        return Task.FromResult(Resolve(name));
+        return Resolve(name);
     }
 
-    public Task<MetadataFile> ResolveModuleAsync(MetadataFile mainModule, string moduleName)
+    public async Task<MetadataFile> ResolveModuleAsync(MetadataFile mainModule, string moduleName)
     {
-        return Task.FromResult(ResolveModule(mainModule, moduleName));
+        return ResolveModule(mainModule, moduleName);
     }
 
     [SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "Could be non-static if instance data is accessed")]

src/LanguageServer/Protocol/Features/EditAndContinue/EditAndContinueDiagnosticSource_OpenDocument.cs

@@ -49,7 +49,7 @@ public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(R
 
             var activeStatementSpanProvider = spanLocator != null
                 ? new ActiveStatementSpanProvider((documentId, filePath, cancellationToken) => spanLocator.GetSpansAsync(compileTimeSolution, documentId, filePath, cancellationToken))
-                : static (_, _, _) => ValueTask.FromResult(ImmutableArray<ActiveStatementSpan>.Empty);
+                : static async (_, _, _) => ImmutableArray<ActiveStatementSpan>.Empty;
 
             var rudeEditDiagnostics = await proxy.GetDocumentDiagnosticsAsync(compileTimeDocument, activeStatementSpanProvider, cancellationToken).ConfigureAwait(false);
 

src/LanguageServer/Protocol/Features/EditAndContinue/EditAndContinueDiagnosticSource_Workspace.cs

@@ -20,15 +20,15 @@ internal static partial class EditAndContinueDiagnosticSource
     private sealed class ProjectSource(Project project, ImmutableArray<DiagnosticData> diagnostics) : AbstractProjectDiagnosticSource(project)
     {
 
-        public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(RequestContext context, CancellationToken cancellationToken)
-            => Task.FromResult(diagnostics);
+        public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(RequestContext context, CancellationToken cancellationToken)
+            => diagnostics;
     }
 
     private sealed class ClosedDocumentSource(TextDocument document, ImmutableArray<DiagnosticData> diagnostics) : AbstractWorkspaceDocumentDiagnosticSource(document)
     {
 
-        public override Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(RequestContext context, CancellationToken cancellationToken)
-            => Task.FromResult(diagnostics);
+        public override async Task<ImmutableArray<DiagnosticData>> GetDiagnosticsAsync(RequestContext context, CancellationToken cancellationToken)
+            => diagnostics;
     }
 
     public static async ValueTask<ImmutableArray<IDiagnosticSource>> CreateWorkspaceDiagnosticSourcesAsync(Solution solution, Func<Document, bool> isDocumentOpen, CancellationToken cancellationToken)