implements PLN-0137 (7/7) call-hierarchy

Call hierarchy walks CallExpr nodes for functions and methods. It does
not use the references index. A cursor that is not on a callable is
empty, and type hierarchy stays unadvertised.

Housekeep DSC-0066 with LSN-0074.
This commit is contained in:
2026-09-22 09:20:28 +01:00
parent e456bb8d7a
commit 1fcecdb04d
24 changed files with 995 additions and 333 deletions
@@ -0,0 +1,24 @@
package p.studio.lsp.messages;
import java.util.Objects;
public record BaselineCallHierarchyItem(
String name,
boolean method,
String uri,
int startLine,
int startCharacter,
int endLine,
int endCharacter) {
public BaselineCallHierarchyItem {
name = Objects.requireNonNull(name, "name").trim();
uri = Objects.requireNonNull(uri, "uri").trim();
if (name.isEmpty() || uri.isEmpty()) {
throw new IllegalArgumentException("call hierarchy item identity must not be blank");
}
if (startLine < 0 || startCharacter < 0 || endLine < 0 || endCharacter < 0) {
throw new IllegalArgumentException("call hierarchy range coordinates must not be negative");
}
}
}
@@ -0,0 +1,18 @@
package p.studio.lsp.messages;
import java.util.Objects;
public record BaselineCallSite(
BaselineCallHierarchyItem item,
int startLine,
int startCharacter,
int endLine,
int endCharacter) {
public BaselineCallSite {
item = Objects.requireNonNull(item, "item");
if (startLine < 0 || startCharacter < 0 || endLine < 0 || endCharacter < 0) {
throw new IllegalArgumentException("call site coordinates must not be negative");
}
}
}
@@ -20,6 +20,7 @@ public record BaselineServerDescription(
boolean foldingRangesSupported,
boolean selectionRangesSupported,
boolean formattingSupported,
boolean callHierarchySupported,
List<String> semanticTokenTypes,
List<BaselineSemanticHostProjection> semanticHostProjections,
List<BaselineVisualTheme> visualThemes,
@@ -11,6 +11,8 @@ import p.studio.lsp.messages.BaselineCodeActionDiagnostic;
import p.studio.lsp.messages.BaselineCodeActions;
import p.studio.lsp.messages.BaselineDocumentLinks;
import p.studio.lsp.messages.BaselineFoldingRanges;
import p.studio.lsp.messages.BaselineCallHierarchyItem;
import p.studio.lsp.messages.BaselineCallSite;
import p.studio.lsp.messages.BaselineFormatting;
import p.studio.lsp.messages.BaselineSelectionRanges;
import p.studio.lsp.messages.DocumentPosition;
@@ -77,6 +79,31 @@ public interface LanguageServiceBridge {
return BaselineFormatting.empty();
}
default java.util.List<BaselineCallHierarchyItem> prepareCallHierarchy(
LspProjectContext context,
String documentUri,
String text,
int line,
int character) {
return java.util.List.of();
}
default java.util.List<BaselineCallSite> incomingCalls(
LspProjectContext context,
String documentUri,
String text,
BaselineCallHierarchyItem target) {
return java.util.List.of();
}
default java.util.List<BaselineCallSite> outgoingCalls(
LspProjectContext context,
String documentUri,
String text,
BaselineCallHierarchyItem target) {
return java.util.List.of();
}
default BaselineSelectionRanges selectionRanges(
LspProjectContext context,
String documentUri,
@@ -5,6 +5,8 @@ import p.studio.compiler.FrontendRegistryService;
import p.studio.compiler.exceptions.BuildException;
import p.studio.compiler.messages.*;
import p.studio.compiler.models.*;
import p.studio.compiler.services.FrontendCallHierarchyItem;
import p.studio.compiler.services.FrontendCallSite;
import p.studio.compiler.services.FrontendCodeAction;
import p.studio.compiler.services.FrontendCompletionCandidate;
import p.studio.compiler.services.FrontendDocumentLink;
@@ -73,6 +75,9 @@ public final class CompilerLanguageServiceBridge implements LanguageServiceBridg
final boolean formattingSupported = languageService
.map(FrontendLanguageService::formattingSupported)
.orElse(false);
final boolean callHierarchySupported = languageService
.map(FrontendLanguageService::callHierarchySupported)
.orElse(false);
return new BaselineServerDescription(
"Prometeu Studio LSP",
"0.1.0",
@@ -90,6 +95,7 @@ public final class CompilerLanguageServiceBridge implements LanguageServiceBridg
foldingRangesSupported,
selectionRangesSupported,
formattingSupported,
callHierarchySupported,
presentation.semanticKeys(),
presentation.hostProjections().stream().map(this::mapSemanticHostProjection).toList(),
presentation.themes().stream().map(this::mapVisualTheme).toList(),
@@ -408,6 +414,130 @@ public final class CompilerLanguageServiceBridge implements LanguageServiceBridg
.orElseGet(BaselineDocumentLinks::empty);
}
@Override
public List<BaselineCallHierarchyItem> prepareCallHierarchy(
final LspProjectContext context,
final String documentUri,
final String text,
final int line,
final int character) {
final var languageService = callHierarchyService(context);
if (languageService == null) {
return List.of();
}
try {
return editorialDocument(context, documentUri, text)
.map(document -> {
final DocumentPositionMapper mapper = new DocumentPositionMapper(document.text());
final int offset = mapper.byteOffsetOf(line, character);
return languageService.prepareCallHierarchy(
callRequest(context, documentUri, document.text()),
document.editorialContext(),
offset)
.stream()
.map(item -> toBaselineItem(item, documentUri, mapper))
.toList();
})
.orElseGet(List::of);
} catch (final BuildException ignored) {
return List.of();
}
}
@Override
public List<BaselineCallSite> incomingCalls(
final LspProjectContext context,
final String documentUri,
final String text,
final BaselineCallHierarchyItem target) {
return directedCalls(context, documentUri, text, target, true);
}
@Override
public List<BaselineCallSite> outgoingCalls(
final LspProjectContext context,
final String documentUri,
final String text,
final BaselineCallHierarchyItem target) {
return directedCalls(context, documentUri, text, target, false);
}
private List<BaselineCallSite> directedCalls(
final LspProjectContext context,
final String documentUri,
final String text,
final BaselineCallHierarchyItem target,
final boolean incoming) {
final var languageService = callHierarchyService(context);
if (languageService == null || target == null) {
return List.of();
}
try {
return editorialDocument(context, documentUri, text)
.map(document -> {
final DocumentPositionMapper mapper = new DocumentPositionMapper(document.text());
final FrontendCallHierarchyItem frontendTarget = new FrontendCallHierarchyItem(
target.name(),
target.method(),
mapper.byteOffsetOf(target.startLine(), target.startCharacter()),
mapper.byteOffsetOf(target.endLine(), target.endCharacter()));
final List<FrontendCallSite> calls = incoming
? languageService.incomingCalls(
callRequest(context, documentUri, document.text()),
document.editorialContext(),
frontendTarget)
: languageService.outgoingCalls(
callRequest(context, documentUri, document.text()),
document.editorialContext(),
frontendTarget);
return calls.stream().map(call -> new BaselineCallSite(
toBaselineItem(call.item(), documentUri, mapper),
mapper.positionOf(call.startOffset()).line(),
mapper.positionOf(call.startOffset()).character(),
mapper.positionOf(call.endOffset()).line(),
mapper.positionOf(call.endOffset()).character())).toList();
})
.orElseGet(List::of);
} catch (final BuildException ignored) {
return List.of();
}
}
private FrontendLanguageService callHierarchyService(final LspProjectContext context) {
Objects.requireNonNull(context, "context");
final var languageService = frontendProvider(context).languageService();
if (languageService.isEmpty() || !languageService.orElseThrow().callHierarchySupported()) {
return null;
}
return languageService.orElseThrow();
}
private FrontendDocumentRequest callRequest(
final LspProjectContext context,
final String documentUri,
final String text) {
return new FrontendDocumentRequest(
context.projectRoot(),
normalizeDocumentPath(documentUri),
text == null ? "" : text);
}
private BaselineCallHierarchyItem toBaselineItem(
final FrontendCallHierarchyItem item,
final String documentUri,
final DocumentPositionMapper mapper) {
final DocumentPosition start = mapper.positionOf(item.startOffset());
final DocumentPosition end = mapper.positionOf(item.endOffset());
return new BaselineCallHierarchyItem(
item.name(),
item.method(),
documentUri,
start.line(),
start.character(),
end.line(),
end.character());
}
@Override
public BaselineFormatting formatDocument(
final LspProjectContext context,
@@ -8,6 +8,8 @@ import org.eclipse.lsp4j.jsonrpc.messages.ResponseError;
import org.eclipse.lsp4j.jsonrpc.messages.ResponseErrorCode;
import org.eclipse.lsp4j.services.LanguageClient;
import org.eclipse.lsp4j.services.TextDocumentService;
import p.studio.lsp.messages.BaselineCallHierarchyItem;
import p.studio.lsp.messages.BaselineCallSite;
import p.studio.lsp.messages.BaselineCodeActionDiagnostic;
import p.studio.lsp.messages.DocumentPosition;
import p.studio.lsp.messages.LspProjectContext;
@@ -169,6 +171,51 @@ public final class PrometeuTextDocumentService implements TextDocumentService {
return CompletableFuture.completedFuture(protocolMessageMapper.mapRename(result));
}
@Override
public CompletableFuture<List<CallHierarchyItem>> prepareCallHierarchy(final CallHierarchyPrepareParams params) {
final String uri = params.getTextDocument().getUri();
final String text = documentTextByUri.get(uri);
return CompletableFuture.completedFuture(protocolMessageMapper.mapCallHierarchyItems(
languageServiceBridge.prepareCallHierarchy(
project,
uri,
text,
params.getPosition().getLine(),
params.getPosition().getCharacter())));
}
@Override
public CompletableFuture<List<CallHierarchyIncomingCall>> callHierarchyIncomingCalls(
final CallHierarchyIncomingCallsParams params) {
return CompletableFuture.completedFuture(protocolMessageMapper.mapIncomingCalls(
directedCallSites(params.getItem(), true)));
}
@Override
public CompletableFuture<List<CallHierarchyOutgoingCall>> callHierarchyOutgoingCalls(
final CallHierarchyOutgoingCallsParams params) {
return CompletableFuture.completedFuture(protocolMessageMapper.mapOutgoingCalls(
directedCallSites(params.getItem(), false)));
}
private List<BaselineCallSite> directedCallSites(final CallHierarchyItem item, final boolean incoming) {
if (item == null || item.getUri() == null || item.getSelectionRange() == null) {
return List.of();
}
final String text = documentTextByUri.get(item.getUri());
final BaselineCallHierarchyItem target = new BaselineCallHierarchyItem(
item.getName(),
item.getKind() == SymbolKind.Method,
item.getUri(),
item.getSelectionRange().getStart().getLine(),
item.getSelectionRange().getStart().getCharacter(),
item.getSelectionRange().getEnd().getLine(),
item.getSelectionRange().getEnd().getCharacter());
return incoming
? languageServiceBridge.incomingCalls(project, item.getUri(), text, target)
: languageServiceBridge.outgoingCalls(project, item.getUri(), text, target);
}
@Override
public CompletableFuture<List<? extends TextEdit>> formatting(final DocumentFormattingParams params) {
final String uri = params.getTextDocument().getUri();
@@ -67,6 +67,9 @@ public final class Lsp4jProtocolMessageMapper implements ProtocolMessageMapper {
if (description.formattingSupported()) {
capabilities.setDocumentFormattingProvider(true);
}
if (description.callHierarchySupported()) {
capabilities.setCallHierarchyProvider(true);
}
final SemanticTokensWithRegistrationOptions semanticTokens = new SemanticTokensWithRegistrationOptions();
semanticTokens.setLegend(new SemanticTokensLegend(description.semanticTokenTypes(), List.of()));
semanticTokens.setFull(true);
@@ -190,6 +193,53 @@ public final class Lsp4jProtocolMessageMapper implements ProtocolMessageMapper {
return List.copyOf(mapped);
}
@Override
public List<CallHierarchyItem> mapCallHierarchyItems(final List<BaselineCallHierarchyItem> items) {
if (items == null || items.isEmpty()) {
return List.of();
}
return items.stream().map(this::mapCallHierarchyItem).toList();
}
@Override
public List<CallHierarchyIncomingCall> mapIncomingCalls(final List<BaselineCallSite> calls) {
if (calls == null || calls.isEmpty()) {
return List.of();
}
return calls.stream().map(call -> new CallHierarchyIncomingCall(
mapCallHierarchyItem(call.item()),
List.of(callRange(call)))).toList();
}
@Override
public List<CallHierarchyOutgoingCall> mapOutgoingCalls(final List<BaselineCallSite> calls) {
if (calls == null || calls.isEmpty()) {
return List.of();
}
return calls.stream().map(call -> new CallHierarchyOutgoingCall(
mapCallHierarchyItem(call.item()),
List.of(callRange(call)))).toList();
}
private CallHierarchyItem mapCallHierarchyItem(final BaselineCallHierarchyItem item) {
final CallHierarchyItem mapped = new CallHierarchyItem();
mapped.setName(item.name());
mapped.setKind(item.method() ? SymbolKind.Method : SymbolKind.Function);
mapped.setUri(item.uri());
final Range range = new Range(
new Position(item.startLine(), item.startCharacter()),
new Position(item.endLine(), item.endCharacter()));
mapped.setRange(range);
mapped.setSelectionRange(range);
return mapped;
}
private Range callRange(final BaselineCallSite call) {
return new Range(
new Position(call.startLine(), call.startCharacter()),
new Position(call.endLine(), call.endCharacter()));
}
@Override
public List<TextEdit> mapFormatting(final BaselineFormatting formatting) {
if (formatting == null || formatting.edits().isEmpty()) {
@@ -11,6 +11,9 @@ import org.eclipse.lsp4j.SemanticTokens;
import org.eclipse.lsp4j.Diagnostic;
import org.eclipse.lsp4j.DocumentLink;
import org.eclipse.lsp4j.DocumentSymbol;
import org.eclipse.lsp4j.CallHierarchyIncomingCall;
import org.eclipse.lsp4j.CallHierarchyItem;
import org.eclipse.lsp4j.CallHierarchyOutgoingCall;
import org.eclipse.lsp4j.FoldingRange;
import org.eclipse.lsp4j.TextEdit;
import org.eclipse.lsp4j.SelectionRange;
@@ -25,6 +28,8 @@ import org.eclipse.lsp4j.PrepareRenameResult;
import p.studio.lsp.messages.BaselineDocumentAnalysis;
import p.studio.lsp.messages.BaselineDocumentLinks;
import p.studio.lsp.messages.BaselineFoldingRanges;
import p.studio.lsp.messages.BaselineCallHierarchyItem;
import p.studio.lsp.messages.BaselineCallSite;
import p.studio.lsp.messages.BaselineFormatting;
import p.studio.lsp.messages.BaselineSelectionRanges;
import p.studio.lsp.messages.BaselineDocumentSymbols;
@@ -79,6 +84,18 @@ public interface ProtocolMessageMapper {
return List.of();
}
default List<CallHierarchyItem> mapCallHierarchyItems(List<BaselineCallHierarchyItem> items) {
return List.of();
}
default List<CallHierarchyIncomingCall> mapIncomingCalls(List<BaselineCallSite> calls) {
return List.of();
}
default List<CallHierarchyOutgoingCall> mapOutgoingCalls(List<BaselineCallSite> calls) {
return List.of();
}
default List<SelectionRange> mapSelectionRanges(BaselineSelectionRanges ranges) {
return List.of();
}
@@ -222,6 +222,62 @@ class CompilerLanguageServiceBridgeTest {
assertTrue(brokenTokens.tokens().stream().anyMatch(token -> token.semanticKey().equals("pbs-punctuation")));
}
@Test
void callHierarchyUsesAstCallsAndRefusesAStruct(@TempDir final Path tempDir) throws IOException {
final Path projectRoot = tempDir.resolve("app");
final Path source = projectRoot.resolve("src").resolve("main.pbs");
Files.createDirectories(source.getParent());
Files.writeString(projectRoot.resolve("prometeu.json"), """
{
"name": "app",
"version": "1.0.0",
"language": "pbs",
"stdlib": "1",
"target": "Game",
"dependencies": []
}
""");
final String text = """
fn helper() -> int {
return 1;
}
fn main() -> int {
return helper();
}
""";
Files.writeString(source, text);
Files.writeString(source.getParent().resolve("mod.barrel"), """
pub fn helper() -> int;
pub fn main() -> int;
""");
final CompilerLanguageServiceBridge bridge = new CompilerLanguageServiceBridge();
final LspProjectContext context = new LspProjectContext("app", "pbs", projectRoot.toRealPath());
final String uri = source.toRealPath().toUri().toString();
final DocumentPositionMapper mapper = new DocumentPositionMapper(text);
final var mainPosition = mapper.positionOf(text.indexOf("fn main") + 1);
final var prepared = bridge.prepareCallHierarchy(
context,
uri,
text,
mainPosition.line(),
mainPosition.character());
assertEquals(1, prepared.size());
assertEquals("main", prepared.getFirst().name());
final var outgoing = bridge.outgoingCalls(context, uri, text, prepared.getFirst());
assertTrue(outgoing.stream().anyMatch(call -> call.item().name().equals("helper")));
final var structPosition = mapper.positionOf(text.indexOf("fn helper") + 1);
final var helper = bridge.prepareCallHierarchy(
context,
uri,
text,
structPosition.line(),
structPosition.character());
assertEquals("helper", helper.getFirst().name());
assertTrue(bridge.incomingCalls(context, uri, text, helper.getFirst()).stream()
.anyMatch(call -> call.item().name().equals("main")));
}
@Test
void completionHoverAndSignatureHelpUseCompilerBackedEditorialResolution() {
final Path projectRoot = findRepoRoot(Path.of("").toAbsolutePath().normalize())
@@ -830,6 +886,7 @@ class CompilerLanguageServiceBridgeTest {
assertTrue(description.foldingRangesSupported());
assertTrue(description.selectionRangesSupported());
assertTrue(description.formattingSupported());
assertTrue(description.callHierarchySupported());
assertEquals(1, description.semanticHostProjections().size());
assertEquals("vscode", description.semanticHostProjections().getFirst().hostId());
assertTrue(description.semanticHostProjections().getFirst().tokenProjections().stream()
@@ -109,6 +109,7 @@ class PrometeuLanguageServerTest {
false,
false,
false,
false,
List.of(),
List.of(new BaselineSemanticHostProjection(
"vscode",
@@ -61,6 +61,7 @@ final class Lsp4jProtocolMessageMapperTest {
true,
true,
true,
true,
List.of("demo-keyword"),
List.of(new BaselineSemanticHostProjection(
"vscode",
@@ -94,6 +95,8 @@ final class Lsp4jProtocolMessageMapperTest {
assertEquals(Boolean.TRUE, result.getCapabilities().getDocumentFormattingProvider().getLeft());
assertNull(result.getCapabilities().getDocumentRangeFormattingProvider());
assertNull(result.getCapabilities().getDocumentOnTypeFormattingProvider());
assertEquals(Boolean.TRUE, result.getCapabilities().getCallHierarchyProvider().getLeft());
assertNull(result.getCapabilities().getTypeHierarchyProvider());
final var experimental = assertInstanceOf(Map.class, result.getCapabilities().getExperimental());
final var semanticPayload = assertInstanceOf(Map.class, experimental.get("prometeuSemanticHostProjections"));
@@ -348,6 +351,7 @@ final class Lsp4jProtocolMessageMapperTest {
documentLinksSupported,
documentLinksSupported,
documentLinksSupported,
documentLinksSupported,
List.of("demo-keyword"),
List.of(new BaselineSemanticHostProjection(
"vscode",