7 files changed, 157 insertions, 57 deletions

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index fac1a0be3..d64f9a3f9 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -41,10 +41,12 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
                 return client.sendRequest(lc.CodeActionRequest.type, params, token).then((values) => {
                     if (values === null) return undefined;
                     const result: (vscode.CodeAction | vscode.Command)[] = [];
+                    const groups = new Map<string, { index: number; items: vscode.CodeAction[] }>();
                     for (const item of values) {
                         if (lc.CodeAction.is(item)) {
                             const action = client.protocol2CodeConverter.asCodeAction(item);
-                            if (isSnippetEdit(item)) {
+                            const group = actionGroup(item);
+                            if (isSnippetEdit(item) || group) {
                                 action.command = {
                                     command: "rust-analyzer.applySnippetWorkspaceEdit",
                                     title: "",
@@ -52,12 +54,38 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
                                 };
                                 action.edit = undefined;
                             }
-                            result.push(action);
+
+                            if (group) {
+                                let entry = groups.get(group);
+                                if (!entry) {
+                                    entry = { index: result.length, items: [] };
+                                    groups.set(group, entry);
+                                    result.push(action);
+                                }
+                                entry.items.push(action);
+                            } else {
+                                result.push(action);
+                            }
                         } else {
                             const command = client.protocol2CodeConverter.asCommand(item);
                             result.push(command);
                         }
                     }
+                    for (const [group, { index, items }] of groups) {
+                        if (items.length === 1) {
+                            result[index] = items[0];
+                        } else {
+                            const action = new vscode.CodeAction(group);
+                            action.command = {
+                                command: "rust-analyzer.applyActionGroup",
+                                title: "",
+                                arguments: [items.map((item) => {
+                                    return { label: item.title, edit: item.command!!.arguments!![0] };
+                                })],
+                            };
+                            result[index] = action;
+                        }
+                    }
                     return result;
                 },
                     (_error) => undefined
@@ -81,15 +109,16 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
     // implementations are still in the "proposed" category for 3.16.
     client.registerFeature(new CallHierarchyFeature(client));
     client.registerFeature(new SemanticTokensFeature(client));
-    client.registerFeature(new SnippetTextEditFeature());
+    client.registerFeature(new ExperimentalFeatures());
 
     return client;
 }
 
-class SnippetTextEditFeature implements lc.StaticFeature {
+class ExperimentalFeatures implements lc.StaticFeature {
     fillClientCapabilities(capabilities: lc.ClientCapabilities): void {
         const caps: any = capabilities.experimental ?? {};
         caps.snippetTextEdit = true;
+        caps.codeActionGroup = true;
         capabilities.experimental = caps;
     }
     initialize(_capabilities: lc.ServerCapabilities<any>, _documentSelector: lc.DocumentSelector | undefined): void {
@@ -107,3 +136,7 @@ function isSnippetEdit(action: lc.CodeAction): boolean {
     }
     return false;
 }
+
+function actionGroup(action: lc.CodeAction): string | undefined {
+    return (action as any).group;
+}
diff --git a/editors/code/src/commands/index.ts b/editors/code/src/commands/index.ts
index 0937b495c..abb53a248 100644
--- a/editors/code/src/commands/index.ts
+++ b/editors/code/src/commands/index.ts
@@ -41,48 +41,65 @@ export function applySourceChange(ctx: Ctx): Cmd {
     };
 }
 
-export function selectAndApplySourceChange(ctx: Ctx): Cmd {
-    return async (changes: ra.SourceChange[]) => {
-        if (changes.length === 1) {
-            await sourceChange.applySourceChange(ctx, changes[0]);
-        } else if (changes.length > 0) {
-            const selectedChange = await vscode.window.showQuickPick(changes);
-            if (!selectedChange) return;
-            await sourceChange.applySourceChange(ctx, selectedChange);
-        }
+export function applyActionGroup(_ctx: Ctx): Cmd {
+    return async (actions: { label: string; edit: vscode.WorkspaceEdit }[]) => {
+        const selectedAction = await vscode.window.showQuickPick(actions);
+        if (!selectedAction) return;
+        await applySnippetWorkspaceEdit(selectedAction.edit);
     };
 }
 
-export function applySnippetWorkspaceEdit(_ctx: Ctx): Cmd {
+export function applySnippetWorkspaceEditCommand(_ctx: Ctx): Cmd {
     return async (edit: vscode.WorkspaceEdit) => {
-        assert(edit.entries().length === 1, `bad ws edit: ${JSON.stringify(edit)}`);
-        const [uri, edits] = edit.entries()[0];
+        await applySnippetWorkspaceEdit(edit);
+    };
+}
 
-        const editor = vscode.window.visibleTextEditors.find((it) => it.document.uri.toString() === uri.toString());
-        if (!editor) return;
+export async function applySnippetWorkspaceEdit(edit: vscode.WorkspaceEdit) {
+    assert(edit.entries().length === 1, `bad ws edit: ${JSON.stringify(edit)}`);
+    const [uri, edits] = edit.entries()[0];
 
-        let editWithSnippet: vscode.TextEdit | undefined = undefined;
-        let lineDelta = 0;
-        await editor.edit((builder) => {
-            for (const indel of edits) {
-                const isSnippet = indel.newText.indexOf('$0') !== -1 || indel.newText.indexOf('${') !== -1;
-                if (isSnippet) {
-                    editWithSnippet = indel;
-                } else {
-                    if (!editWithSnippet) {
-                        lineDelta = (indel.newText.match(/\n/g) || []).length - (indel.range.end.line - indel.range.start.line);
-                    }
-                    builder.replace(indel.range, indel.newText);
-                }
+    const editor = vscode.window.visibleTextEditors.find((it) => it.document.uri.toString() === uri.toString());
+    if (!editor) return;
+
+    let selection: vscode.Selection | undefined = undefined;
+    let lineDelta = 0;
+    await editor.edit((builder) => {
+        for (const indel of edits) {
+            const parsed = parseSnippet(indel.newText);
+            if (parsed) {
+                const [newText, [placeholderStart, placeholderLength]] = parsed;
+                const prefix = newText.substr(0, placeholderStart);
+                const lastNewline = prefix.lastIndexOf('\n');
+
+                const startLine = indel.range.start.line + lineDelta + countLines(prefix);
+                const startColumn = lastNewline === -1 ?
+                    indel.range.start.character + placeholderStart
+                    : prefix.length - lastNewline - 1;
+                const endColumn = startColumn + placeholderLength;
+                selection = new vscode.Selection(
+                    new vscode.Position(startLine, startColumn),
+                    new vscode.Position(startLine, endColumn),
+                );
+                builder.replace(indel.range, newText);
+            } else {
+                lineDelta = countLines(indel.newText) - (indel.range.end.line - indel.range.start.line);
+                builder.replace(indel.range, indel.newText);
             }
-        });
-        if (editWithSnippet) {
-            const snip = editWithSnippet as vscode.TextEdit;
-            const range = snip.range.with(
-                snip.range.start.with(snip.range.start.line + lineDelta),
-                snip.range.end.with(snip.range.end.line + lineDelta),
-            );
-            await editor.insertSnippet(new vscode.SnippetString(snip.newText), range);
         }
-    };
+    });
+    if (selection) editor.selection = selection;
+}
+
+function parseSnippet(snip: string): [string, [number, number]] | undefined {
+    const m = snip.match(/\$(0|\{0:([^}]*)\})/);
+    if (!m) return undefined;
+    const placeholder = m[2] ?? "";
+    const range: [number, number] = [m.index!!, placeholder.length];
+    const insert = snip.replace(m[0], placeholder);
+    return [insert, range];
+}
+
+function countLines(text: string): number {
+    return (text.match(/\n/g) || []).length;
 }
diff --git a/editors/code/src/commands/join_lines.ts b/editors/code/src/commands/join_lines.ts
index de0614653..0bf1ee6e6 100644
--- a/editors/code/src/commands/join_lines.ts
+++ b/editors/code/src/commands/join_lines.ts
@@ -1,7 +1,7 @@
 import * as ra from '../rust-analyzer-api';
+import * as lc from 'vscode-languageclient';
 
 import { Ctx, Cmd } from '../ctx';
-import { applySourceChange } from '../source_change';
 
 export function joinLines(ctx: Ctx): Cmd {
     return async () => {
@@ -9,10 +9,14 @@ export function joinLines(ctx: Ctx): Cmd {
         const client = ctx.client;
         if (!editor || !client) return;
 
-        const change = await client.sendRequest(ra.joinLines, {
-            range: client.code2ProtocolConverter.asRange(editor.selection),
+        const items: lc.TextEdit[] = await client.sendRequest(ra.joinLines, {
+            ranges: editor.selections.map((it) => client.code2ProtocolConverter.asRange(it)),
             textDocument: { uri: editor.document.uri.toString() },
         });
-        await applySourceChange(ctx, change);
+        editor.edit((builder) => {
+            client.protocol2CodeConverter.asTextEdits(items).forEach((edit) => {
+                builder.replace(edit.range, edit.newText);
+            });
+        });
     };
 }
diff --git a/editors/code/src/commands/on_enter.ts b/editors/code/src/commands/on_enter.ts
index 285849db7..a7871c31e 100644
--- a/editors/code/src/commands/on_enter.ts
+++ b/editors/code/src/commands/on_enter.ts
@@ -1,8 +1,8 @@
 import * as vscode from 'vscode';
 import * as ra from '../rust-analyzer-api';
 
-import { applySourceChange } from '../source_change';
 import { Cmd, Ctx } from '../ctx';
+import { applySnippetWorkspaceEdit } from '.';
 
 async function handleKeypress(ctx: Ctx) {
     const editor = ctx.activeRustEditor;
@@ -21,7 +21,8 @@ async function handleKeypress(ctx: Ctx) {
     });
     if (!change) return false;
 
-    await applySourceChange(ctx, change);
+    const workspaceEdit = client.protocol2CodeConverter.asWorkspaceEdit(change);
+    await applySnippetWorkspaceEdit(workspaceEdit);
     return true;
 }
 
diff --git a/editors/code/src/commands/ssr.ts b/editors/code/src/commands/ssr.ts
index 4ef8cdf04..5d40a64d2 100644
--- a/editors/code/src/commands/ssr.ts
+++ b/editors/code/src/commands/ssr.ts
@@ -2,7 +2,6 @@ import * as vscode from 'vscode';
 import * as ra from "../rust-analyzer-api";
 
 import { Ctx, Cmd } from '../ctx';
-import { applySourceChange } from '../source_change';
 
 export function ssr(ctx: Ctx): Cmd {
     return async () => {
@@ -22,11 +21,10 @@ export function ssr(ctx: Ctx): Cmd {
             }
         };
         const request = await vscode.window.showInputBox(options);
-
         if (!request) return;
 
-        const change = await client.sendRequest(ra.ssr, { query: request, parseOnly: false });
+        const edit = await client.sendRequest(ra.ssr, { query: request, parseOnly: false });
 
-        await applySourceChange(ctx, change);
+        await vscode.workspace.applyEdit(client.protocol2CodeConverter.asWorkspaceEdit(edit));
     };
 }
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index ac3bb365e..3405634f3 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -1,7 +1,7 @@
 import * as vscode from 'vscode';
 import * as path from "path";
 import * as os from "os";
-import { promises as fs } from "fs";
+import { promises as fs, PathLike } from "fs";
 
 import * as commands from './commands';
 import { activateInlayHints } from './inlay_hints';
@@ -12,6 +12,7 @@ import { log, assert, isValidExecutable } from './util';
 import { PersistentState } from './persistent_state';
 import { fetchRelease, download } from './net';
 import { activateTaskProvider } from './tasks';
+import { exec } from 'child_process';
 
 let ctx: Ctx | undefined;
 
@@ -91,8 +92,8 @@ export async function activate(context: vscode.ExtensionContext) {
     ctx.registerCommand('debugSingle', commands.debugSingle);
     ctx.registerCommand('showReferences', commands.showReferences);
     ctx.registerCommand('applySourceChange', commands.applySourceChange);
-    ctx.registerCommand('applySnippetWorkspaceEdit', commands.applySnippetWorkspaceEdit);
-    ctx.registerCommand('selectAndApplySourceChange', commands.selectAndApplySourceChange);
+    ctx.registerCommand('applySnippetWorkspaceEdit', commands.applySnippetWorkspaceEditCommand);
+    ctx.registerCommand('applyActionGroup', commands.applyActionGroup);
 
     ctx.pushCleanup(activateTaskProvider(workspaceFolder));
 
@@ -188,6 +189,46 @@ async function bootstrapServer(config: Config, state: PersistentState): Promise<
     return path;
 }
 
+async function patchelf(dest: PathLike): Promise<void> {
+    await vscode.window.withProgress(
+        {
+            location: vscode.ProgressLocation.Notification,
+            title: "Patching rust-analyzer for NixOS"
+        },
+        async (progress, _) => {
+            const expression = `
+            {src, pkgs ? import <nixpkgs> {}}:
+                pkgs.stdenv.mkDerivation {
+                    name = "rust-analyzer";
+                    inherit src;
+                    phases = [ "installPhase" "fixupPhase" ];
+                    installPhase = "cp $src $out";
+                    fixupPhase = ''
+                    chmod 755 $out
+                    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $out
+                    '';
+                }
+            `;
+            const origFile = dest + "-orig";
+            await fs.rename(dest, origFile);
+            progress.report({ message: "Patching executable", increment: 20 });
+            await new Promise((resolve, reject) => {
+                const handle = exec(`nix-build -E - --arg src '${origFile}' -o ${dest}`,
+                    (err, stdout, stderr) => {
+                        if (err != null) {
+                            reject(Error(stderr));
+                        } else {
+                            resolve(stdout);
+                        }
+                    });
+                handle.stdin?.write(expression);
+                handle.stdin?.end();
+            });
+            await fs.unlink(origFile);
+        }
+    );
+}
+
 async function getServer(config: Config, state: PersistentState): Promise<string | undefined> {
     const explicitPath = process.env.__RA_LSP_SERVER_DEBUG ?? config.serverPath;
     if (explicitPath) {
@@ -237,6 +278,12 @@ async function getServer(config: Config, state: PersistentState): Promise<string
     assert(!!artifact, `Bad release: ${JSON.stringify(release)}`);
 
     await download(artifact.browser_download_url, dest, "Downloading rust-analyzer server", { mode: 0o755 });
+
+    // Patching executable if that's NixOS.
+    if (await fs.stat("/etc/nixos").then(_ => true).catch(_ => false)) {
+        await patchelf(dest);
+    }
+
     await state.updateServerVersion(config.package.version);
     return dest;
 }
diff --git a/editors/code/src/rust-analyzer-api.ts b/editors/code/src/rust-analyzer-api.ts
index 400ac3714..73f36432f 100644
--- a/editors/code/src/rust-analyzer-api.ts
+++ b/editors/code/src/rust-analyzer-api.ts
@@ -64,12 +64,12 @@ export const parentModule = request<lc.TextDocumentPositionParams, Vec<lc.Locati
 
 export interface JoinLinesParams {
     textDocument: lc.TextDocumentIdentifier;
-    range: lc.Range;
+    ranges: lc.Range[];
 }
-export const joinLines = request<JoinLinesParams, SourceChange>("joinLines");
+export const joinLines = new lc.RequestType<JoinLinesParams, lc.TextEdit[], unknown>('experimental/joinLines');
 
 
-export const onEnter = request<lc.TextDocumentPositionParams, Option<SourceChange>>("onEnter");
+export const onEnter = request<lc.TextDocumentPositionParams, Option<lc.WorkspaceEdit>>("onEnter");
 
 export interface RunnablesParams {
     textDocument: lc.TextDocumentIdentifier;
@@ -112,7 +112,7 @@ export interface SsrParams {
     query: string;
     parseOnly: boolean;
 }
-export const ssr = request<SsrParams, SourceChange>("ssr");
+export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, unknown>('experimental/ssr');
 
 
 export const publishDecorations = notification<PublishDecorationsParams>("publishDecorations");