fix(completion): leave items their server inserts to the server (#3505)

kotlin-lsp items carry an empty text and a command that inserts them through a workspace edit. We added call parentheses to method items anyway (refreshName()(), an override's body followed by ()) and left the caret in front of the server's text. Items with an empty text get no parentheses, and the caret moves past the server's edit when it lands at the caret.
This commit is contained in:
l0ng-ai
2026-11-15 16:38:37 +08:00
committed by GitHub
parent d4b2ade24d
commit 0f91aac0d4
2 changed files with 77 additions and 6 deletions
+28 -1
View File
@@ -2,7 +2,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
import { EditorState, StateEffect, type Extension } from "@codemirror/state";
import { EditorView, runScopeHandlers } from "@codemirror/view";
import type { CompletionItem } from "@/bindings";
import type { EditorDocContext } from "@/editor/api";
import { remoteChange, type EditorDocContext } from "@/editor/api";
import { lspDoc } from "./lsp";
import { insertTab, tabOut, tabOutOfScope } from "@/editor/core/cm/smartKeys";
import {
@@ -294,6 +294,32 @@ describe("applying completions", () => {
await vi.waitFor(() => expect(view.state.selection.main.head).toBe(17));
});
it("leaves an item its server inserts to the server, and puts the caret after what it inserted", async () => {
const executed: string[] = [];
setInvokeRoute((cmd) => {
executed.push(cmd);
return Promise.resolve(null);
});
try {
const { view, req } = setup("p.ref|\n", "", [completionExtension()]);
view.dispatch({ effects: StateEffect.appendConfig.of(lspDoc.of({ doc: 1 } as EditorDocContext)) });
// kotlin-lsp: an empty text, inserted by `jetbrains.kotlin.completion.apply` as a workspace edit.
const command = { title: "Apply Completion", command: "jetbrains.kotlin.completion.apply", arguments: ["1"] };
const kotlin = item({ label: "refreshName", labelDetail: "()", insertText: "", command });
applyLspCompletion(view, makeCompletion(kotlin, req), 5, 5, "insert");
expect(view.state.doc.toString()).toBe("p.ref\n");
await vi.waitFor(() => expect(executed).toContain("lsp_execute_command"));
view.dispatch({ changes: { from: 5, insert: "reshName()" }, annotations: remoteChange.of(true) });
expect(view.state.doc.toString()).toBe("p.refreshName()\n");
expect(view.state.selection.main.head).toBe(15);
// Later edits from elsewhere leave the caret alone.
view.dispatch({ changes: { from: 15, insert: " " }, annotations: remoteChange.of(true) });
expect(view.state.selection.main.head).toBe(15);
} finally {
setInvokeRoute(null);
}
});
it("does not register a scope when jumping outside closing brackets is off", () => {
const { view, req } = setup("service.cr|");
applyLspCompletion(view, makeCompletion(item(), req), 8, 10, "insert");
@@ -532,6 +558,7 @@ describe("insert parentheses", () => {
expect(callParens(item({ kind: "field" }), line("a.cr"), 2, 4)).toBeNull();
expect(callParens(item({ isSnippet: true }), line("a.cr"), 2, 4)).toBeNull();
expect(callParens(item({ insertText: "create()" }), line("a.cr"), 2, 4)).toBeNull();
expect(callParens(item({ insertText: "" }), line("a.cr"), 4, 4)).toBeNull();
});
it("skips calls that already have parentheses and imports", () => {
+49 -5
View File
@@ -24,7 +24,7 @@ import {
type CompletionResult,
type CompletionSource,
} from "@codemirror/autocomplete";
import { EditorSelection, Prec, type Text } from "@codemirror/state";
import { EditorSelection, EditorState, Prec, StateEffect, StateField, type Text } from "@codemirror/state";
import { EditorView, ViewPlugin, keymap, type ViewUpdate } from "@codemirror/view";
import {
call,
@@ -58,6 +58,7 @@ import { tx } from "@/platform/i18n";
import { showHint } from "./hint";
import { inplaceRenameActive } from "./inplaceRename";
import { languageSemantics } from "./semantic";
import { remoteChange } from "@/editor/api";
interface RequestContext {
doc: number;
@@ -297,7 +298,9 @@ export function callParens(
start: number,
end: number,
): "inside" | "after" | null {
if (item.isSnippet || !item.kind || !CALLABLE.has(item.kind) || /[(<[{]/.test(item.insertText)) return null;
// An empty text is inserted by the item's server command (kotlin-lsp), parentheses included.
if (item.isSnippet || !item.kind || !CALLABLE.has(item.kind) || !item.insertText || /[(<[{]/.test(item.insertText))
return null;
const next = line.text.charAt(end - line.from);
if (next && /[(\p{L}\p{N}_$'"`]/u.test(next)) return null;
if (IMPORT_LINE.test(line.text.slice(0, start - line.from))) return null;
@@ -322,6 +325,33 @@ async function applyLateEdits(view: EditorView, c: LspCompletion, insertedAt: nu
view.dispatch({ changes: edits, userEvent: "input.complete" });
}
/** Where the caret was when an item its server inserts was picked, until that edit lands (`null`: none). */
const awaitServerInsert = StateEffect.define<number | null>();
const serverInsertAt = StateField.define<number | null>({
create: () => null,
update(at, tr) {
for (const e of tr.effects) if (e.is(awaitServerInsert)) return e.value;
// The edit landed, or the caret moved on before it did.
if (at === null || tr.annotation(remoteChange) || tr.selection) return null;
return tr.changes.mapPos(at, -1);
},
});
/**
* The server's edit inserts the item at the caret: the caret goes after it, as after any other
* completion (a remote insertion at the caret would otherwise leave it in front).
*/
const caretAfterServerInsert = EditorState.transactionFilter.of((tr) => {
const at = tr.startState.field(serverInsertAt, false);
const caret = tr.startState.selection.main;
if (at == null || !tr.docChanged || !tr.annotation(remoteChange) || !caret.empty || caret.head !== at) return tr;
let inserted = false;
tr.changes.iterChangedRanges((fromA, toA) => {
if (fromA <= at && toA >= at) inserted = true;
});
return inserted ? [tr, { selection: EditorSelection.cursor(tr.changes.mapPos(at, 1)), sequential: true }] : tr;
});
/** Client-side commands handled by the editor itself (VS Code ids servers commonly send). */
const CLIENT_COMMANDS = new Set(["editor.action.triggerParameterHints", "editor.action.triggerSuggest"]);
@@ -329,18 +359,30 @@ function runCommand(view: EditorView, item: CompletionItem) {
const command = item.command;
if (!command?.command) return;
const cmd = command.command;
// kotlin-lsp inserts the item itself (`jetbrains.kotlin.completion.apply`): nothing went in here.
const serverInserted = !item.insertText && !CLIENT_COMMANDS.has(cmd) && !cmd.startsWith("editor.");
if (serverInserted) view.dispatch({ effects: awaitServerInsert.of(view.state.selection.main.head) });
if (cmd === "editor.action.triggerParameterHints") setTimeout(() => triggerSignatureHelp(view), 0);
else if (cmd === "editor.action.triggerSuggest") setTimeout(() => startCompletion(view), 0);
else if (!CLIENT_COMMANDS.has(cmd) && !cmd.startsWith("editor.")) {
const doc = docOf(view);
// Server commands (auto-import, postfix…); resulting edits come back as workspace/applyEdit.
if (doc)
void lspRequest(() => commands.lspExecuteCommand(doc.doc, command)).catch((e: unknown) =>
reportLspError(view, e, false),
);
void lspRequest(() => commands.lspExecuteCommand(doc.doc, command))
.catch((e: unknown) => reportLspError(view, e, false))
.finally(() => {
// The edit arrives before the command's answer; allow for the document update.
if (serverInserted)
setTimeout(() => {
if (view.dom.isConnected && view.state.field(serverInsertAt, false) != null)
view.dispatch({ effects: awaitServerInsert.of(null) });
}, SERVER_INSERT_WAIT_MS);
});
}
}
const SERVER_INSERT_WAIT_MS = 1000;
// ---------------------------------------------------------------------------
// Source
@@ -828,6 +870,8 @@ export function completionExtension() {
}),
completionFooter,
lookupTracker,
serverInsertAt,
caretAfterServerInsert,
Prec.highest(
keymap.of([
// macOS: ⌃N / ⌃P are line down / up in text, so they move through the lookup as ↓ / ↑ do.