1 files changed, 93 insertions, 5 deletions

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index cffdcf11a..d64f9a3f9 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -31,24 +31,112 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
                 const res = await next(document, token);
                 if (res === undefined) throw new Error('busy');
                 return res;
+            },
+            async provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken, _next: lc.ProvideCodeActionsSignature) {
+                const params: lc.CodeActionParams = {
+                    textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
+                    range: client.code2ProtocolConverter.asRange(range),
+                    context: client.code2ProtocolConverter.asCodeActionContext(context)
+                };
+                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);
+                            const group = actionGroup(item);
+                            if (isSnippetEdit(item) || group) {
+                                action.command = {
+                                    command: "rust-analyzer.applySnippetWorkspaceEdit",
+                                    title: "",
+                                    arguments: [action.edit],
+                                };
+                                action.edit = undefined;
+                            }
+
+                            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
+                );
             }
+
         } as any
     };
 
-    const res = new lc.LanguageClient(
+    const client = new lc.LanguageClient(
         'rust-analyzer',
         'Rust Analyzer Language Server',
         serverOptions,
         clientOptions,
     );
 
-    // To turn on all proposed features use: res.registerProposedFeatures();
+    // To turn on all proposed features use: client.registerProposedFeatures();
     // Here we want to enable CallHierarchyFeature and SemanticTokensFeature
     // since they are available on stable.
     // Note that while these features are stable in vscode their LSP protocol
     // implementations are still in the "proposed" category for 3.16.
-    res.registerFeature(new CallHierarchyFeature(res));
-    res.registerFeature(new SemanticTokensFeature(res));
+    client.registerFeature(new CallHierarchyFeature(client));
+    client.registerFeature(new SemanticTokensFeature(client));
+    client.registerFeature(new ExperimentalFeatures());
+
+    return client;
+}
+
+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 {
+    }
+}
+
+function isSnippetEdit(action: lc.CodeAction): boolean {
+    const documentChanges = action.edit?.documentChanges ?? [];
+    for (const edit of documentChanges) {
+        if (lc.TextDocumentEdit.is(edit)) {
+            if (edit.edits.some((indel) => (indel as any).insertTextFormat === lc.InsertTextFormat.Snippet)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 
-    return res;
+function actionGroup(action: lc.CodeAction): string | undefined {
+    return (action as any).group;
 }