Merge #2709

2709: Work around synchrnonisation issue r=matklad a=matklad



Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>

Author: bors[bot]

editors/code/src/client.ts

@@ -0,0 +1,90 @@
+import { homedir } from 'os';
+import * as lc from 'vscode-languageclient';
+
+import { window, workspace } from 'vscode';
+import { Config } from './config';
+
+export function createClient(config: Config): lc.LanguageClient {
+    // '.' Is the fallback if no folder is open
+    // TODO?: Workspace folders support Uri's (eg: file://test.txt). It might be a good idea to test if the uri points to a file.
+    let folder: string = '.';
+    if (workspace.workspaceFolders !== undefined) {
+        folder = workspace.workspaceFolders[0].uri.fsPath.toString();
+    }
+
+    const command = expandPathResolving(config.raLspServerPath);
+    const run: lc.Executable = {
+        command,
+        options: { cwd: folder },
+    };
+    const serverOptions: lc.ServerOptions = {
+        run,
+        debug: run,
+    };
+    const traceOutputChannel = window.createOutputChannel(
+        'Rust Analyzer Language Server Trace',
+    );
+    const clientOptions: lc.LanguageClientOptions = {
+        documentSelector: [{ scheme: 'file', language: 'rust' }],
+        initializationOptions: {
+            publishDecorations: true,
+            lruCapacity: config.lruCapacity,
+            maxInlayHintLength: config.maxInlayHintLength,
+            cargoWatchEnable: config.cargoWatchOptions.enable,
+            cargoWatchArgs: config.cargoWatchOptions.arguments,
+            cargoWatchCommand: config.cargoWatchOptions.command,
+            cargoWatchAllTargets:
+                config.cargoWatchOptions.allTargets,
+            excludeGlobs: config.excludeGlobs,
+            useClientWatching: config.useClientWatching,
+            featureFlags: config.featureFlags,
+            withSysroot: config.withSysroot,
+            cargoFeatures: config.cargoFeatures,
+        },
+        traceOutputChannel,
+    };
+
+    const res = new lc.LanguageClient(
+        'rust-analyzer',
+        'Rust Analyzer Language Server',
+        serverOptions,
+        clientOptions,
+    );
+
+    // HACK: This is an awful way of filtering out the decorations notifications
+    // However, pending proper support, this is the most effecitve approach
+    // Proper support for this would entail a change to vscode-languageclient to allow not notifying on certain messages
+    // Or the ability to disable the serverside component of highlighting (but this means that to do tracing we need to disable hihlighting)
+    // This also requires considering our settings strategy, which is work which needs doing
+    // @ts-ignore The tracer is private to vscode-languageclient, but we need access to it to not log publishDecorations requests
+    res._tracer = {
+        log: (messageOrDataObject: string | any, data?: string) => {
+            if (typeof messageOrDataObject === 'string') {
+                if (
+                    messageOrDataObject.includes(
+                        'rust-analyzer/publishDecorations',
+                    ) ||
+                    messageOrDataObject.includes(
+                        'rust-analyzer/decorationsRequest',
+                    )
+                ) {
+                    // Don't log publish decorations requests
+                } else {
+                    // @ts-ignore This is just a utility function
+                    res.logTrace(messageOrDataObject, data);
+                }
+            } else {
+                // @ts-ignore
+                res.logObjectTrace(messageOrDataObject);
+            }
+        },
+    };
+    res.registerProposedFeatures()
+    return res;
+}
+function expandPathResolving(path: string) {
+    if (path.startsWith('~/')) {
+        return path.replace('~', homedir());
+    }
+    return path;
+}

editors/code/src/commands/analyzer_status.ts

