Cleanup and fix races in server activation and restart

Author: dibarbet

.vscode/settings.json

@@ -20,5 +20,6 @@
     "omnisharp.autoStart": false,
     "editor.formatOnSave": false,
     "eslint.lintTask.enable": true,
-    "dotnet.defaultSolution": "disable"
+    "dotnet.defaultSolution": "disable",
+    "jest.autoRun": "off"
 }

src/common.ts

@@ -226,3 +226,9 @@ export function findPowerShell(): string | undefined {
         }
     }
 }
+
+export function isNotNull<T>(value: T): asserts value is NonNullable<T> {
+    if (value === null || value === undefined) {
+        throw new Error('value is null or undefined.');
+    }
+}

src/csharpExtensionExports.ts

@@ -9,6 +9,7 @@ import { EventStream } from './eventStream';
 import TestManager from './features/dotnetTest';
 import { GlobalBrokeredServiceContainer } from '@microsoft/servicehub-framework';
 import { RequestType } from 'vscode-languageclient/node';
+import { LanguageServerEvents } from './lsptoolshost/languageServerEvents';
 
 export interface OmnisharpExtensionExports {
     initializationFinished: () => Promise<void>;
@@ -32,4 +33,5 @@ export interface CSharpExtensionExperimentalExports {
         params: Params,
         token: vscode.CancellationToken
     ) => Promise<Response>;
+    languageServerEvents: LanguageServerEvents;
 }

src/lsptoolshost/debugger.ts

@@ -14,18 +14,20 @@ import OptionProvider from '../shared/observers/optionProvider';
 import { ServerStateChange } from './serverStateChange';
 import { DotnetConfigurationResolver } from '../shared/dotnetConfigurationProvider';
 import { getCSharpDevKit } from '../utils/getCSharpDevKit';
