Порівняти коміти

...
Автор SHA1 Повідомлення Дата
l0ng-ai 41babd5b92 feat(editor): show the interfaces a Go type or method implements in the gutter
Go types satisfy interfaces implicitly, so the gutter showed only the interface side (is implemented by). Named types and receiver methods now get an implements marker listing the interfaces (interface methods) gopls reports for them; clicking it goes to the interface or opens the chooser.

Go named types other than structs (type Celsius float64) were outlined as classes and showed the interfaces they satisfy as subclasses; they now get the implements marker instead. Target names for Go methods come from their receiver, and Go interface declarations are recognized as enclosing types.
2026-11-13 21:10:14 +08:00
5 змінених файлів з 146 додано та 9 видалено

No files matched your search

+24 -5
Переглянути файл
@@ -39,6 +39,7 @@ import { gutterIconMarkup } from "@/ui";
import {
MARKER_ICONS,
candidateKey,
implementsMarker,
inheritorsMarker,
markerCandidates,
supersMarker,
@@ -167,10 +168,13 @@ export async function fillMarkers(
groups.has("inheritors") && !cache.unsupported.has("inheritors")
? candidates.filter((c) => c.inheritable && cache.entries.get(candidateKey(c))?.inheritors === undefined)
: [];
const up =
groups.has("supers") && !cache.unsupported.has("supers")
? candidates.filter((c) => c.overriding && c.owner && cache.entries.get(candidateKey(c))?.supers === undefined)
: [];
const askSupers = groups.has("supers") && !cache.unsupported.has("supers");
const up = askSupers
? candidates.filter((c) => c.overriding && c.owner && cache.entries.get(candidateKey(c))?.supers === undefined)
: [];
const implicit = askSupers
? candidates.filter((c) => c.implicit && cache.entries.get(candidateKey(c))?.supers === undefined)
: [];
let implementations: Location[][] = [];
const known = down.length ? await fromHierarchy(path, down, deps.supers) : new Map<MarkerCandidate, Location[]>();
@@ -206,13 +210,26 @@ export async function fillMarkers(
}
const supers: SuperMethod[][] = [];
for (const c of up) supers.push(await superMethodTargets(path, c.owner!, c.symbol, deps.supers));
// Go: an implementation request on a type or method answers the interfaces it satisfies.
let satisfied: Location[][] = [];
if (implicit.length) {
try {
satisfied = await deps.implementations(implicit.map((c) => ({ line: c.line, col: c.col })));
} catch (e) {
if (isCancelled(e)) throw e;
if (isUnavailable(e)) cache.unsupported.add("supers");
implicit.length = 0;
}
}
const files = await deps.readFiles([
...implementations.flat().map((l) => l.path),
...supers.flat().map((s) => s.location.path),
...satisfied.flat().map((l) => l.path),
]);
down.forEach((c, i) => (entry(c).inheritors = inheritorsMarker(c, implementations[i] ?? [], files)));
up.forEach((c, i) => (entry(c).supers = supersMarker(c, supers[i]!, files)));
implicit.forEach((c, i) => (entry(c).supers = implementsMarker(c, withoutSelf(path, c, satisfied[i] ?? []), files)));
}
/**
@@ -481,7 +498,9 @@ class MarkersPlugin {
if (stale()) return;
entry.outline = {
items,
candidates: markerCandidates(items, (l) => (l < text.lines ? text.line(l + 1).text : "")),
candidates: markerCandidates(items, (l) => (l < text.lines ? text.line(l + 1).text : ""), {
implicitInterfaces: ctx.language === "go",
}),
};
}
const { candidates, items } = entry.outline;
+63
Переглянути файл
@@ -125,7 +125,34 @@ const BASE_OUTLINE = [
item("Base", "class", 0, 3, [item("run()", "method", 1, 1, [], 25), item("label()", "method", 2, 2, [], 18)], 22),
];
// main.go, as gopls outlines it: methods sit outside their type.
const GO = [
"package main",
"",
"type Shape interface {",
"\tArea() float64",
"}",
"",
"type Square struct{ side float64 }",
"",
"func (s *Square) Area() float64 { return s.side * s.side }",
"",
"type Celsius float64",
"",
"func main() {}",
];
const GO_PATH = "/p/main.go";
const GO_OUTLINE = [
item("Shape", "interface", 2, 4, [item("Area", "method", 3, 3, [], 1)], 5),
item("Square", "struct", 6, 6, [], 5),
item("(*Square).Area", "method", 8, 8, [], 17),
item("Celsius", "class", 10, 10, [], 5),
item("main", "function", 12, 12, [], 5),
];
const FILES: Record<string, string[]> = {
[GO_PATH]: GO,
"/go/src/fmt/print.go": ["package fmt", "type Stringer interface {", "\tString() string", "}"],
[SHAPE_PATH]: SHAPE,
"/p/Circle.java": CIRCLE,
"/p/Square.java": ["public class Square implements Shape {", " public double area() { return 2; }", "}"],
@@ -158,6 +185,17 @@ describe("marker candidates", () => {
]);
});
it("Go: types and receiver methods satisfy interfaces; only interfaces have implementations", () => {
const found = markerCandidates(GO_OUTLINE, lines(GO), { implicitInterfaces: true });
expect(found.map((c) => [c.name, c.method, c.inheritable, !!c.implicit])).toEqual([
["Shape", false, true, false],
["Area", true, true, false],
["Square", false, false, true],
["Area", true, false, true],
["Celsius", false, false, true],
]);
});
it("skips structs, enums and free functions for implementation requests", () => {
const outline = [item("Point", "struct", 0, 3, [item("len", "method", 1, 1)]), item("main", "function", 5, 6)];
const found = markerCandidates(outline, () => "");
@@ -228,6 +266,31 @@ describe("markers from server answers", () => {
expect(markers[0]!.chooserTitle).toBe("Choose Implementation of Shape (2 found)");
});
it("Go: marks the interfaces a type satisfies and the interface methods a method implements", async () => {
const { deps } = server(
{
[`${GO_PATH}:2`]: [loc(GO_PATH, 6, 5)],
[`${GO_PATH}:3`]: [loc(GO_PATH, 8, 17)],
[`${GO_PATH}:6`]: [loc(GO_PATH, 2, 5)],
[`${GO_PATH}:8`]: [loc(GO_PATH, 3, 1)],
[`${GO_PATH}:10`]: [loc("/go/src/fmt/print.go", 1, 5)],
},
{},
);
const candidates = markerCandidates(GO_OUTLINE, lines(GO), { implicitInterfaces: true });
const cache = emptyCache();
await fillMarkers(GO_PATH, candidates, ALL, deps(GO_PATH), cache);
const markers = cachedMarkers(candidates, ALL, cache);
expect(markers.map((m) => [m.line, m.kind, m.tooltip])).toEqual([
[2, "implemented", "Is implemented by Square"],
[3, "implemented", "Is implemented in Square"],
[6, "implementing", "Implements Shape"],
[8, "implementing", "Implements method in Shape"],
[10, "implementing", "Implements Stringer"],
]);
expect(markers[2]!.chooserTitle).toBe("Choose Implemented Interface of Square (1 found)");
});
it("marks subclassed classes and overridden methods", async () => {
const { deps } = server(
{
+53 -2
Переглянути файл
@@ -38,6 +38,11 @@ export interface MarkerCandidate {
overriding: boolean;
/** Identifier position of the enclosing type (methods). */
owner: { line: number; col: number } | null;
/**
* Satisfies interfaces implicitly (Go): an implementation request on it answers the interfaces
* a type satisfies, or the interface methods a method implements.
*/
implicit?: boolean;
}
export interface LineMarker {
@@ -54,6 +59,8 @@ export interface LineMarker {
/** Types whose subtypes / implementations are worth a marker (not structs, enums: they cannot be extended). */
const INHERITABLE_TYPES = new Set<SymbolKind>(["class", "interface", "trait"]);
const ABSTRACT_TYPES = new Set<SymbolKind>(["interface", "trait"]);
/** Go declarations that can satisfy an interface: named types other than interfaces, and methods. */
const IMPLICIT_KINDS = new Set<SymbolKind>(["struct", "class", "method"]);
/** Types whose methods may implement or override a supertype's. */
const MEMBER_OWNERS = new Set<SymbolKind>(["class", "interface", "trait", "enum", "struct"]);
@@ -88,12 +95,30 @@ function declarationPrefix(item: OutlineItem, lineText: (line: number) => string
export function markerCandidates(
outline: readonly OutlineItem[],
lineText: (line: number) => string,
options: { implicitInterfaces?: boolean } = {},
): MarkerCandidate[] {
const out: MarkerCandidate[] = [];
const walk = (items: readonly OutlineItem[], parent: OutlineItem | null) => {
for (const it of items) {
const prefix = () => declarationPrefix(it, lineText);
const at = it.selection_range.start;
// Go: named types and their methods (`(*Square).Area`, outside the type) only satisfy
// interfaces; nothing extends them.
if (options.implicitInterfaces && !parent && IMPLICIT_KINDS.has(it.kind)) {
out.push({
symbol: it.name,
name: it.name.replace(/^\([^)]*\)\./, ""),
line: at.line,
col: at.col,
method: it.kind === "method",
abstract: false,
inheritable: false,
overriding: false,
owner: null,
implicit: true,
});
continue;
}
if (INHERITABLE_TYPES.has(it.kind)) {
const p = prefix();
out.push({
@@ -136,7 +161,10 @@ export function withoutSelf(path: string, c: MarkerCandidate, targets: readonly
return targets.filter((t) => !(t.path === path && t.range.start.line === c.line));
}
const TYPE_DECLARATION = /\b(?:class|interface|trait|object|struct|enum|record|impl)\s+([\p{L}_$][\p{L}\p{N}_$]*)/u;
const TYPE_DECLARATION =
/\b(?:class|interface|trait|object|struct|enum|record|impl)\s+([\p{L}_$][\p{L}\p{N}_$]*)|^\s*type\s+([\p{L}_][\p{L}\p{N}_]*)(?:\[[^\]]*\])?\s+(?:interface|struct)\b/u;
/** A Go method's receiver type: `func (s *Square) Area()`. */
const GO_RECEIVER = /^\s*func\s*\(\s*(?:[\p{L}_][\p{L}\p{N}_]*\s+)?\*?\s*([\p{L}_][\p{L}\p{N}_]*)/u;
const FENCES = [`"""`, `'''`];
@@ -166,13 +194,15 @@ export function enclosingType(lines: readonly string[] | null | undefined, targe
// A single-line docstring (fences open and close on the line) is text too.
if (FENCES.some((f) => code.includes(f))) continue;
const m = TYPE_DECLARATION.exec(code);
if (m && !/^\s*(\*|\/\*)/.test(line)) container = m[1]!;
if (m && !/^\s*(\*|\/\*)/.test(line)) container = (m[1] ?? m[2])!;
}
return container;
}
/** Name of the type a target sits in: the nearest type declaration above it, else the file name. */
export function enclosingTypeName(lines: readonly string[] | null | undefined, target: Location): string {
const receiver = GO_RECEIVER.exec(lines?.[target.range.start.line] ?? "")?.[1];
if (receiver) return receiver;
const found = enclosingType(lines, target);
if (found) return found;
const file = target.path.split(/[\\/]/).pop() ?? target.path;
@@ -222,6 +252,27 @@ export function inheritorsMarker(
return { kind, line: c.line, name: c.name, targets: [...targets], tooltip, chooserTitle };
}
/** ↑ marker of a Go type or method from the interfaces (methods) it satisfies; null without any. */
export function implementsMarker(
c: MarkerCandidate,
targets: readonly Location[],
files: ReadonlyMap<string, string[] | null>,
): LineMarker | null {
if (!targets.length) return null;
const names = nameList(targets.map((t) => targetName(files.get(t.path), t, c.method)));
const n = targets.length;
return {
kind: "implementing",
line: c.line,
name: c.name,
targets: [...targets],
tooltip: c.method ? tx`Implements method in ${names}` : tx`Implements ${names}`,
chooserTitle: c.method
? tx`Choose Super Method of ${c.name} (${n} found)`
: tx`Choose Implemented Interface of ${c.name} (${n} found)`,
};
}
/** Whether a super method is abstract: declared in an interface / trait, or marked `abstract`. */
export function isAbstractSuper(s: SuperMethod, files: ReadonlyMap<string, string[] | null>): boolean {
const lines = files.get(s.location.path);
+3 -1
Переглянути файл
@@ -1517,5 +1517,7 @@
"Created Git repository in {dir}": "Created Git repository in {dir}",
"Check the JVM Debugger": "Check the JVM Debugger",
"Whether the debugger for a build tool's JVMs is installed, offering the install when not (arg: { module, retry, done(ready) })": "Whether the debugger for a build tool's JVMs is installed, offering the install when not (arg: { module, retry, done(ready) })",
"This module has Kotlin sources, so debugging it needs the Kotlin debugger (kotlin-debug-adapter).": "This module has Kotlin sources, so debugging it needs the Kotlin debugger (kotlin-debug-adapter)."
"This module has Kotlin sources, so debugging it needs the Kotlin debugger (kotlin-debug-adapter).": "This module has Kotlin sources, so debugging it needs the Kotlin debugger (kotlin-debug-adapter).",
"Implements {names}": "Implements {names}",
"Choose Implemented Interface of {name} ({count} found)": "Choose Implemented Interface of {name} ({count} found)"
}
+3 -1
Переглянути файл
@@ -7918,5 +7918,7 @@
"Created Git repository in {dir}": "已在 {dir} 创建 Git 仓库",
"Check the JVM Debugger": "检查 JVM 调试器",
"Whether the debugger for a build tool's JVMs is installed, offering the install when not (arg: { module, retry, done(ready) })": "检查构建工具启动的 JVM 所需的调试器是否已安装,未安装时提供安装(参数:{ module, retry, done(ready) })",
"This module has Kotlin sources, so debugging it needs the Kotlin debugger (kotlin-debug-adapter).": "此模块包含 Kotlin 源代码,调试它需要 Kotlin 调试器(kotlin-debug-adapter)。"
"This module has Kotlin sources, so debugging it needs the Kotlin debugger (kotlin-debug-adapter).": "此模块包含 Kotlin 源代码,调试它需要 Kotlin 调试器(kotlin-debug-adapter)。",
"Implements {names}": "实现 {names}",
"Choose Implemented Interface of {name} ({count} found)": "选择 {name} 实现的接口(找到 {count} 个)"
}