Improve LSP conformance in MS.CA.LanguageServer (#81174)

I am proposing fixes for two LSP conformance issues I discovered while
integrating Roslyn LSP with Zed:

1. The response from the `textDocument/diagnostic` request cannot be
`null`. MS.CA.LanguageServer currently returns a `null` response in the
case described here:
https://github.com/dotnet/roslyn/blob/76a39c1a97fe5c73549786fc6944dc188a7b7b3b/src/LanguageServer/Protocol/Handler/Diagnostics/DiagnosticSourceProviders/DiagnosticSourceManager.cs#L72-L80
Because the set of diagnostic handlers is empty, a response value is
never generated for the request, and we fall through to returning
`null`. Instead, explicitly return an empty list of diagnostics. (This
is exactly how VS Code's LSP client treats a `null` response.)

2. Methods that take no parameters (e.g. `workspace/diagnostic/refresh`)
were being sent with an empty array as the parameter value. This is
because the `InvokeWithCancellationAsync` method in StreamJsonRpc
normalizes unspecified arguments to an empty list. Use the
`InvokeParameterObjectAsync` method instead, which don't do this.

Author: reflectronic

src/LanguageServer/Protocol/Handler/Diagnostics/Public/PublicDocumentPullDiagnosticsHandler.cs

@@ -23,7 +23,7 @@ internal sealed partial class PublicDocumentPullDiagnosticsHandler(
     IDiagnosticSourceManager diagnosticSourceManager,
     IDiagnosticsRefresher diagnosticsRefresher,
     IGlobalOptionService globalOptions)
-    : AbstractDocumentPullDiagnosticHandler<DocumentDiagnosticParams, DocumentDiagnosticPartialReport, DocumentDiagnosticReport?>(
+    : AbstractDocumentPullDiagnosticHandler<DocumentDiagnosticParams, DocumentDiagnosticPartialReport, DocumentDiagnosticReport>(
         diagnosticsRefresher, diagnosticSourceManager, globalOptions)
 {
     private readonly IClientLanguageServerManager _clientLanguageServerManager = clientLanguageServerManager;
@@ -57,7 +57,7 @@ protected override bool TryCreateUnchangedReport(TextDocumentIdentifier identifi
         return true;
     }
 
-    protected override DocumentDiagnosticReport? CreateReturn(BufferedProgress<DocumentDiagnosticPartialReport> progress)
+    protected override DocumentDiagnosticReport CreateReturn(BufferedProgress<DocumentDiagnosticPartialReport> progress)
     {
         // We only ever report one result for document diagnostics, which is the first DocumentDiagnosticReport.
         var progressValues = progress.GetValues();
@@ -71,7 +71,10 @@ protected override bool TryCreateUnchangedReport(TextDocumentIdentifier identifi
             return progressValues.Single().Second;
         }
 
-        return null;
+        return new RelatedFullDocumentDiagnosticReport
+        {
+            Items = []
+        };
     }
 
     protected override ImmutableArray<PreviousPullResult>? GetPreviousResults(DocumentDiagnosticParams diagnosticsParams)

src/LanguageServer/Protocol/Handler/LanguageServerNotificationManager.cs

@@ -27,13 +27,13 @@ public Task<TResponse> SendRequestAsync<TParams, TResponse>(string methodName, T
         => _jsonRpc.InvokeWithParameterObjectAsync<TResponse>(methodName, @params, cancellationToken);
 
     public async ValueTask SendRequestAsync(string methodName, CancellationToken cancellationToken)
-        => await _jsonRpc.InvokeWithCancellationAsync(methodName, cancellationToken: cancellationToken).ConfigureAwait(false);
+        => await _jsonRpc.InvokeWithParameterObjectAsync(methodName, cancellationToken: cancellationToken).ConfigureAwait(false);
 
     public async ValueTask SendRequestAsync<TParams>(string methodName, TParams @params, CancellationToken cancellationToken)
         => await _jsonRpc.InvokeWithParameterObjectAsync(methodName, @params, cancellationToken).ConfigureAwait(false);
 
     public async ValueTask SendNotificationAsync(string methodName, CancellationToken cancellationToken)
-        => await _jsonRpc.NotifyAsync(methodName).ConfigureAwait(false);
+        => await _jsonRpc.NotifyWithParameterObjectAsync(methodName).ConfigureAwait(false);
 
     public async ValueTask SendNotificationAsync<TParams>(string methodName, TParams @params, CancellationToken cancellationToken)
         => await _jsonRpc.NotifyWithParameterObjectAsync(methodName, @params).ConfigureAwait(false);

src/LanguageServer/ProtocolUnitTests/Diagnostics/AbstractPullDiagnosticTestsBase.cs

@@ -271,30 +271,26 @@ private protected static async Task<ImmutableArray<TestDiagnosticResult>> RunGet
         else
         {
             BufferedProgress<DocumentDiagnosticPartialReport>? progress = useProgress ? BufferedProgress.Create<DocumentDiagnosticPartialReport>(null) : null;
-            var diagnostics = await testLspServer.ExecuteRequestAsync<DocumentDiagnosticParams, SumType<FullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport>?>(
+            var diagnostics = await testLspServer.ExecuteRequestAsync<DocumentDiagnosticParams, SumType<FullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport>>(
                 Methods.TextDocumentDiagnosticName,
                 CreateProposedDocumentDiagnosticParams(vsTextDocumentIdentifier, previousResultId, category, progress),
                 CancellationToken.None).ConfigureAwait(false);
             if (useProgress)
             {
-                Assert.Null(diagnostics);
+                Assert.IsType<FullDocumentDiagnosticReport>(diagnostics.Value);
+                Assert.Empty(diagnostics.First.Items);
                 AssertEx.NotNull(progress);
                 diagnostics = progress.Value.GetValues()!.Single().First;
             }
 
-            if (diagnostics == null)
-            {
-                // The public LSP spec returns null when no diagnostics are available for a document wheres VS returns an empty array.
-                return [];
-            }
-            else if (diagnostics.Value.Value is UnchangedDocumentDiagnosticReport)
+            if (diagnostics.Value is UnchangedDocumentDiagnosticReport)
             {
                 // The public LSP spec returns different types when unchanged in contrast to VS which just returns null diagnostic array.
-                return [new TestDiagnosticResult(vsTextDocumentIdentifier, diagnostics.Value.Second.ResultId!, null)];
+                return [new TestDiagnosticResult(vsTextDocumentIdentifier, diagnostics.Second.ResultId!, null)];
             }
             else
             {
-                return [new TestDiagnosticResult(vsTextDocumentIdentifier, diagnostics.Value.First.ResultId!, diagnostics.Value.First.Items)];
+                return [new TestDiagnosticResult(vsTextDocumentIdentifier, diagnostics.First.ResultId!, diagnostics.First.Items)];
             }
         }
 

src/LanguageServer/ProtocolUnitTests/Diagnostics/NonLocalDiagnosticTests.cs

@@ -57,11 +57,11 @@ internal async Task TestNonLocalDocumentDiagnosticsAreReportedWhenFSAEnabled(boo
         }
         else
         {
-            Assert.Empty(results);
+            Assert.Empty(results.Single().Diagnostics!);
 
             // Asking again should give us back unchanged diagnostics.
             var results2 = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI(), useVSDiagnostics: false, category: PublicDocumentNonLocalDiagnosticSourceProvider.NonLocal);
-            Assert.Empty(results2);
+            Assert.Empty(results.Single().Diagnostics!);
         }
     }
 

src/LanguageServer/ProtocolUnitTests/Diagnostics/PullDiagnosticTests.cs

@@ -45,13 +45,26 @@ public async Task TestNoDocumentDiagnosticsForClosedFilesWithFSAOff(bool useVSDi
         var document = testLspServer.GetCurrentSolution().Projects.Single().Documents.Single();
 
         var results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI(), useVSDiagnostics);
-
-        Assert.Empty(results);
+        if (useVSDiagnostics)
+        {
+            Assert.Empty(results);
+        }
+        else
+        {
+            Assert.Empty(results.Single().Diagnostics!);
+        }
 
         // Verify document pull diagnostics are unaffected by running code analysis.
         await testLspServer.RunCodeAnalysisAsync(document.Project.Id);
         results = await RunGetDocumentPullDiagnosticsAsync(testLspServer, document.GetURI(), useVSDiagnostics);
-        Assert.Empty(results);
+        if (useVSDiagnostics)
+        {
+            Assert.Empty(results);
+        }
+        else
+        {
+            Assert.Empty(results.Single().Diagnostics!);
+        }
     }
 
     [Theory, CombinatorialData]