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.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(editor): Copy Reference copies path:line unless the caret is on a declaration's name (#1507)
Jaw50986088f9be
diff --git a/src/editor/core/actions.ts b/src/editor/core/actions.tsindex d9c063773..ca1bd6ccc 100644--- a/src/editor/core/actions.ts+++ b/src/editor/core/actions.ts@@ -63,7 +63,7 @@ import { cloneCaretAbove, cloneCaretBelow } from "./cm/verticalMotion";import { pasteAsPlainText, pasteFromHistory, unwrapAtCaret } from "./extras";import { cyclicExpandWord } from "./wordCompletion";import { qualifiedReference } from "./copyReference";-import { symbolChain } from "./view/outline";+import { declarationChain } from "./view/outline";import { recordClipboard } from "./clipboardHistory";import { useDocMeta, useOutline } from "./model/document";import { fontZoom, setFontZoom, stepFontZoom } from "./cm/prefs";@@ -414,12 +414,14 @@ function copyReference(view: EditorView, slot: EditorSlot) {const line = state.doc.lineAt(head);const meta = slot.model.getMeta();const outline = useOutline.getState()[slot.model.path] ?? [];+ // A package is not a member to qualify: jdtls lists the whole `package …;` statement as one.+ const chain = declarationChain(outline, line.number - 1, head - line.from).filter((i) => i.kind !== "package");const reference = qualifiedReference({language: meta.language,path: slot.model.path,root: useProject.getState().project?.root ?? null,text: state.doc.toString(),- chain: symbolChain(outline, line.number - 1, head - line.from).map((i) => i.name),+ chain: chain.map((i) => i.name),line: line.number - 1,});recordClipboard(reference);diff --git a/src/editor/core/copyReference.ts b/src/editor/core/copyReference.tsindex 9684fd25b..953a73f94 100644--- a/src/editor/core/copyReference.ts+++ b/src/editor/core/copyReference.ts@@ -1,7 +1,7 @@/**- * Edit › Copy Reference (⌥⇧⌘C): the fully qualified name of the symbol at- * the caret, built from the file's outline (symbols enclosing the caret) and- * the language's module conventions; `path:line` where there is no symbol.+ * Edit › Copy Reference (⌥⇧⌘C): with the caret on a declaration's name, its+ * fully qualified name, built from the file's outline and the language's module+ * conventions; anywhere else `path:line`, as in IDEA.*/export interface ReferenceInput {@@ -11,7 +11,7 @@ export interface ReferenceInput {/** Project root, for project-relative paths and module names. */root: string | null;text: string;- /** Names of the outline symbols enclosing the caret, outermost first. */+ /** Names of the outline symbols down to the one named at the caret, outermost first; empty off a name. */chain: string[];/** 0-based caret line. */line: number;@@ -59,42 +59,37 @@ const declared = (text: string, re: RegExp) => re.exec(text)?.[1] ?? null;export function qualifiedReference(r: ReferenceInput): string {const fallback = `${relativePath(r.path, r.root)}:${r.line + 1}`;const chain = r.chain.filter(Boolean);+ if (!chain.length) return fallback;switch (r.language) {case "java":case "groovy": {- if (!chain.length) return fallback;const pkg = declared(r.text, /^\s*package\s+([\w.]+)\s*;?/m);const [type, ...rest] = chain;const typePath = [pkg, type].filter(Boolean).join(".");- // `pkg.Outer.Inner#member`: the last symbol is the member unless the caret is in a type only.+ // `pkg.Outer.Inner#member`: the last symbol is the member unless the caret is on a type's name.return rest.length ? `${[typePath, ...rest.slice(0, -1)].join(".")}#${rest[rest.length - 1]}` : typePath;}case "kotlin":case "scala": {- if (!chain.length) return fallback;const pkg = declared(r.text, /^\s*package\s+([\w.]+)/m);return [pkg, ...chain].filter(Boolean).join(".");}- case "csharp": {- if (!chain.length) return fallback;+ case "csharp":return chain.join(".");- }- case "rust": {- if (!chain.length) return rustModulePath(r.path);+ case "rust":return [rustModulePath(r.path), ...chain.map((n) => (n.startsWith("impl") ? rustImplType(n) : n))].join("::");- }case "python":return [pythonModulePath(r.path, r.root), ...chain].join(".");case "go": {const pkg = declared(r.text, /^\s*package\s+(\w+)/m) ?? stem(r.path);- return chain.length ? [pkg, ...chain].join(".") : fallback;+ return [pkg, ...chain].join(".");}case "cpp":case "c":case "objective-cpp":case "php":- return chain.length ? chain.join("::") : fallback;+ return chain.join("::");default:- return chain.length ? `${relativePath(r.path, r.root)}:${chain.join(".")}` : fallback;+ return `${relativePath(r.path, r.root)}:${chain.join(".")}`;}}diff --git a/src/editor/core/editingExtras.test.ts b/src/editor/core/editingExtras.test.tsindex 8c9676f8c..d1ead564c 100644--- a/src/editor/core/editingExtras.test.ts+++ b/src/editor/core/editingExtras.test.ts@@ -2,7 +2,9 @@ import { describe, expect, it } from "vitest";import { EditorState } from "@codemirror/state";import { EditorView } from "@codemirror/view";import { cyclicExpandWord, expandCandidates, prefixStart } from "./wordCompletion";+import type { OutlineItem } from "@/platform/ipc";import { pythonModulePath, qualifiedReference, rustImplType, rustModulePath } from "./copyReference";+import { declarationChain } from "./view/outline";describe("cyclic expand word", () => {const text = "alphaOne x alphaTwo y al| alphaThree alphaOne";@@ -101,5 +103,33 @@ describe("copy reference", () => {expect(qualifiedReference({ ...base, root: null, language: "markdown", path: "/x/a.md", text: "", chain: [] }),).toBe("/x/a.md:5");+ expect(qualifiedReference({ ...base, language: "python", path: "/p/pkg/mod.py", text: "", chain: [] })).toBe(+ "pkg/mod.py:5",+ );+ expect(qualifiedReference({ ...base, language: "rust", path: "/p/src/a.rs", text: "", chain: [] })).toBe(+ "src/a.rs:5",+ );+ });++ it("names a symbol only with the caret on its name, like IDEA", () => {+ const item = (name: string, range: number[], sel: number[], children: OutlineItem[] = []): OutlineItem => ({+ name,+ detail: null,+ kind: "class",+ range: { start: { line: range[0]!, col: range[1]! }, end: { line: range[2]!, col: range[3]! } },+ selection_range: { start: { line: sel[0]!, col: sel[1]! }, end: { line: sel[2]!, col: sel[3]! } },+ children,+ });+ // class Book { line 0, name at cols 6-10+ // void sum() { line 1, name at cols 7-10+ // total += 1; line 2+ const outline = [item("Book", [0, 0, 4, 1], [0, 6, 0, 10], [item("sum", [1, 2, 3, 3], [1, 7, 1, 10])])];+ const names = (line: number, col: number) => declarationChain(outline, line, col).map((i) => i.name);+ expect(names(1, 8)).toEqual(["Book", "sum"]);+ expect(names(1, 10)).toEqual(["Book", "sum"]);+ expect(names(0, 6)).toEqual(["Book"]);+ expect(names(2, 6)).toEqual([]);+ expect(names(1, 2)).toEqual([]);+ expect(names(5, 0)).toEqual([]);});});diff --git a/src/editor/core/view/outline.ts b/src/editor/core/view/outline.tsindex 79451cfe8..ebcc9876d 100644--- a/src/editor/core/view/outline.ts+++ b/src/editor/core/view/outline.ts@@ -14,3 +14,11 @@ export function symbolChain(items: readonly OutlineItem[], line: number, col: nulevel = hit.children;}}++/** The chain up to the innermost item whose name (selection range) holds (line, col); empty off every name. */+export function declarationChain(items: readonly OutlineItem[], line: number, col: number): OutlineItem[] {+ const pos = { line, col };+ const chain = symbolChain(items, line, col);+ const named = chain.findLastIndex((i) => before(i.selection_range.start, pos) && before(pos, i.selection_range.end));+ return chain.slice(0, named + 1);+}