Files
prometeu-studio/prometeu-app/src/main/java/p/studio/app/lsp/AutomationLspQueries.java
T
bquarkz ea1cc26fe3
Test / Tests and coverage occurred while executing withChecks step.
Intrepid/Prometeu/Studio/pipeline/pr-master There was a failure building this commit
feat(studio): improve compiler reliability and AI diagnostics
Preserve structured diagnostics, source attribution, phase outcomes and revision context through compiler, Studio, LSP, MCP and JavaFX. Add project service discovery and resilient VS Code reconnection.

Correct all eight reproduced PBS production failures in expression context, sibling executable bindings and nominal owner identity. Consolidate specs, lessons, immutable baseline evidence and the maintained source-to-guest qualification runner.

Validation: required Gradle gate recorded 724 tests, with 711 passed and 13 skipped. Full corpus passed 168 compilation observations and 108 guest runs (104 successes and four deliberate faults); supplemental controls passed 42 compilations and 16 guest runs. TypeScript compilation, two Node discovery tests and discussion validation passed.
2026-11-10 12:36:25 +00:00

443 lines
33 KiB
Java

package p.studio.app.lsp;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.eclipse.lsp4j.*;
import org.eclipse.lsp4j.jsonrpc.json.MessageJsonHandler;
import org.eclipse.lsp4j.jsonrpc.messages.Either;
import org.eclipse.lsp4j.launch.LSPLauncher;
import org.eclipse.lsp4j.services.*;
import p.studio.api.automation.*;
import p.studio.api.project.ProjectCatalog;
import p.studio.core.language.LanguageQueryPort;
import p.studio.core.language.LanguageQueryExecution;
import p.studio.utilities.json.*;
import p.studio.lsp.api.LspServerLifecycle;
import p.studio.lsp.services.protocol.ExternalSourceLanguageServer;
import org.eclipse.lsp4j.jsonrpc.Launcher;
import java.net.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;
/** A real client of the already-running project LSP. Each query owns and closes its connection. */
public final class AutomationLspQueries implements LanguageQueryPort {
private final LspServerLifecycle lifecycle;
private final ProjectCatalog projects;
private final ProjectKnowledge knowledge;
private final ObjectMapper mapper;
private final com.google.gson.Gson gson = new MessageJsonHandler(Map.of()).getGson();
private final Map<TaskIdentity, Map<String, CallHierarchyItem>> items = new ConcurrentHashMap<>();
private static final Set<String> OPERATIONS = Set.of("readExternalSource", "diagnostics", "completion", "hover", "signatureHelp", "definition",
"references", "documentSymbols", "workspaceSymbols", "prepareRename", "rename", "codeActions", "formatting",
"documentLinks", "foldingRanges", "selectionRanges", "prepareCallHierarchy", "incomingCalls", "outgoingCalls", "semanticTokens");
private static final Set<String> EDITS = Set.of("completion", "prepareRename", "rename", "codeActions", "formatting");
public AutomationLspQueries(LspServerLifecycle lifecycle, ProjectCatalog projects, ProjectKnowledge knowledge, ObjectMapper mapper) {
this.lifecycle = lifecycle; this.projects = projects; this.knowledge = knowledge; this.mapper = mapper;
}
private record ExternalTask(String consumer, p.studio.lsp.messages.LspServerEndpoint endpoint,
p.studio.lsp.messages.LspProjectContext binding, Set<String> uris) {}
private final Map<TaskIdentity, ExternalTask> externalTasks = new ConcurrentHashMap<>();
@Override public void endTask(TaskIdentity task) {
items.remove(task);
final var state = externalTasks.get(task);
if (state == null) return;
final var workers = Executors.newCachedThreadPool();
try (var socket = new Socket()) {
socket.connect(new InetSocketAddress(state.endpoint().host(), state.endpoint().port()), 2000);
final var client = new QuietClient();
final var launcher = new Launcher.Builder<ExternalSourceLanguageServer>().setLocalService(client)
.setRemoteInterface(ExternalSourceLanguageServer.class).setInput(socket.getInputStream())
.setOutput(socket.getOutputStream()).setExecutorService(workers).create();
final var listening = launcher.startListening();
try {
final var server = launcher.getRemoteProxy();
final var init = new InitializeParams();
init.setRootUri(state.binding().projectRoot().toUri().toString());
init.setCapabilities(new ClientCapabilities());
init.getCapabilities().setExperimental(Map.of("prometeuExternalSources", true));
init.setInitializationOptions(Map.of("prometeuExternalConsumerId", state.consumer()));
server.initialize(init).get(2, TimeUnit.SECONDS);
server.releaseExternalSource(new ExternalSourceLanguageServer.Request(state.consumer(), null)).get(2, TimeUnit.SECONDS);
externalTasks.remove(task, state);
} finally { listening.cancel(true); }
} catch (Exception failure) {
// A closed project host has already released its registry. Other cleanup
// failures are surfaced instead of silently reporting a successful task end.
if (lifecycle.endpoint(state.binding()).isPresent())
throw new IllegalStateException("Could not release task external sources", failure);
externalTasks.remove(task, state);
} finally { new LanguageQueryExecution("endTask", 10_000, 2_000).finishWorkers(workers); }
}
private static class QuietClient implements LanguageClient {
public void telemetryEvent(Object event) {}
public void publishDiagnostics(PublishDiagnosticsParams event) {}
public void showMessage(MessageParams message) {}
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams request) { return CompletableFuture.completedFuture(null); }
public void logMessage(MessageParams message) {}
}
@Override public Map<String, Object> query(TaskIdentity task, String operation, Map<String, Object> parameters) throws Exception {
return query(task, operation, parameters, new LanguageQueryExecution(operation, 10_000, 2_000));
}
@Override public Map<String, Object> query(TaskIdentity task, String operation, Map<String, Object> parameters,
LanguageQueryExecution execution) throws Exception {
try {
var result = performQuery(task, operation, parameters, execution);
if (execution.hasFailure()) throw execution.exception(AutomationFailure.Code.LANGUAGE_QUERY_CLEANUP_FAILED, "Language query cleanup failed", true);
return result;
} catch (IllegalArgumentException | ControlDeniedException failure) { throw failure; }
catch (Exception failure) {
recordFailure(execution, failure);
throw execution.exception(AutomationFailure.Code.LANGUAGE_QUERY_INTERNAL_FAILURE, "Language query failed", true);
}
}
private Map<String, Object> performQuery(TaskIdentity task, String operation, Map<String, Object> parameters,
LanguageQueryExecution execution) throws Exception {
if (!OPERATIONS.contains(operation)) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "Unsupported language operation: " + operation);
var context = knowledge.context(task.projectRoot());
var primary = context.languages().stream().filter(ProjectKnowledge.Language::primary).findFirst().orElseThrow();
if (primary.capabilities().stream().anyMatch(cap -> cap.name().equals("lsp") && cap.support() != ProjectKnowledge.Support.SUPPORTED))
throw failure(AutomationFailure.Code.UNSUPPORTED_LANGUAGE, "Project language has no available LSP");
var project = projects.openProject(context.projectRoot());
var binding = LspLifecycleAdapter.context(project);
var endpoint = lifecycle.endpoint(binding).orElseThrow(() -> failure(AutomationFailure.Code.LANGUAGE_SERVER_UNAVAILABLE, "Project LSP is not running; reopen the project if its language changed"));
var params = mapper.valueToTree(parameters);
CallHierarchyItem item = null;
String uri = null;
if (operation.equals("incomingCalls") || operation.equals("outgoingCalls")) {
item = items.getOrDefault(task, Map.of()).get(params.path("itemId").asText());
if (item == null) throw new IllegalArgumentException("Unknown task-local hierarchy itemId");
uri = item.getUri();
} else if (!operation.equals("workspaceSymbols")) {
uri = params.path("uri").asText(null);
if (uri == null) throw new IllegalArgumentException("uri is required");
}
final boolean external = uri != null && uri.startsWith("prometeu-source:");
if (external) {
final var state = externalTasks.get(task);
if (state == null || !state.uris().contains(uri)) throw failure(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, "Unknown task-owned external source");
if (EDITS.contains(operation)) throw failure(AutomationFailure.Code.READ_ONLY_SCOPE, "External sources are read-only");
if (!Set.of("readExternalSource", "hover", "definition").contains(operation))
throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "Operation is unavailable for external documents");
} else if (operation.equals("readExternalSource")) throw new IllegalArgumentException("An external source URI is required");
Path document = uri == null || external ? null : sourcePath(context, uri);
if (document != null && EDITS.contains(operation)) requireEditable(context, document.toUri().toString());
String source = null;
if (document != null) {
try (var input = Files.newInputStream(document)) {
var bytes = input.readNBytes(4 * 1024 * 1024 + 1);
if (bytes.length > 4 * 1024 * 1024) throw failure(AutomationFailure.Code.LIMIT_EXCEEDED, "Source document exceeds 4 MiB");
source = java.nio.charset.StandardCharsets.UTF_8.newDecoder().decode(java.nio.ByteBuffer.wrap(bytes)).toString();
}
uri = document.toUri().toString();
}
long deadline = execution.deadlineNanos();
if (System.nanoTime() >= deadline) throw new TimeoutException("Language query admission budget expired");
var workers = Executors.newCachedThreadPool(r -> { var thread = new Thread(r, "studio-automation-lsp"); thread.setDaemon(true); return thread; });
try (var socket = new Socket()) {
execution.own(() -> { try { socket.close(); } catch (java.io.IOException ignored) {} });
execution.own(workers::shutdownNow);
if (!InetAddress.getByName(endpoint.host()).isLoopbackAddress()) throw failure(AutomationFailure.Code.LANGUAGE_SERVER_UNAVAILABLE, "Project LSP endpoint is not local");
socket.connect(new InetSocketAddress(endpoint.host(), endpoint.port()), (int)Math.max(1, Math.min(2000, TimeUnit.NANOSECONDS.toMillis(deadline - System.nanoTime()))));
var diagnostics = new CompletableFuture<List<Diagnostic>>();
String expectedUri = uri;
LanguageClient client = new LanguageClient() {
public void telemetryEvent(Object event) {}
public void publishDiagnostics(PublishDiagnosticsParams event) { if (Objects.equals(event.getUri(), expectedUri)) diagnostics.complete(List.copyOf(event.getDiagnostics())); }
public void showMessage(MessageParams message) {}
public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams request) { return CompletableFuture.completedFuture(null); }
public void logMessage(MessageParams message) {}
@Override public CompletableFuture<ApplyWorkspaceEditResponse> applyEdit(ApplyWorkspaceEditParams edit) {
return CompletableFuture.completedFuture(new ApplyWorkspaceEditResponse(false));
}
};
var launcher = new Launcher.Builder<ExternalSourceLanguageServer>().setLocalService(client)
.setRemoteInterface(ExternalSourceLanguageServer.class).setInput(socket.getInputStream())
.setOutput(socket.getOutputStream()).setExecutorService(workers).create();
var listening = launcher.startListening();
execution.own(() -> listening.cancel(true));
final var server = launcher.getRemoteProxy();
final var acquired = new HashSet<String>();
boolean succeeded = false;
try {
var initialize = new InitializeParams();
initialize.setRootUri(binding.projectRoot().toUri().toString());
initialize.setCapabilities(new ClientCapabilities());
initialize.getCapabilities().setExperimental(Map.of("prometeuExternalSources", true,
"prometeuDiagnosticAnalysis", Map.of("version", 1)));
final var previous = externalTasks.get(task);
initialize.setInitializationOptions(previous == null
? Map.of("prometeuExternalPersistentConsumer", true)
: Map.of("prometeuExternalConsumerId", previous.consumer(), "prometeuExternalPersistentConsumer", true));
execution.method("initialize");
var capabilities = await(server.initialize(initialize), deadline, execution).getCapabilities();
final var experimental = gson.toJsonTree(capabilities.getExperimental());
if (experimental.isJsonObject() && experimental.getAsJsonObject().has("prometeuExternalConsumerId")) {
final String consumer = experimental.getAsJsonObject().get("prometeuExternalConsumerId").getAsString();
externalTasks.putIfAbsent(task, new ExternalTask(consumer, endpoint, binding, ConcurrentHashMap.newKeySet()));
}
server.initialized(new InitializedParams());
requireCapability(operation, capabilities);
List<Diagnostic> currentDiagnostics = List.of();
Map<String, Object> analysis = Map.of();
var rich = experimental.isJsonObject() ? experimental.getAsJsonObject().get("prometeuDiagnosticAnalysis") : null;
boolean richAnalysis = rich != null && rich.isJsonObject() && rich.getAsJsonObject().has("version")
&& rich.getAsJsonObject().get("version").getAsInt() == 1;
String digest = source == null ? null : sha256(source);
if (document != null) {
// Fresh client overlay contains exactly the saved UTF-8 file. Wait for analysis before querying.
server.getTextDocumentService().didOpen(new DidOpenTextDocumentParams(new TextDocumentItem(uri, primary.id(), 1, source)));
if (richAnalysis) {
execution.method("prometeu/documentAnalysis");
var retained = await(server.documentAnalysis(new ExternalSourceLanguageServer.DiagnosticAnalysisRequest(
new VersionedTextDocumentIdentifier(uri, 1), digest)), deadline, execution);
analysis = mapper.convertValue(mapper.readTree(gson.toJson(retained)), Map.class);
}
currentDiagnostics = await(diagnostics, deadline, execution);
}
Map<String, Object> externalRevision = Map.of();
if (external) {
final var request = new ExternalSourceLanguageServer.Request(externalTasks.get(task).consumer(), uri);
var content = await(server.revalidateExternalSource(request), deadline, execution);
source = content.text();
externalRevision = mapper.convertValue(mapper.readTree(gson.toJson(content)), Map.class);
externalRevision = new LinkedHashMap<>(externalRevision);
externalRevision.remove("text");
if (source.getBytes(java.nio.charset.StandardCharsets.UTF_8).length > 4 * 1024 * 1024)
throw failure(AutomationFailure.Code.LIMIT_EXCEEDED, "External source exceeds 4 MiB");
}
execution.method(operation);
var text = server.getTextDocumentService();
var id = uri == null ? null : new TextDocumentIdentifier(uri);
Object result = switch (operation) {
case "readExternalSource" -> await(server.readExternalSource(
new ExternalSourceLanguageServer.Request(externalTasks.get(task).consumer(), uri)), deadline, execution);
case "diagnostics" -> currentDiagnostics;
case "hover" -> await(text.hover(new HoverParams(id, position(params.path("position"), source))), deadline, execution);
case "completion" -> await(text.completion(new CompletionParams(id, position(params.path("position"), source))), deadline, execution);
case "signatureHelp" -> await(text.signatureHelp(new SignatureHelpParams(id, position(params.path("position"), source))), deadline, execution);
case "definition" -> await(text.definition(new DefinitionParams(id, position(params.path("position"), source))), deadline, execution);
case "references" -> await(text.references(new ReferenceParams(id, position(params.path("position"), source), new ReferenceContext(params.path("includeDeclaration").asBoolean(false)))), deadline, execution);
case "documentSymbols" -> await(text.documentSymbol(new DocumentSymbolParams(id)), deadline, execution);
case "workspaceSymbols" -> await(server.getWorkspaceService().symbol(new WorkspaceSymbolParams(params.path("query").asText(""))), deadline, execution);
case "prepareRename" -> await(text.prepareRename(new PrepareRenameParams(id, position(params.path("position"), source))), deadline, execution);
case "rename" -> {
String name = params.path("newName").asText("");
if (name.isBlank()) throw new IllegalArgumentException("newName is required");
yield await(text.rename(new RenameParams(id, position(params.path("position"), source), name)), deadline, execution);
}
case "formatting" -> await(text.formatting(new DocumentFormattingParams(id, new FormattingOptions(4, true))), deadline, execution);
case "codeActions" -> await(text.codeAction(new CodeActionParams(id,
range(params.path("range"), source),
new CodeActionContext(currentDiagnostics))), deadline, execution);
case "documentLinks" -> await(text.documentLink(new DocumentLinkParams(id)), deadline, execution);
case "foldingRanges" -> await(text.foldingRange(new FoldingRangeRequestParams(id)), deadline, execution);
case "selectionRanges" -> {
if (!params.path("positions").isArray() || params.path("positions").isEmpty()) throw new IllegalArgumentException("positions are required");
var positions = new ArrayList<Position>();
for (var p : params.path("positions")) positions.add(position(p, source));
yield await(text.selectionRange(new SelectionRangeParams(id, positions)), deadline, execution);
}
case "prepareCallHierarchy" -> await(text.prepareCallHierarchy(new CallHierarchyPrepareParams(id, position(params.path("position"), source))), deadline, execution);
case "incomingCalls" -> await(text.callHierarchyIncomingCalls(new CallHierarchyIncomingCallsParams(item)), deadline, execution);
case "outgoingCalls" -> await(text.callHierarchyOutgoingCalls(new CallHierarchyOutgoingCallsParams(item)), deadline, execution);
case "semanticTokens" -> await(text.semanticTokensFull(new SemanticTokensParams(id)), deadline, execution);
default -> throw new IllegalArgumentException("Unsupported operation");
};
var wire = mapper.readTree(gson.toJson(result));
validateEdits(context, wire);
if (operation.equals("definition") && externalTasks.containsKey(task)) {
final var returned = new HashSet<String>();
rememberExternalUris(returned, wire);
acquired.addAll(returned);
acquired.removeAll(externalTasks.get(task).uris());
for (String externalUri : returned) {
await(server.retainExternalSource(new ExternalSourceLanguageServer.Request(
externalTasks.get(task).consumer(), externalUri)), deadline, execution);
externalTasks.get(task).uris().add(externalUri);
}
}
var limitations = new ArrayList<String>();
if (operation.equals("codeActions") && wire.isArray()) {
for (var action : wire) if (action.has("command")) {
((com.fasterxml.jackson.databind.node.ObjectNode) action).remove("command");
limitations.add("Executable LSP commands are not exposed; only edit proposals are returned");
}
}
if (operation.equals("prepareCallHierarchy") || operation.equals("incomingCalls") || operation.equals("outgoingCalls")) addItemIds(task, wire);
var output = new LinkedHashMap<String, Object>();
output.put("operation", operation); output.put("result", mapper.convertValue(wire, Object.class));
if (document != null && !richAnalysis) {
limitations.add("ANALYSIS_DETAILS_UNAVAILABLE");
analysis = ImmutableJson.fields("analysisId", null, "issues", List.of(), "summary",
DiagnosticPayloads.legacySummary("document"));
}
output.put("limitations", limitations);
output.put("analysis", analysis);
output.put("context", ImmutableJson.fields("projectRoot", context.projectRoot().toString(),
"taskId", task.value(), "clientRequestId", null, "buildId", null, "queryId", execution.queryId(), "analysisId", analysis.get("analysisId"),
"document", document == null ? null : ImmutableJson.fields("uri", uri, "version", 1, "sha256", digest),
"inputs", analysis.getOrDefault("inputs", List.of()), "externalRevision", externalRevision,
"inputCoverage", "partial", "configuration", analysis.getOrDefault("configuration", Map.of())));
succeeded = true;
return Collections.unmodifiableMap(output);
} catch (Exception failure) {
recordFailure(execution, failure);
throw failure;
} finally {
if (!succeeded && !acquired.isEmpty() && externalTasks.containsKey(task)) {
final var state = externalTasks.get(task);
final boolean interrupted = Thread.interrupted();
try {
for (String acquiredUri : acquired) {
state.uris().remove(acquiredUri);
server.releaseExternalSource(new ExternalSourceLanguageServer.Request(state.consumer(), acquiredUri))
.get(500, TimeUnit.MILLISECONDS);
}
} catch (Exception cleanupFailure) {
execution.record(AutomationFailure.Code.LANGUAGE_QUERY_CLEANUP_FAILED, "Could not release query external sources", Map.of());
} finally { if (interrupted) Thread.currentThread().interrupt(); }
}
listening.cancel(true);
}
} finally { execution.finishWorkers(workers); }
}
private static String sha256(String text) throws java.security.NoSuchAlgorithmException {
return HexFormat.of().formatHex(java.security.MessageDigest.getInstance("SHA-256")
.digest(text.getBytes(java.nio.charset.StandardCharsets.UTF_8)));
}
private static void recordFailure(LanguageQueryExecution execution, Exception failure) {
if (failure instanceof AutomationException domain) { execution.record(domain.failure()); return; }
if (failure instanceof IllegalArgumentException || failure instanceof ControlDeniedException) return;
var cause = failure instanceof ExecutionException && failure.getCause() != null ? failure.getCause() : failure;
AutomationFailure.Code code;
Map<String, Object> details = Map.of();
if (cause instanceof TimeoutException || cause instanceof SocketTimeoutException) code = AutomationFailure.Code.LANGUAGE_QUERY_TIMEOUT;
else if (cause instanceof InterruptedException || cause instanceof CancellationException) code = AutomationFailure.Code.LANGUAGE_QUERY_CANCELLED;
else if (cause instanceof ConnectException || cause instanceof SocketException) code = AutomationFailure.Code.LANGUAGE_SERVER_UNAVAILABLE;
else if (cause instanceof org.eclipse.lsp4j.jsonrpc.ResponseErrorException response) {
int rpc = response.getResponseError().getCode();
details = ImmutableJson.fields("protocolCode", rpc, "reason", rpc == -32020 ? "ANALYSIS_REVISION_MISMATCH" : rpc == -32021 ? "ANALYSIS_UNAVAILABLE" : null);
code = rpc == -32020 ? AutomationFailure.Code.LANGUAGE_QUERY_REVISION_MISMATCH
: rpc == -32021 || rpc == -32603 ? AutomationFailure.Code.LANGUAGE_QUERY_INTERNAL_FAILURE
: AutomationFailure.Code.LANGUAGE_QUERY_PROTOCOL_FAILURE;
} else if (cause instanceof org.eclipse.lsp4j.jsonrpc.JsonRpcException || cause instanceof com.google.gson.JsonParseException
|| cause instanceof com.fasterxml.jackson.core.JsonProcessingException) code = AutomationFailure.Code.LANGUAGE_QUERY_PROTOCOL_FAILURE;
else code = AutomationFailure.Code.LANGUAGE_QUERY_INTERNAL_FAILURE;
execution.record(code, "Language query failed: " + code.name(), details);
}
private void rememberExternalUris(Set<String> uris, com.fasterxml.jackson.databind.JsonNode node) {
if (node.isObject() && node.path("uri").asText().startsWith("prometeu-source:")) uris.add(node.path("uri").asText());
if (node.isContainerNode()) node.forEach(child -> rememberExternalUris(uris, child));
}
private void addItemIds(TaskIdentity task, com.fasterxml.jackson.databind.JsonNode node) {
if (node.isObject() && node.has("uri") && node.has("selectionRange") && node.has("name") && node.has("kind")) {
var stored = items.computeIfAbsent(task, ignored -> new ConcurrentHashMap<>());
if (stored.size() >= 1024) throw failure(AutomationFailure.Code.LIMIT_EXCEEDED, "Too many hierarchy items for this task");
String key = UUID.randomUUID().toString();
stored.put(key, gson.fromJson(node.toString(), CallHierarchyItem.class));
((com.fasterxml.jackson.databind.node.ObjectNode) node).put("itemId", key);
} else if (node.isContainerNode()) node.forEach(child -> addItemIds(task, child));
}
private static void requireCapability(String operation, ServerCapabilities caps) {
if (operation.equals("readExternalSource")) {
final var raw = new com.google.gson.Gson().toJsonTree(caps.getExperimental());
if (!raw.isJsonObject() || !raw.getAsJsonObject().has("prometeuExternalSources"))
throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP does not advertise external sources");
return;
}
Object capability = switch (operation) {
case "diagnostics" -> caps.getTextDocumentSync();
case "hover" -> caps.getHoverProvider(); case "completion" -> caps.getCompletionProvider();
case "signatureHelp" -> caps.getSignatureHelpProvider(); case "definition" -> caps.getDefinitionProvider();
case "references" -> caps.getReferencesProvider(); case "documentSymbols" -> caps.getDocumentSymbolProvider();
case "workspaceSymbols" -> caps.getWorkspaceSymbolProvider(); case "rename", "prepareRename" -> caps.getRenameProvider();
case "codeActions" -> caps.getCodeActionProvider(); case "formatting" -> caps.getDocumentFormattingProvider();
case "documentLinks" -> caps.getDocumentLinkProvider(); case "foldingRanges" -> caps.getFoldingRangeProvider();
case "selectionRanges" -> caps.getSelectionRangeProvider(); case "prepareCallHierarchy", "incomingCalls", "outgoingCalls" -> caps.getCallHierarchyProvider();
case "semanticTokens" -> caps.getSemanticTokensProvider(); default -> null;
};
if (capability instanceof Either<?, ?> either) capability = either.isLeft() ? either.getLeft() : either.getRight();
if (operation.equals("prepareRename") && (!(capability instanceof RenameOptions options) || !Boolean.TRUE.equals(options.getPrepareProvider())))
throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP does not advertise prepareRename");
if (capability == null || Boolean.FALSE.equals(capability)) throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP does not advertise " + operation);
}
private static Position position(com.fasterxml.jackson.databind.JsonNode node, String text) {
if (!node.path("line").isIntegralNumber() || !node.path("character").isIntegralNumber()
|| !node.path("line").canConvertToInt() || !node.path("character").canConvertToInt()) throw new IllegalArgumentException("UTF-16 position is required");
int line = node.path("line").intValue(), character = node.path("character").intValue();
String[] lines = text.split("\\r\\n|\\n|\\r", -1);
if (line < 0 || line >= lines.length || character < 0 || character > lines[line].length()
|| character > 0 && character < lines[line].length() && Character.isHighSurrogate(lines[line].charAt(character - 1)) && Character.isLowSurrogate(lines[line].charAt(character)))
throw new IllegalArgumentException("Position is outside the saved document or splits a UTF-16 pair");
return new Position(line, character);
}
private static Range range(com.fasterxml.jackson.databind.JsonNode node, String text) {
var start = position(node.path("start"), text); var end = position(node.path("end"), text);
if (start.getLine() > end.getLine() || start.getLine() == end.getLine() && start.getCharacter() > end.getCharacter())
throw new IllegalArgumentException("Range end precedes its start");
return new Range(start, end);
}
private static Path sourcePath(ProjectKnowledge.Context context, String uri) throws Exception {
final Path path;
try { path = Path.of(URI.create(uri)).toRealPath(); }
catch (RuntimeException | java.io.IOException invalid) { throw failure(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, "Source URI is not an accessible local project/dependency file"); }
boolean scope = path.startsWith(context.projectRoot()) || context.readOnlyRoots().stream().anyMatch(path::startsWith)
|| context.libraries().stream().flatMap(lib -> lib.roots().stream()).anyMatch(path::startsWith);
boolean source = context.languages().stream().flatMap(lang -> lang.extensions().stream()).anyMatch(extension -> path.getFileName().toString().endsWith("." + extension));
if (!scope || !source || !Files.isRegularFile(path)) throw failure(AutomationFailure.Code.OUTSIDE_PROJECT_SCOPE, "URI is outside the known source scope");
return path;
}
private static void requireEditable(ProjectKnowledge.Context context, String uri) throws Exception {
Path path = sourcePath(context, uri);
if (!path.startsWith(context.projectRoot()) || context.readOnlyRoots().stream().anyMatch(path::startsWith))
throw failure(AutomationFailure.Code.READ_ONLY_SCOPE, "LSP edit proposal targets a read-only SDK/dependency");
}
private static void validateEdits(ProjectKnowledge.Context context, com.fasterxml.jackson.databind.JsonNode node) throws Exception {
if (node.isObject()) {
if (node.has("changes")) {
var fields = node.path("changes").fieldNames();
while (fields.hasNext()) requireEditable(context, fields.next());
}
if (node.has("textDocument") && node.has("edits")) requireEditable(context, node.path("textDocument").path("uri").asText());
if (node.has("kind") && Set.of("create", "rename", "delete").contains(node.path("kind").asText()))
throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, "LSP file operations are not exposed");
}
if (node.isContainerNode()) for (var child : node) validateEdits(context, child);
}
private static <T> T await(CompletableFuture<T> future, long deadline, LanguageQueryExecution execution) throws Exception {
execution.own(() -> future.cancel(true));
try { return future.get(Math.max(1, deadline - System.nanoTime()), TimeUnit.NANOSECONDS); }
catch (ExecutionException failure) {
if (failure.getCause() instanceof org.eclipse.lsp4j.jsonrpc.ResponseErrorException response) {
int code = response.getResponseError().getCode();
if (code == -32010) throw failure(AutomationFailure.Code.READ_ONLY_SCOPE, response.getResponseError().getMessage());
if (code == -32602) throw new IllegalArgumentException("LSP rejected query parameters");
if (code == -32601 || code == -32600)
throw failure(AutomationFailure.Code.UNSUPPORTED_CAPABILITY, response.getResponseError().getMessage());
}
throw failure;
}
catch (Exception failure) { future.cancel(true); throw failure; }
}
private static AutomationException failure(AutomationFailure.Code code, String message) { return new AutomationException(code, message); }
}