@@ -49,9 +49,10 @@ class TextDocumentContentProvider
         _uri: vscode.Uri,
     ): vscode.ProviderResult<string> {
         const editor = vscode.window.activeTextEditor;
-        if (editor == null) return '';
+        const client = this.ctx.client
+        if (!editor || !client) return '';
 
-        return this.ctx.client.sendRequest<string>(
+        return client.sendRequest<string>(
             'rust-analyzer/analyzerStatus',
             null,
         );

editors/code/src/commands/expand_macro.ts

@@ -52,14 +52,15 @@ class TextDocumentContentProvider
 
     async provideTextDocumentContent(_uri: vscode.Uri): Promise<string> {
         const editor = vscode.window.activeTextEditor;
-        if (editor == null) return '';
+        const client = this.ctx.client
+        if (!editor || !client) return '';
 
         const position = editor.selection.active;
         const request: lc.TextDocumentPositionParams = {
             textDocument: { uri: editor.document.uri.toString() },
             position,
         };
-        const expanded = await this.ctx.client.sendRequest<ExpandedMacro>(
+        const expanded = await client.sendRequest<ExpandedMacro>(
             'rust-analyzer/expandMacro',
             request,
         );

editors/code/src/commands/index.ts

@@ -15,18 +15,21 @@ import { run, runSingle } from './runnables';
 
 function collectGarbage(ctx: Ctx): Cmd {
     return async () => {
-        ctx.client.sendRequest<null>('rust-analyzer/collectGarbage', null);
+        ctx.client?.sendRequest<null>('rust-analyzer/collectGarbage', null);
     };
 }
 
 function showReferences(ctx: Ctx): Cmd {
     return (uri: string, position: lc.Position, locations: lc.Location[]) => {
-        vscode.commands.executeCommand(
-            'editor.action.showReferences',
-            vscode.Uri.parse(uri),
-            ctx.client.protocol2CodeConverter.asPosition(position),
-            locations.map(ctx.client.protocol2CodeConverter.asLocation),
-        );
+        let client = ctx.client;
+        if (client) {
+            vscode.commands.executeCommand(
+                'editor.action.showReferences',
+                vscode.Uri.parse(uri),
+                client.protocol2CodeConverter.asPosition(position),
+                locations.map(client.protocol2CodeConverter.asLocation),
+            );
+        }
     };
 }
 
@@ -36,6 +39,13 @@ function applySourceChange(ctx: Ctx): Cmd {
     }
 }
 
+function reload(ctx: Ctx): Cmd {
+    return async () => {
+        vscode.window.showInformationMessage('Reloading rust-analyzer...');
+        await ctx.restartServer();
+    }
+}
+
 export {
     analyzerStatus,
     expandMacro,
@@ -49,4 +59,5 @@ export {
     runSingle,
     showReferences,
     applySourceChange,
+    reload
 };

editors/code/src/commands/join_lines.ts

@@ -6,13 +6,14 @@ import { applySourceChange, SourceChange } from '../source_change';
 export function joinLines(ctx: Ctx): Cmd {
     return async () => {
         const editor = ctx.activeRustEditor;
-        if (!editor) return;
+        const client = ctx.client;
+        if (!editor || !client) return;
 
         const request: JoinLinesParams = {
-            range: ctx.client.code2ProtocolConverter.asRange(editor.selection),
+            range: client.code2ProtocolConverter.asRange(editor.selection),
             textDocument: { uri: editor.document.uri.toString() },
         };
-        const change = await ctx.client.sendRequest<SourceChange>(
+        const change = await client.sendRequest<SourceChange>(
             'rust-analyzer/joinLines',
             request,
         );

editors/code/src/config.ts

@@ -16,25 +16,25 @@ export interface CargoFeatures {
 }
 
 export class Config {
-    public highlightingOn = true;
-    public rainbowHighlightingOn = false;
-    public enableEnhancedTyping = true;
-    public raLspServerPath = RA_LSP_DEBUG || 'ra_lsp_server';
-    public lruCapacity: null | number = null;
-    public displayInlayHints = true;
-    public maxInlayHintLength: null | number = null;
-    public excludeGlobs = [];
-    public useClientWatching = true;
-    public featureFlags = {};
+    highlightingOn = true;
+    rainbowHighlightingOn = false;
+    enableEnhancedTyping = true;
+    raLspServerPath = RA_LSP_DEBUG || 'ra_lsp_server';
+    lruCapacity: null | number = null;
+    displayInlayHints = true;
+    maxInlayHintLength: null | number = null;
+    excludeGlobs = [];
+    useClientWatching = true;
+    featureFlags = {};
     // for internal use
-    public withSysroot: null | boolean = null;
-    public cargoWatchOptions: CargoWatchOptions = {
+    withSysroot: null | boolean = null;
+    cargoWatchOptions: CargoWatchOptions = {
         enable: true,
         arguments: [],
         command: '',
         allTargets: true,
     };
-    public cargoFeatures: CargoFeatures = {
+    cargoFeatures: CargoFeatures = {
         noDefaultFeatures: false,
         allFeatures: true,
         features: [],
@@ -43,14 +43,12 @@ export class Config {
     private prevEnhancedTyping: null | boolean = null;
     private prevCargoFeatures: null | CargoFeatures = null;
 
-    constructor() {
-        vscode.workspace.onDidChangeConfiguration(_ =>
-            this.userConfigChanged(),
-        );
-        this.userConfigChanged();
+    constructor(ctx: vscode.ExtensionContext) {
+        vscode.workspace.onDidChangeConfiguration(_ => this.refresh(), ctx.subscriptions);
+        this.refresh();
     }
 
-    public userConfigChanged() {
+    private refresh() {
         const config = vscode.workspace.getConfiguration('rust-analyzer');
 
         let requireReloadMessage = null;

editors/code/src/ctx.ts

@@ -1,21 +1,38 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
-import { Server } from './server';
 import { Config } from './config';
+import { createClient } from './client'
 
 export class Ctx {
+    readonly config: Config;
+    // Because we have "reload server" action, various listeners **will** face a
+    // situation where the client is not ready yet, and should be prepared to
+    // deal with it.
+    //
+    // Ideally, this should be replaced with async getter though.
+    client: lc.LanguageClient | null = null
     private extCtx: vscode.ExtensionContext;
+    private onDidRestartHooks: Array<(client: lc.LanguageClient) => void> = [];
 
     constructor(extCtx: vscode.ExtensionContext) {
+        this.config = new Config(extCtx)
         this.extCtx = extCtx;
     }
 
-    get client(): lc.LanguageClient {
-        return Server.client;
-    }
+    async restartServer() {
+        let old = this.client;
+        if (old) {
+            await old.stop()
+        }
+        this.client = null;
+        const client = createClient(this.config);
+        this.pushCleanup(client.start());
+        await client.onReady();
 
-    get config(): Config {
-        return Server.config;
+        this.client = client
+        for (const hook of this.onDidRestartHooks) {
+            hook(client)
+        }
     }
 
     get activeRustEditor(): vscode.TextEditor | undefined {
@@ -62,30 +79,34 @@ export class Ctx {
         this.extCtx.subscriptions.push(d);
     }
 
-    async sendRequestWithRetry<R>(
-        method: string,
-        param: any,
-        token?: vscode.CancellationToken,
-    ): Promise<R> {
-        await this.client.onReady();
-        for (const delay of [2, 4, 6, 8, 10, null]) {
-            try {
-                return await (token ? this.client.sendRequest(method, param, token) : this.client.sendRequest(method, param));
-            } catch (e) {
-                if (
-                    e.code === lc.ErrorCodes.ContentModified &&
-                    delay !== null
-                ) {
-                    await sleep(10 * (1 << delay));
-                    continue;
-                }
-                throw e;
-            }
-        }
-        throw 'unreachable';
+    onDidRestart(hook: (client: lc.LanguageClient) => void) {
+        this.onDidRestartHooks.push(hook)
     }
 }
 
 export type Cmd = (...args: any[]) => any;
 
+export async function sendRequestWithRetry<R>(
+    client: lc.LanguageClient,
+    method: string,
+    param: any,
+    token?: vscode.CancellationToken,
+): Promise<R> {
+    for (const delay of [2, 4, 6, 8, 10, null]) {
+        try {
+            return await (token ? client.sendRequest(method, param, token) : client.sendRequest(method, param));
+        } catch (e) {
+            if (
+                e.code === lc.ErrorCodes.ContentModified &&
+                delay !== null
+            ) {
+                await sleep(10 * (1 << delay));
+                continue;
+            }
+            throw e;
+        }
+    }
+    throw 'unreachable';
+}
+
 const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));