Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

fix(editor): Ctrl/⌘-hover info replaces hover popups instead of stacking (#60)

l0ng-aie16253a890b6
diff --git a/src/editor/lsp/hover.ts b/src/editor/lsp/hover.ts
index e9706558a..955efc28e 100644
--- a/src/editor/lsp/hover.ts
+++ b/src/editor/lsp/hover.ts
@@ -4,7 +4,8 @@
* history, `docs.ts`) and code.quickDefinition (⌥Space, definition source popup).
*/
import { EditorSelection } from "@codemirror/state";
-import { hoverTooltip, type EditorView } from "@codemirror/view";
+import { closeHoverTooltips, hasHoverTooltips, hoverTooltip, ViewPlugin, type EditorView } from "@codemirror/view";
+import type { Extension } from "@codemirror/state";
import {
commands,
isTauri,
@@ -32,6 +33,7 @@ import { basename } from "@/platform/project";
import { iconNode } from "./iconMarkup";
import { editorPrefs } from "@/platform/editorSettings";
import { CONTRIBUTED_HOVER, contributedAt, type ContributedHover } from "@/editor/api";
+import { navigationModifierHeld, onNavigationModifier, pointerTarget } from "@/platform/navigationModifier";
let hoverRequest: RequestId | null = null;
@@ -98,43 +100,78 @@ function renderDiagnostics(view: EditorView, diags: PlacedDiagnostic[]): HTMLEle
return box;
}
-/** Hover: problems always; quick documentation per Settings › Editor › Code Editing. */
-export function hoverExtension() {
- return hoverTooltip(
- async (view, pos) => {
- const diags = diagnosticsAt(view, pos);
- let hover: Hover | null = null;
- if (editorPrefs().codeEditing.quickDocOnHover)
- try {
- hover = await requestHover(view, pos);
- } catch (e) {
- reportLspError(view, e, false);
- }
- if (!diags.length && !hover) return null;
- let from = pos,
- to = pos;
- if (hover?.range) ({ from, to } = rangeToOffsets(view.state.doc, hover.range));
- else if (diags.length) ({ from, to } = diags[0]!);
- else {
- const word = view.state.wordAt(pos);
- if (word) ({ from, to } = word);
- }
- const lang = docOf(view)?.uiMode ?? null;
- return {
- pos: from,
- end: to,
- above: true,
- create: () => {
- const dom = document.createElement("div");
- dom.className = `cm-lsp-hover ${selectableText}`;
- if (diags.length) dom.appendChild(renderDiagnostics(view, diags));
- if (hover) dom.appendChild(renderMarkup(hover.contents, lang));
- return { dom };
- },
- };
+/**
+ * Whether the plain hover (problems + quick documentation) stays out: while
+ * ⌘/Ctrl is held the ⌘-hover link and its brief info (`navigation.ts`) own the
+ * pointer, as in IDEA; and over an inlay hint, which has its own tooltip.
+ */
+export function hoverYields(): boolean {
+ return navigationModifierHeld() || !!pointerTarget()?.closest?.(".cm-lsp-inlay");
+}
+
+/** Problems always; quick documentation per Settings › Editor › Code Editing. */
+export async function hoverSource(view: EditorView, pos: number) {
+ if (hoverYields()) return null;
+ const diags = diagnosticsAt(view, pos);
+ let hover: Hover | null = null;
+ if (editorPrefs().codeEditing.quickDocOnHover)
+ try {
+ hover = await requestHover(view, pos);
+ } catch (e) {
+ reportLspError(view, e, false);
+ }
+ // ⌘/Ctrl pressed while the server answered.
+ if (hoverYields()) return null;
+ if (!diags.length && !hover) return null;
+ let from = pos,
+ to = pos;
+ if (hover?.range) ({ from, to } = rangeToOffsets(view.state.doc, hover.range));
+ else if (diags.length) ({ from, to } = diags[0]!);
+ else {
+ const word = view.state.wordAt(pos);
+ if (word) ({ from, to } = word);
+ }
+ const lang = docOf(view)?.uiMode ?? null;
+ return {
+ pos: from,
+ end: to,
+ above: true,
+ create: () => {
+ const dom = document.createElement("div");
+ dom.className = `cm-lsp-hover ${selectableText}`;
+ if (diags.length) dom.appendChild(renderDiagnostics(view, diags));
+ if (hover) dom.appendChild(renderMarkup(hover.contents, lang));
+ return { dom };
},
- { hoverTime: Math.max(100, editorPrefs().codeEditing.quickDocDelay) },
- );
+ };
+}
+
+/**
+ * Pressing ⌘/Ctrl closes the open hover popups (documentation, problems,
+ * debugger values) so the ⌘-hover info replaces them instead of stacking;
+ * a popup the pointer is in stays (selecting text in it and copying).
+ */
+const hoverYieldsToNavigation = ViewPlugin.fromClass(
+ class {
+ private off: () => void;
+ constructor(view: EditorView) {
+ this.off = onNavigationModifier((held) => {
+ if (!held || !hasHoverTooltips(view.state)) return;
+ if (pointerTarget()?.closest?.(".cm-tooltip")) return;
+ view.dispatch({ effects: closeHoverTooltips });
+ });
+ }
+ destroy() {
+ this.off();
+ }
+ },
+);
+
+export function hoverExtension(): Extension {
+ return [
+ hoverTooltip(hoverSource, { hoverTime: Math.max(100, editorPrefs().codeEditing.quickDocDelay) }),
+ hoverYieldsToNavigation,
+ ];
}
/** The documentation popup has the keyboard (F1 pressed twice, or clicked into). */
diff --git a/src/editor/lsp/hoverPrecedence.test.ts b/src/editor/lsp/hoverPrecedence.test.ts
new file mode 100644
index 000000000..1c42150b8
--- /dev/null
+++ b/src/editor/lsp/hoverPrecedence.test.ts
@@ -0,0 +1,127 @@
+/** Issue #57: ⌘/Ctrl-hover info and the plain hover popups never stack. */
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { EditorState } from "@codemirror/state";
+import { EditorView, activateHover, hasHoverTooltips } from "@codemirror/view";
+import { CONTRIBUTED_HOVER, type ContributedHover } from "@/editor/api";
+import { usePlatform } from "@/platform/platformInfo";
+import {
+ isNavigationGesture,
+ navigationModifierHeld,
+ pointerTarget,
+ resetNavigationModifier,
+} from "@/platform/navigationModifier";
+import { hoverExtension, hoverSource } from "./hover";
+
+const docHover: ContributedHover = (state, pos) => {
+ const w = state.wordAt(pos);
+ return w ? { from: w.from, to: w.to, markdown: "package query" } : null;
+};
+
+function editor() {
+ const state = EditorState.create({
+ doc: "query.FlightPlan",
+ extensions: [hoverExtension(), EditorState.languageData.of(() => [{ [CONTRIBUTED_HOVER]: docHover }])],
+ });
+ const parent = document.body.appendChild(document.createElement("div"));
+ return new EditorView({ state, parent });
+}
+
+const key = (type: "keydown" | "keyup", k: string, init: KeyboardEventInit = {}) =>
+ window.dispatchEvent(new KeyboardEvent(type, { key: k, bubbles: true, ...init }));
+const settle = () => new Promise((r) => setTimeout(r, 0));
+
+describe.each([
+ { os: "windows", mod: "Control", flag: "ctrlKey", other: "metaKey" },
+ { os: "macos", mod: "Meta", flag: "metaKey", other: "ctrlKey" },
+] as const)("navigation modifier on $os", ({ os, mod, flag, other }) => {
+ let view: EditorView | null = null;
+ beforeEach(() => {
+ usePlatform.setState({ os });
+ resetNavigationModifier();
+ });
+ afterEach(() => {
+ view?.destroy();
+ view = null;
+ document.body.replaceChildren();
+ resetNavigationModifier();
+ });
+
+ it("tracks the platform's modifier alone, pressed and released", () => {
+ expect(navigationModifierHeld()).toBe(false);
+ key("keydown", mod, { [flag]: true });
+ expect(navigationModifierHeld()).toBe(true);
+ key("keyup", mod);
+ expect(navigationModifierHeld()).toBe(false);
+ // With ⇧/⌥ it is another gesture; the other platform's Ctrl/⌘ is not it.
+ key("keydown", "Shift", { [flag]: true, shiftKey: true });
+ expect(navigationModifierHeld()).toBe(false);
+ key("keydown", mod === "Meta" ? "Control" : "Meta", { [other]: true });
+ expect(navigationModifierHeld()).toBe(false);
+ const both = new MouseEvent("mousemove", { [flag]: true, [other]: true });
+ expect(isNavigationGesture(both)).toBe(false);
+ expect(isNavigationGesture(new MouseEvent("mousemove", { [flag]: true }))).toBe(true);
+ });
+
+ it("learns the state from mouse moves and forgets it when the window loses focus", () => {
+ expect(navigationModifierHeld()).toBe(false);
+ window.dispatchEvent(new MouseEvent("mousemove", { [flag]: true }));
+ expect(navigationModifierHeld()).toBe(true);
+ window.dispatchEvent(new Event("blur"));
+ expect(navigationModifierHeld()).toBe(false);
+ });
+
+ it("modifier held before hovering: no documentation popup", async () => {
+ view = editor();
+ expect(await hoverSource(view, 2)).not.toBeNull();
+ key("keydown", mod, { [flag]: true });
+ expect(await hoverSource(view, 2)).toBeNull();
+ });
+
+ it("modifier pressed while the documentation popup is open: it closes", async () => {
+ view = editor();
+ activateHover(view, 2, 1);
+ await settle();
+ expect(hasHoverTooltips(view.state)).toBe(true);
+ key("keydown", mod, { [flag]: true });
+ expect(hasHoverTooltips(view.state)).toBe(false);
+ });
+
+ it("modifier pressed while the request is in flight: the late answer is dropped", async () => {
+ view = editor();
+ const pending = hoverSource(view, 2);
+ key("keydown", mod, { [flag]: true });
+ expect(await pending).toBeNull();
+ });
+
+ it("modifier released: nothing stale is left and the next hover shows documentation again", async () => {
+ view = editor();
+ key("keydown", mod, { [flag]: true });
+ activateHover(view, 2, 1);
+ await settle();
+ expect(hasHoverTooltips(view.state)).toBe(false);
+ key("keyup", mod);
+ expect(hasHoverTooltips(view.state)).toBe(false);
+ activateHover(view, 2, 1);
+ await settle();
+ expect(hasHoverTooltips(view.state)).toBe(true);
+ });
+
+ it("keeps a popup the pointer is in (select + copy with the modifier)", async () => {
+ view = editor();
+ activateHover(view, 2, 1);
+ await settle();
+ const tooltip = view.dom.querySelector(".cm-tooltip")!;
+ tooltip.dispatchEvent(new MouseEvent("mousemove", { bubbles: true }));
+ expect(pointerTarget()).toBe(tooltip);
+ key("keydown", mod, { [flag]: true });
+ expect(hasHoverTooltips(view.state)).toBe(true);
+ });
+
+ it("no documentation popup over an inlay hint (it has its own tooltip)", async () => {
+ view = editor();
+ const inlay = view.contentDOM.appendChild(document.createElement("span"));
+ inlay.className = "cm-lsp-inlay";
+ inlay.dispatchEvent(new MouseEvent("mousemove", { bubbles: true }));
+ expect(await hoverSource(view, 2)).toBeNull();
+ });
+});
diff --git a/src/editor/lsp/inlay.test.ts b/src/editor/lsp/inlay.test.ts
index 1b0deb774..510943758 100644
--- a/src/editor/lsp/inlay.test.ts
+++ b/src/editor/lsp/inlay.test.ts
@@ -10,6 +10,7 @@ vi.mock("@/workbench/contributions", async (orig) => {
});
const { inlayDecorations, inlayMenuItems } = await import("./inlay");
+const { usePlatform } = await import("@/platform/platformInfo");
const { useContextMenuStore } = await import("@/ui");
const hint: InlayHint = {
@@ -51,7 +52,11 @@ describe("inlay hints", () => {
expect(view.dom.querySelector(".cm-lsp-inlay")!.textContent).toBe(": Foo");
part.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true, button: 0 }));
expect(openFile).not.toHaveBeenCalled();
- part.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true, button: 0, metaKey: true, ctrlKey: true }));
+ usePlatform.setState({ os: "windows" });
+ // ⌘ is not the navigation modifier off macOS.
+ part.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true, button: 0, metaKey: true }));
+ expect(openFile).not.toHaveBeenCalled();
+ part.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true, button: 0, ctrlKey: true }));
expect(openFile).toHaveBeenCalledWith("/p/foo.rs", { selection: { line: 4, col: 7 }, focus: true });
});
diff --git a/src/editor/lsp/inlay.ts b/src/editor/lsp/inlay.ts
index f97ee238d..9896aed3e 100644
--- a/src/editor/lsp/inlay.ts
+++ b/src/editor/lsp/inlay.ts
@@ -8,7 +8,7 @@ import { StateEffect, StateField, type Extension } from "@codemirror/state";
import { Decoration, EditorView, ViewPlugin, WidgetType, type DecorationSet, type ViewUpdate } from "@codemirror/view";
import { call, commands, isTauri, type InlayHint } from "@/platform/ipc";
import { executeAction } from "@/platform/actions";
-import { hasPrimaryModifier } from "@/platform/keymap";
+import { isNavigationGesture } from "@/platform/navigationModifier";
import { maybeEditorService } from "@/workbench/contributions";
import { showContextMenu, type MenuItem } from "@/ui";
import { useProject } from "@/platform/project";
@@ -69,7 +69,7 @@ class InlayWidget extends WidgetType {
const loc = part.location;
// ⌘-click (Ctrl elsewhere) navigates to the declaration the part names, as in IDEA.
span.addEventListener("mousedown", (e) => {
- if (e.button !== 0 || !hasPrimaryModifier(e)) return;
+ if (e.button !== 0 || !isNavigationGesture(e)) return;
e.preventDefault();
e.stopPropagation();
void maybeEditorService()?.openFile(loc.path, {
diff --git a/src/editor/lsp/navigation.ts b/src/editor/lsp/navigation.ts
index 8d1705a28..55ff239ab 100644
--- a/src/editor/lsp/navigation.ts
+++ b/src/editor/lsp/navigation.ts
@@ -49,7 +49,8 @@ import { requestHover } from "./hover";
import { declarationSummary, renderCode } from "./markdown";
import { editorPrefs } from "@/platform/editorSettings";
import { isVirtualUri, virtualContainer } from "@/platform/virtualDocs";
-import { hasPrimaryModifier, isMacHost, shortcutLabel } from "@/platform/keymap";
+import { shortcutLabel } from "@/platform/keymap";
+import { isNavigationGesture, onNavigationModifier } from "@/platform/navigationModifier";
import { create } from "zustand";
export async function navigateTo(loc: Location) {
@@ -337,7 +338,16 @@ const linkPlugin = ViewPlugin.fromClass(
private probed = new Map<string, { info: NavInfo | null } | null>();
private probedDoc: Text | null = null;
private probing: string | null = null;
- constructor(readonly view: EditorView) {}
+ private off: () => void;
+ constructor(readonly view: EditorView) {
+ // Window-wide, so ⌘/Ctrl over an unfocused editor underlines too; released anywhere clears it.
+ this.off = onNavigationModifier((held) => {
+ if (!held || this.last) this.show(held);
+ });
+ }
+ destroy() {
+ this.off();
+ }
private set(value: LinkState | null) {
const current = this.view.state.field(linkField);
if (current === value || (current && value && current.from === value.from && current.to === value.to && current.info === value.info))
@@ -391,25 +401,17 @@ const linkPlugin = ViewPlugin.fromClass(
{
eventHandlers: {
mousemove(e) {
- this.last = { x: e.clientX, y: e.clientY };
- this.show(hasPrimaryModifier(e) && !e.altKey && !e.shiftKey);
+ // Not through a popup or an inlay hint (which navigates on its own ⌘-click) to the text under it.
+ const over = e.target instanceof Element ? e.target : null;
+ this.last = over?.closest(".cm-tooltip, .cm-lsp-inlay") ? null : { x: e.clientX, y: e.clientY };
+ this.show(isNavigationGesture(e));
},
mouseleave() {
this.last = null;
this.show(false);
},
- keydown(e) {
- if (e.key === (isMacHost() ? "Meta" : "Control")) this.show(true);
- },
- keyup(e) {
- if (e.key === (isMacHost() ? "Meta" : "Control")) this.show(false);
- },
- blur() {
- this.show(false);
- },
mousedown(e, view) {
- if (e.button !== 0 || !hasPrimaryModifier(e) || e.altKey || e.shiftKey) return false;
- if (isMacHost() ? e.ctrlKey : e.metaKey) return false;
+ if (e.button !== 0 || !isNavigationGesture(e)) return false;
const pos = view.posAtCoords({ x: e.clientX, y: e.clientY }, false);
if (pos == null) return false;
e.preventDefault();
diff --git a/src/features/debugger/editor/valueTooltip.ts b/src/features/debugger/editor/valueTooltip.ts
index 6bca28473..6fafe8cdd 100644
--- a/src/features/debugger/editor/valueTooltip.ts
+++ b/src/features/debugger/editor/valueTooltip.ts
@@ -6,6 +6,7 @@
import type { Extension } from "@codemirror/state";
import { hoverTooltip, type EditorView } from "@codemirror/view";
import { workflowSettings } from "@/platform/workflowSettings";
+import { navigationModifierHeld } from "@/platform/navigationModifier";
import { activeSession, evaluate } from "../state";
import { inlineValue } from "../values";
import { tx } from "@/platform/i18n";
@@ -40,7 +41,8 @@ export function valueTooltip(): Extension {
return hoverTooltip(
async (view, pos) => {
const dbg = workflowSettings().debugger;
- if (!dbg.valueTooltip) return null;
+ // ⌘/Ctrl-hover shows the navigation info instead (closed on press by the LSP hover).
+ if (!dbg.valueTooltip || navigationModifierHeld()) return null;
const session = activeSession();
if (!session || session.status !== "paused") return null;
const expr = expressionAt(view, pos);
@@ -53,6 +55,7 @@ export function valueTooltip(): Extension {
} catch {
return null;
}
+ if (navigationModifierHeld()) return null;
return {
pos: expr.from,
end: expr.to,
diff --git a/src/platform/navigationModifier.ts b/src/platform/navigationModifier.ts
new file mode 100644
index 000000000..b592e9e29
--- /dev/null
+++ b/src/platform/navigationModifier.ts
@@ -0,0 +1,77 @@
+/**
+ * The navigation modifier (⌘ on macOS, Ctrl elsewhere) as a live, window-wide
+ * state: ⌘/Ctrl-hover shows the navigation link and its brief info, and every
+ * plain hover popup (quick documentation, problems, debugger values) yields to
+ * it. Tracked on the window so an editor sees the key even when it isn't focused.
+ */
+import { hasPrimaryModifier, isMacHost } from "./keymap";
+
+type ModifierEvent = Pick<MouseEvent, "metaKey" | "ctrlKey" | "altKey" | "shiftKey">;
+
+/** ⌘/Ctrl alone: no ⌥/⇧ (other gestures) and not the other platform's Ctrl/⌘. */
+export function isNavigationGesture(e: ModifierEvent): boolean {
+ return hasPrimaryModifier(e) && !e.altKey && !e.shiftKey && !(isMacHost() ? e.ctrlKey : e.metaKey);
+}
+
+let held = false;
+let pointer: Element | null = null;
+const listeners = new Set<(held: boolean) => void>();
+let installed: (() => void) | null = null;
+
+function setHeld(value: boolean) {
+ if (held === value) return;
+ held = value;
+ for (const fn of [...listeners]) fn(value);
+}
+
+function install() {
+ if (installed || typeof window === "undefined") return;
+ const onKey = (e: KeyboardEvent) => setHeld(isNavigationGesture(e));
+ // Also from pointer events: a key released outside the window never reports its keyup.
+ const onMouse = (e: MouseEvent) => {
+ pointer = e.target instanceof Element ? e.target : null;
+ setHeld(isNavigationGesture(e));
+ };
+ const onBlur = () => setHeld(false);
+ const opts = { capture: true, passive: true } as const;
+ window.addEventListener("keydown", onKey, opts);
+ window.addEventListener("keyup", onKey, opts);
+ window.addEventListener("mousemove", onMouse, opts);
+ window.addEventListener("mousedown", onMouse, opts);
+ window.addEventListener("blur", onBlur);
+ installed = () => {
+ window.removeEventListener("keydown", onKey, opts);
+ window.removeEventListener("keyup", onKey, opts);
+ window.removeEventListener("mousemove", onMouse, opts);
+ window.removeEventListener("mousedown", onMouse, opts);
+ window.removeEventListener("blur", onBlur);
+ installed = null;
+ };
+}
+
+/** Whether ⌘ (macOS) / Ctrl is held on its own right now. */
+export function navigationModifierHeld(): boolean {
+ install();
+ return held;
+}
+
+/** Element under the pointer at the last mouse move (null before any). */
+export function pointerTarget(): Element | null {
+ install();
+ return pointer;
+}
+
+/** Called with the new state whenever the navigation modifier is pressed or released. */
+export function onNavigationModifier(fn: (held: boolean) => void): () => void {
+ install();
+ listeners.add(fn);
+ return () => listeners.delete(fn);
+}
+
+/** Tests: forget the tracked state and listeners. */
+export function resetNavigationModifier() {
+ installed?.();
+ held = false;
+ pointer = null;
+ listeners.clear();
+}