Merge branch 'dev/evgenyt/improve_complex_edit' of https://github.com/etvorun/vscode-csharp into dev/evgenyt/improve_complex_edit

Author: etvorun

CHANGELOG.md

@@ -1,12 +1,12 @@
 ## Known Issues
 
-- In version 2.15.30 only, .NET 6.0 projects fail to load if only the 6.0 SDK is installed [#6801](https://github.com/dotnet/vscode-csharp/issues/6801)
-  - If you are trying to load a project that uses the 6.0 SDK, and you do not have any higher SDKs installed, you might get an error message like "Exception thrown while loading (project name) System.Exception: The server disconnected unexpectedly." In that case, try installing a 7.0 SDK as well, which should mitigate the issue. Other workarounds are available in the bug link if needed.
 - Diagnostics related feature requests and improvements [#5951](https://github.com/dotnet/vscode-csharp/issues/5951)
-- [O# Parity] Nested code code action support for code fixes and refactorings [#5735](https://github.com/dotnet/vscode-csharp/issues/5735)
-- [O# Parity] Nuget restore [#5725](https://github.com/dotnet/vscode-csharp/issues/5725)
 - Debug from .csproj and .sln [#5876](https://github.com/dotnet/vscode-csharp/issues/5876)
 
+## Latest
+* Update Roslyn to 4.10.0-1.24066.17 (PR: [#6816](https://github.com/dotnet/vscode-csharp/pull/6816))
+  * Fix issue loading .NET 6.0 projects when only the 6.0 SDK is installed (PR: [#71597](https://github.com/dotnet/roslyn/pull/71597))
+
 ## 2.15.30
 * Update Roslyn to 4.10.0-1.24058.1 (PR: [#6791](https://github.com/dotnet/vscode-csharp/pull/6791))
   * Fix error when a source generated file was present in find references or go to definition requests (PR: [#71395](https://github.com/dotnet/roslyn/pull/71395))

package.json

@@ -37,7 +37,7 @@
     }
   },
   "defaults": {
-    "roslyn": "4.10.0-1.24058.1",
+    "roslyn": "4.10.0-1.24066.17",
     "omniSharp": "1.39.11",
     "razor": "7.0.0-preview.23627.2",
     "razorOmnisharp": "7.0.0-preview.23363.1",

src/lsptoolshost/onAutoInsert.ts

@@ -40,7 +40,15 @@ export function registerOnAutoInsert(languageServer: RoslynLanguageServer) {
 
             source.cancel();
             source = new vscode.CancellationTokenSource();
-            await applyAutoInsertEdit(e, changeTrimmed, languageServer, source.token);
+            try {
+                await applyAutoInsertEdit(e, changeTrimmed, languageServer, source.token);
+            } catch (e) {
+                if (e instanceof vscode.CancellationError) {
+                    return;
+                }
+
+                throw e;
+            }
         }
     });
 }

src/lsptoolshost/restore.ts

@@ -41,10 +41,19 @@ async function chooseProjectAndRestore(
     languageServer: RoslynLanguageServer,
     restoreChannel: vscode.OutputChannel
 ): Promise<void> {
-    const projects = await languageServer.sendRequest0(
-        RestorableProjects.type,
-        new vscode.CancellationTokenSource().token
-    );
+    let projects: string[];
+    try {
+        projects = await languageServer.sendRequest0(
+            RestorableProjects.type,
+            new vscode.CancellationTokenSource().token
+        );
+    } catch (e) {
+        if (e instanceof vscode.CancellationError) {
+            return;
+        }
+
+        throw e;
+    }
 
     const items = projects.map((p) => {
         const projectName = path.basename(p);

src/lsptoolshost/roslynLanguageServer.ts

@@ -28,6 +28,7 @@ import {
     RAL,
     CancellationToken,
     RequestHandler,
+    ResponseError,
 } from 'vscode-languageclient/node';
 import { PlatformInformation } from '../shared/platform';
 import { readConfigurations } from './configurationMiddleware';
@@ -270,8 +271,12 @@ export class RoslynLanguageServer {
             throw new Error('Tried to send request while server is not started.');
         }
 
-        const response = await this._languageClient.sendRequest(type, params, token);
-        return response;
+        try {
+            const response = await this._languageClient.sendRequest(type, params, token);
+            return response;
+        } catch (e) {
+            throw this.convertServerError(type.method, e);
+        }
     }
 
     /**
@@ -285,8 +290,12 @@ export class RoslynLanguageServer {
             throw new Error('Tried to send request while server is not started.');
         }
 
-        const response = await this._languageClient.sendRequest(type, token);
-        return response;
+        try {
+            const response = await this._languageClient.sendRequest(type, token);
+            return response;
+        } catch (e) {
+            throw this.convertServerError(type.method, e);
+        }
     }
 
     public async sendRequestWithProgress<P extends PartialResultParams, R, PR, E, RO>(
@@ -302,10 +311,15 @@ export class RoslynLanguageServer {
         const disposable = this._languageClient.onProgress(type, partialResultToken, async (partialResult) => {
             await onProgress(partialResult);
         });
-        const response = await this._languageClient
-            .sendRequest(type, params, cancellationToken)
-            .finally(() => disposable.dispose());
-        return response;
+
+        try {
+            const response = await this._languageClient.sendRequest(type, params, cancellationToken);
+            return response;
+        } catch (e) {
+            throw this.convertServerError(type.method, e);
+        } finally {
+            disposable.dispose();
+        }
     }
 
     /**
@@ -368,6 +382,25 @@ export class RoslynLanguageServer {
         }
     }
 
+    private convertServerError(request: string, e: any): Error {
+        let error: Error;
+        if (e instanceof ResponseError && e.code === -32800) {
+            // Convert the LSP RequestCancelled error (code -32800) to a CancellationError so we can handle cancellation uniformly.
+            error = new vscode.CancellationError();
+        } else if (e instanceof Error) {
+            error = e;
+        } else if (typeof e === 'string') {
+            error = new Error(e);
+        } else {
+            error = new Error(`Unknown error: ${e.toString()}`);
+        }
+
+        if (!(error instanceof vscode.CancellationError)) {
+            _channel.appendLine(`Error making ${request} request: ${error.message}`);
+        }
+        return error;
+    }
+
     private async openDefaultSolutionOrProjects(): Promise<void> {
         // If Dev Kit isn't installed, then we are responsible for picking the solution to open, assuming the user hasn't explicitly
         // disabled it.
@@ -723,8 +756,19 @@ export class RoslynLanguageServer {
         // When a file is opened process any build diagnostics that may be shown
         this._languageClient.addDisposable(
             vscode.workspace.onDidOpenTextDocument(async (event) => {
-                const buildIds = await this.getBuildOnlyDiagnosticIds(CancellationToken.None);
-                this._buildDiagnosticService._onFileOpened(event, buildIds);
+                try {
+                    const buildIds = await this.getBuildOnlyDiagnosticIds(CancellationToken.None);
+                    this._buildDiagnosticService._onFileOpened(event, buildIds);
+                } catch (e) {
+                    if (e instanceof vscode.CancellationError) {
+                        // The request was cancelled (not due to us) - this means the server is no longer accepting requests
+                        // so there is nothing for us to do here.
+                        return;
+                    }
+
+                    // Let non-cancellation errors bubble up.
+                    throw e;
+                }
             })
         );
     }

test/artifactTests/vsix.test.ts

@@ -18,7 +18,7 @@ describe('Vscode VSIX', () => {
     vsixFiles.forEach((element) => {
         // We're packaging the platform specific Roslyn server with ready to run in the vsix, so the size should be roughly ~50MB
         // We also publish the Razor server, which is roughly ~75MB
-        const sizeInMB = 230;
+        const sizeInMB = 240;
         const maximumVsixSizeInBytes = sizeInMB * 1024 * 1024;
 
         describe(`Given ${element}`, () => {

test/integrationTests/diagnosticsHelpers.ts

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as vscode from 'vscode';
+import { expect } from '@jest/globals';
+import { restartLanguageServer } from './integrationHelpers';
+
+function sortDiagnostics(diagnostics: vscode.Diagnostic[]): vscode.Diagnostic[] {
+    return diagnostics.sort((a, b) => {
+        const rangeCompare = a.range.start.compareTo(b.range.start);
+        if (rangeCompare !== 0) {
+            return rangeCompare;
+        }
+
+        return getCode(a).localeCompare(getCode(b));
+    });
+}
+
+export async function waitForExpectedDiagnostics(
+    assertExpectedDiagnostics: (input: [vscode.Uri, vscode.Diagnostic[]][]) => void,
+    file?: vscode.Uri
+): Promise<void> {
+    let duration = 30 * 1000;
+    const step = 500;
+    let error: any = undefined;
+    while (duration > 0) {
+        const diagnostics: [vscode.Uri, vscode.Diagnostic[]][] = [];
+        if (file) {
+            diagnostics.push([file, sortDiagnostics(vscode.languages.getDiagnostics(file))]);
+        } else {
+            const allDiagnostics = vscode.languages.getDiagnostics();
+            for (const [uri, uriDiagnostics] of allDiagnostics) {
+                diagnostics.push([uri, sortDiagnostics(uriDiagnostics)]);
+            }
+        }
+
+        try {
+            assertExpectedDiagnostics(diagnostics);
+            return;
+        } catch (e) {
+            error = e;
+            // Wait for a bit and try again.
+            await new Promise((r) => setTimeout(r, step));
+            duration -= step;
+        }
+    }
+
+    throw new Error(`Polling did not succeed within the alotted duration: ${error}`);
+}
+
+export async function setBackgroundAnalysisScopes(scopes: { compiler: string; analyzer: string }): Promise<void> {
+    const dotnetConfig = vscode.workspace.getConfiguration('dotnet');
+    await dotnetConfig.update('backgroundAnalysis.compilerDiagnosticsScope', scopes.compiler);
+    await dotnetConfig.update('backgroundAnalysis.analyzerDiagnosticsScope', scopes.analyzer);
+
+    // Restart the language server to ensure diagnostics are reported with the correct configuration.
+    // While in normal user scenarios it isn't necessary to restart the server to pickup diagnostic config changes,
+    // we need to do it in integration tests for two reasons:
+    //  1. We don't know when the server finishes processing the config change (its sent as a notification from client -> server).
+    //  2. Even if we processed the config change, the VSCode API does not provide a way to re-request diagnostics after the config change.
+    await restartLanguageServer();
+}
+
+export function getCode(diagnostic: vscode.Diagnostic): string {
+    const code: {
+        value: string | number;
+        target: vscode.Uri;
+    } = diagnostic.code as any;
+    expect(code).toBeDefined();
+    return code.value.toString();
+}