+import { RoslynLanguageServerEvents } from './languageServerEvents';
 
 export function registerDebugger(
     context: vscode.ExtensionContext,
     languageServer: RoslynLanguageServer,
+    languageServerEvents: RoslynLanguageServerEvents,
     platformInfo: PlatformInformation,
     optionProvider: OptionProvider,
     csharpOutputChannel: vscode.OutputChannel
 ) {
     const workspaceInformationProvider: IWorkspaceDebugInformationProvider =
-        new RoslynWorkspaceDebugInformationProvider(languageServer);
+        new RoslynWorkspaceDebugInformationProvider(languageServer, csharpOutputChannel);
 
-    const disposable = languageServer.registerStateChangeEvent(async (state) => {
+    const disposable = languageServerEvents.onServerStateChange(async (state) => {
         if (state === ServerStateChange.ProjectInitializationComplete) {
             const csharpDevkitExtension = getCSharpDevKit();
             if (!csharpDevkitExtension) {

src/lsptoolshost/languageServerEvents.ts

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { ServerStateChange } from './serverStateChange';
+import { IDisposable } from '../disposable';
+
+/**
+ * Defines events that are fired by the language server.
+ * These events can be consumed to wait for the server to reach a certain state.
+ */
+export interface LanguageServerEvents {
+    readonly onServerStateChange: vscode.Event<ServerStateChange>;
+}
+
+/**
+ * Implementation that fires events when the language server reaches a certain state.
+ * This is intentionally separate from the language server itself, so consumers can
+ * register for events without having to know about the specific current state of the language server.
+ */
+export class RoslynLanguageServerEvents implements LanguageServerEvents, IDisposable {
+    public readonly onServerStateChangeEmitter = new vscode.EventEmitter<ServerStateChange>();
+
+    public get onServerStateChange(): vscode.Event<ServerStateChange> {
+        return this.onServerStateChangeEmitter.event;
+    }
+
+    dispose(): void {
+        this.onServerStateChangeEmitter.dispose();
+    }
+}

src/lsptoolshost/onAutoInsert.ts

@@ -0,0 +1,95 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { UriConverter } from './uriConverter';
+
+import { FormattingOptions, TextDocumentIdentifier } from 'vscode-languageclient/node';
+import OptionProvider from '../shared/observers/optionProvider';
+import * as RoslynProtocol from './roslynProtocol';
+import { RoslynLanguageServer } from './roslynLanguageServer';
+
+export function registerOnAutoInsert(optionsProvider: OptionProvider, languageServer: RoslynLanguageServer) {
+    let source = new vscode.CancellationTokenSource();
+    vscode.workspace.onDidChangeTextDocument(async (e) => {
+        const options = optionsProvider.GetLatestOptions();
+        if (!options.languageServerOptions.documentSelector.includes(e.document.languageId)) {
+            return;
+        }
+
+        if (e.contentChanges.length > 1 || e.contentChanges.length === 0) {
+            return;
+        }
+
+        const change = e.contentChanges[0];
+
+        if (!change.range.isEmpty) {
+            return;
+        }
+
+        const capabilities = await languageServer.getServerCapabilities();
+
+        if (capabilities._vs_onAutoInsertProvider) {
+            // Regular expression to match all whitespace characters except the newline character
+            const changeTrimmed = change.text.replace(/[^\S\n]+/g, '');
+
+            if (!capabilities._vs_onAutoInsertProvider._vs_triggerCharacters.includes(changeTrimmed)) {
+                return;
+            }
+
+            source.cancel();
+            source = new vscode.CancellationTokenSource();
+            await applyAutoInsertEdit(e, changeTrimmed, languageServer, source.token);
+        }
+    });
+}
+
+async function applyAutoInsertEdit(
+    e: vscode.TextDocumentChangeEvent,
+    changeTrimmed: string,
+    languageServer: RoslynLanguageServer,
+    token: vscode.CancellationToken
+) {
+    const change = e.contentChanges[0];
+    // The server expects the request position to represent the caret position in the text after the change has already been applied.
+    // We need to calculate what that position would be after the change is applied and send that to the server.
+    const position = new vscode.Position(
+        change.range.start.line,
+        change.range.start.character + (change.text.length - change.rangeLength)
+    );
+    const uri = UriConverter.serialize(e.document.uri);
+    const textDocument = TextDocumentIdentifier.create(uri);
+    const formattingOptions = getFormattingOptions();
+    const request: RoslynProtocol.OnAutoInsertParams = {
+        _vs_textDocument: textDocument,
+        _vs_position: position,
+        _vs_ch: changeTrimmed,
+        _vs_options: formattingOptions,
+    };
+
+    const response = await languageServer.sendRequest(RoslynProtocol.OnAutoInsertRequest.type, request, token);
+    if (response) {
+        const textEdit = response._vs_textEdit;
+        const startPosition = new vscode.Position(textEdit.range.start.line, textEdit.range.start.character);
+        const endPosition = new vscode.Position(textEdit.range.end.line, textEdit.range.end.character);
+        const docComment = new vscode.SnippetString(textEdit.newText);
+        const code: any = vscode;
+        const textEdits = [new code.SnippetTextEdit(new vscode.Range(startPosition, endPosition), docComment)];
+        const edit = new vscode.WorkspaceEdit();
+        edit.set(e.document.uri, textEdits);
+
+        const applied = vscode.workspace.applyEdit(edit);
+        if (!applied) {
+            throw new Error('Tried to insert a comment but an error occurred.');
+        }
+    }
+}
+
+function getFormattingOptions(): FormattingOptions {
+    const editorConfig = vscode.workspace.getConfiguration('editor');
+    const tabSize = editorConfig.get<number>('tabSize') ?? 4;
+    const insertSpaces = editorConfig.get<boolean>('insertSpaces') ?? true;
+    return FormattingOptions.create(tabSize, insertSpaces);
+}

src/lsptoolshost/razorCommands.ts

@@ -0,0 +1,107 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { RoslynLanguageServer } from './roslynLanguageServer';
+import * as vscode from 'vscode';
+import {
+    DidChangeTextDocumentNotification,
+    DidCloseTextDocumentNotification,
+    DidCloseTextDocumentParams,
+    DidChangeTextDocumentParams,
+    DocumentDiagnosticParams,
+    RequestType,
+    DocumentDiagnosticRequest,
+    DocumentDiagnosticReport,
+    CancellationToken,
+    CodeAction,
+    CodeActionParams,
+    CodeActionRequest,
+    CodeActionResolveRequest,
+    CompletionParams,
+    CompletionRequest,
+    CompletionResolveRequest,
+    CompletionItem,
+} from 'vscode-languageclient/node';
+import SerializableSimplifyMethodParams from '../razor/src/simplify/serializableSimplifyMethodParams';
+import { TextEdit } from 'vscode-html-languageservice';
+
+// These are commands that are invoked by the Razor extension, and are used to send LSP requests to the Roslyn LSP server
+export const roslynDidChangeCommand = 'roslyn.changeRazorCSharp';
+export const roslynDidCloseCommand = 'roslyn.closeRazorCSharp';
+export const roslynPullDiagnosticCommand = 'roslyn.pullDiagnosticRazorCSharp';
+export const provideCodeActionsCommand = 'roslyn.provideCodeActions';
+export const resolveCodeActionCommand = 'roslyn.resolveCodeAction';
+export const provideCompletionsCommand = 'roslyn.provideCompletions';
+export const resolveCompletionsCommand = 'roslyn.resolveCompletion';
+export const roslynSimplifyMethodCommand = 'roslyn.simplifyMethod';
+export const razorInitializeCommand = 'razor.initialize';
+
+export function registerRazorCommands(context: vscode.ExtensionContext, languageServer: RoslynLanguageServer) {
+    // Razor will call into us (via command) for generated file didChange/didClose notifications. We'll then forward these
+    // notifications along to Roslyn. didOpen notifications are handled separately via the vscode.openTextDocument method.
+    context.subscriptions.push(
+        vscode.commands.registerCommand(roslynDidChangeCommand, async (notification: DidChangeTextDocumentParams) => {
+            await languageServer.sendNotification(DidChangeTextDocumentNotification.method, notification);
+        })
+    );
+    context.subscriptions.push(
+        vscode.commands.registerCommand(roslynDidCloseCommand, async (notification: DidCloseTextDocumentParams) => {
+            await languageServer.sendNotification(DidCloseTextDocumentNotification.method, notification);
+        })
+    );
+    context.subscriptions.push(
+        vscode.commands.registerCommand(roslynPullDiagnosticCommand, async (request: DocumentDiagnosticParams) => {
+            const diagnosticRequestType = new RequestType<DocumentDiagnosticParams, DocumentDiagnosticReport, any>(
+                DocumentDiagnosticRequest.method
+            );
+            return await languageServer.sendRequest(diagnosticRequestType, request, CancellationToken.None);
+        })
+    );
+    context.subscriptions.push(
+        vscode.commands.registerCommand(
+            roslynSimplifyMethodCommand,
+            async (request: SerializableSimplifyMethodParams) => {
+                const simplifyMethodRequestType = new RequestType<SerializableSimplifyMethodParams, TextEdit[], any>(
+                    'roslyn/simplifyMethod'
+                );
+                return await languageServer.sendRequest(simplifyMethodRequestType, request, CancellationToken.None);
+            }
+        )
+    );
+
+    // The VS Code API for code actions (and the vscode.CodeAction type) doesn't support everything that LSP supports,
+    // namely the data property, which Razor needs to identify which code actions are on their allow list, so we need
+    // to expose a command for them to directly invoke our code actions LSP endpoints, rather than use built-in commands.
+    context.subscriptions.push(
+        vscode.commands.registerCommand(provideCodeActionsCommand, async (request: CodeActionParams) => {
+            return await languageServer.sendRequest(CodeActionRequest.type, request, CancellationToken.None);
+        })
+    );
+    context.subscriptions.push(
+        vscode.commands.registerCommand(resolveCodeActionCommand, async (request: CodeAction) => {
+            return await languageServer.sendRequest(CodeActionResolveRequest.type, request, CancellationToken.None);
+        })
+    );
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand(provideCompletionsCommand, async (request: CompletionParams) => {
+            return await languageServer.sendRequest(CompletionRequest.type, request, CancellationToken.None);
+        })
+    );
+    context.subscriptions.push(
+        vscode.commands.registerCommand(resolveCompletionsCommand, async (request: CompletionItem) => {
+            return await languageServer.sendRequest(CompletionResolveRequest.type, request, CancellationToken.None);
+        })
+    );
+
+    // Roslyn is responsible for producing a json file containing information for Razor, that comes from the compilation for
+    // a project. We want to defer this work until necessary, so this command is called by the Razor document manager to tell
+    // us when they need us to initialize the Razor things.
+    context.subscriptions.push(
+        vscode.commands.registerCommand(razorInitializeCommand, async () => {
+            await languageServer.sendNotification('razor/initialize', {});
+        })
+    );
+}