Skip to content

Commit cda4eea

Browse files
gselzerclaude
andcommitted
code-lsp: advertise what process servers can do
ProcessLanguageServer answered initialize with no capabilities, so a client following them would neither sync documents nor ask for completion, hover or signature help. Now initializing starts the process, and passes on its capabilities: of the features the proxy forwards, those the process has; with documents always synced by their whole text, as the proxy requires. If the process cannot start, no features are claimed. Also, tests that need a failing ServerProcesses now make their own, rather than replacing (and, in testRetry, leaking) the one setUp made. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1 parent cf5bfa4 commit cda4eea

7 files changed

Lines changed: 159 additions & 36 deletions

File tree

‎scijava-code-lsp-ty/src/test/java/org/scijava/code/lsp/ty/TyLifecycleIntegrationTest.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -50,8 +50,8 @@
5050

5151

5252
/**
53-
* Tests that {@link TyLanguageServerPlugin}'s ty processes start when first
54-
* used, and stop when the context is disposed. Also an example of using a
53+
* Tests that {@link TyLanguageServerPlugin}'s ty processes start when their
54+
* servers are initialized, and stop when the context is disposed. Also an example of using a
5555
* server directly, through the {@link LanguageServer} API
5656
*
5757
* @author Gabriel Selzer

‎scijava-code-lsp/src/main/java/org/scijava/code/lsp/server/ProcessLanguageServer.java‎

Lines changed: 40 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -57,6 +57,7 @@
5757
import org.eclipse.lsp4j.SignatureHelp;
5858
import org.eclipse.lsp4j.SignatureHelpParams;
5959
import org.eclipse.lsp4j.TextDocumentItem;
60+
import org.eclipse.lsp4j.TextDocumentSyncKind;
6061
import org.eclipse.lsp4j.jsonrpc.messages.Either;
6162
import org.eclipse.lsp4j.services.LanguageClient;
6263
import org.eclipse.lsp4j.services.LanguageClientAware;
@@ -114,9 +115,10 @@ public void connect(final LanguageClient c) {
114115
public CompletableFuture<InitializeResult> initialize(
115116
final InitializeParams params)
116117
{
117-
// NB: The process is initialized when started (see ServerProcesses).
118-
return CompletableFuture.completedFuture(new InitializeResult(
119-
new ServerCapabilities()));
118+
// NB: Starts the process, to say what it can do; if it cannot start, says
119+
// what it could, as it may start later (when asked again).
120+
return slot.process().handle((s, error) -> new InitializeResult(
121+
capabilities(s == null ? fallback() : s.capabilities())));
120122
}
121123

122124
@Override
@@ -216,6 +218,41 @@ public void didChangeWatchedFiles(final DidChangeWatchedFilesParams p) {
216218

217219
// -- Helper methods --
218220

221+
/**
222+
* The capabilities of this {@link ProcessLanguageServer}. Mostly, this is an
223+
* intersection: of the features this proxy passes on (completion, signature
224+
* help and hover), those the process has, as it described them.
225+
* <p>
226+
* Documents are synchronized as the proxy does it (by
227+
* their whole text; see {@link #didChange}), whatever the process said.
228+
* </p>
229+
*
230+
* @param process What the process said it can do.
231+
*/
232+
private static ServerCapabilities capabilities(
233+
final ServerCapabilities process)
234+
{
235+
final ServerCapabilities c = new ServerCapabilities();
236+
c.setCompletionProvider(process.getCompletionProvider());
237+
c.setSignatureHelpProvider(process.getSignatureHelpProvider());
238+
c.setHoverProvider(process.getHoverProvider());
239+
// NB: Not intersected: how documents are synced is up to the proxy.
240+
c.setTextDocumentSync(TextDocumentSyncKind.Full);
241+
return c;
242+
}
243+
244+
/**
245+
* What to assume a process can do when it could not be started: nothing.
246+
* <p>
247+
* NB: The client keeps the capabilities it is told at initialization for
248+
* good, so it is offered no features even should the process start later
249+
* (when asked again, e.g. once its environment can be built).
250+
* </p>
251+
*/
252+
private static ServerCapabilities fallback() {
253+
return new ServerCapabilities();
254+
}
255+
219256
/**
220257
* Asks the process, with the document's current text.
221258
*

‎scijava-code-lsp/src/main/java/org/scijava/code/lsp/server/ServerProcess.java‎

Lines changed: 20 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -50,13 +50,15 @@
5050
import org.eclipse.lsp4j.DidOpenTextDocumentParams;
5151
import org.eclipse.lsp4j.HoverCapabilities;
5252
import org.eclipse.lsp4j.InitializeParams;
53+
import org.eclipse.lsp4j.InitializeResult;
5354
import org.eclipse.lsp4j.InitializedParams;
5455
import org.eclipse.lsp4j.MarkupKind;
5556
import org.eclipse.lsp4j.MessageActionItem;
5657
import org.eclipse.lsp4j.MessageParams;
5758
import org.eclipse.lsp4j.MessageType;
5859
import org.eclipse.lsp4j.PublishDiagnosticsCapabilities;
5960
import org.eclipse.lsp4j.PublishDiagnosticsParams;
61+
import org.eclipse.lsp4j.ServerCapabilities;
6062
import org.eclipse.lsp4j.ShowMessageRequestParams;
6163
import org.eclipse.lsp4j.SignatureHelpCapabilities;
6264
import org.eclipse.lsp4j.SignatureInformationCapabilities;
@@ -95,6 +97,9 @@ final class ServerProcess {
9597
private final LanguageServer remote;
9698
private final Future<Void> listening;
9799

100+
/** What the server said it can do, when initialized. */
101+
private final ServerCapabilities capabilities;
102+
98103
/** Open documents' versions and texts, by URI. */
99104
private final Map<String, Document> documents = new HashMap<>();
100105

@@ -105,13 +110,14 @@ final class ServerProcess {
105110

106111
private ServerProcess(final String language, final Process process,
107112
final LanguageServer remote, final Future<Void> listening,
108-
final Published published)
113+
final Published published, final ServerCapabilities capabilities)
109114
{
110115
this.language = language;
111116
this.published = published;
112117
this.process = process;
113118
this.remote = remote;
114119
this.listening = listening;
120+
this.capabilities = capabilities;
115121
}
116122

117123
/**
@@ -138,18 +144,22 @@ static ServerProcess start(final ServerLauncher launcher,
138144
final InitializeParams init = new InitializeParams();
139145
init.setProcessId((int) ProcessHandle.current().pid());
140146
init.setClientInfo(new org.eclipse.lsp4j.ClientInfo("SciJava"));
141-
init.setCapabilities(capabilities());
147+
init.setCapabilities(clientCapabilities());
142148
final String root = launcher.rootUri(env);
143149
if (root != null) {
144150
init.setRootUri(root);
145151
init.setWorkspaceFolders(Collections.singletonList(new WorkspaceFolder(
146152
root, "scripts")));
147153
}
148154
init.setInitializationOptions(launcher.initializationOptions(env));
149-
remote.initialize(init).get(timeout, TimeUnit.MILLISECONDS);
155+
final InitializeResult result = remote.initialize(init).get(timeout,
156+
TimeUnit.MILLISECONDS);
150157
remote.initialized(new InitializedParams());
158+
final ServerCapabilities capabilities = result == null || result
159+
.getCapabilities() == null ? new ServerCapabilities() : result
160+
.getCapabilities();
151161
return new ServerProcess(launcher.language(), process, remote, listening,
152-
published);
162+
published, capabilities);
153163
}
154164
catch (final Exception exc) {
155165
destroy(process);
@@ -207,6 +217,11 @@ public LanguageServer remote() {
207217
return remote;
208218
}
209219

220+
/** What the server said it can do, when initialized. */
221+
public ServerCapabilities capabilities() {
222+
return capabilities;
223+
}
224+
210225
/** Whether the server still runs. */
211226
public boolean isAlive() {
212227
return process.isAlive() && !listening.isDone();
@@ -267,7 +282,7 @@ private boolean sync(final String uri, final String text) {
267282
}
268283

269284
/** What this client can do: plain text documentation, no snippets. */
270-
private static ClientCapabilities capabilities() {
285+
private static ClientCapabilities clientCapabilities() {
271286
final CompletionItemCapabilities item = new CompletionItemCapabilities(
272287
false);
273288
item.setDocumentationFormat(Collections.singletonList(

‎scijava-code-lsp/src/test/java/org/scijava/code/lsp/server/AbstractProcessLanguageServerPluginTest.java‎

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,9 @@
3838
import static org.scijava.code.lsp.server.FakeServers.waitFor;
3939

4040
import java.util.List;
41+
import java.util.concurrent.TimeUnit;
4142

43+
import org.eclipse.lsp4j.InitializeParams;
4244
import org.junit.jupiter.api.AfterEach;
4345
import org.junit.jupiter.api.BeforeEach;
4446
import org.junit.jupiter.api.Test;
@@ -86,18 +88,15 @@ public void testSupports() {
8688
}
8789

8890
/**
89-
* Tests that a process is not started when a server is created, only once
90-
* the server is used.
91+
* Tests that a process is not started when a server is created, but once
92+
* the server is initialized.
9193
*/
9294
@Test
93-
public void testLazyStart() throws Exception {
95+
public void testStartOnInitialize() throws Exception {
9496
final ProcessLanguageServer s = (ProcessLanguageServer) plugin.create(
9597
"python", ENV);
9698
assertEquals(0, started.size());
97-
// Using it starts it
98-
final String uri = "untitled:/p.py";
99-
open(s, uri, "x");
100-
assertEquals(3, complete(s, uri).size());
99+
s.initialize(new InitializeParams()).get(10, TimeUnit.SECONDS);
101100
assertEquals(1, started.size());
102101
}
103102

‎scijava-code-lsp/src/test/java/org/scijava/code/lsp/server/FakeServers.java‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,7 @@
5858
import org.eclipse.lsp4j.InitializeResult;
5959
import org.eclipse.lsp4j.Position;
6060
import org.eclipse.lsp4j.ServerCapabilities;
61+
import org.eclipse.lsp4j.TextDocumentSyncKind;
6162
import org.eclipse.lsp4j.jsonrpc.messages.Either;
6263
import org.eclipse.lsp4j.launch.LSPLauncher;
6364
import org.eclipse.lsp4j.services.LanguageServer;
@@ -208,8 +209,12 @@ static final class Server implements LanguageServer, TextDocumentService,
208209
public CompletableFuture<InitializeResult> initialize(
209210
final InitializeParams params)
210211
{
212+
// NB: Completion (resolved), but no hover or signature help; and what
213+
// a proxy cannot pass on: incremental changes, and definitions.
211214
final ServerCapabilities capabilities = new ServerCapabilities();
212215
capabilities.setCompletionProvider(new CompletionOptions(true, null));
216+
capabilities.setTextDocumentSync(TextDocumentSyncKind.Incremental);
217+
capabilities.setDefinitionProvider(true);
213218
return CompletableFuture.completedFuture(new InitializeResult(
214219
capabilities));
215220
}

‎scijava-code-lsp/src/test/java/org/scijava/code/lsp/server/ProcessLanguageServerTest.java‎

Lines changed: 61 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -31,27 +31,35 @@
3131

3232
import static org.junit.jupiter.api.Assertions.assertEquals;
3333
import static org.junit.jupiter.api.Assertions.assertFalse;
34+
import static org.junit.jupiter.api.Assertions.assertNull;
35+
import static org.junit.jupiter.api.Assertions.assertTrue;
3436
import static org.scijava.code.lsp.server.FakeServers.ENV;
3537
import static org.scijava.code.lsp.server.FakeServers.complete;
3638
import static org.scijava.code.lsp.server.FakeServers.open;
3739
import static org.scijava.code.lsp.server.FakeServers.waitFor;
3840

41+
import java.io.IOException;
3942
import java.util.Arrays;
4043
import java.util.Collections;
4144
import java.util.List;
4245
import java.util.concurrent.CompletableFuture;
4346
import java.util.concurrent.CopyOnWriteArrayList;
47+
import java.util.concurrent.TimeUnit;
4448

4549
import org.eclipse.lsp4j.DidCloseTextDocumentParams;
50+
import org.eclipse.lsp4j.InitializeParams;
4651
import org.eclipse.lsp4j.MessageActionItem;
4752
import org.eclipse.lsp4j.MessageParams;
4853
import org.eclipse.lsp4j.PublishDiagnosticsParams;
54+
import org.eclipse.lsp4j.ServerCapabilities;
4955
import org.eclipse.lsp4j.ShowMessageRequestParams;
5056
import org.eclipse.lsp4j.TextDocumentIdentifier;
57+
import org.eclipse.lsp4j.TextDocumentSyncKind;
5158
import org.eclipse.lsp4j.services.LanguageClient;
5259
import org.junit.jupiter.api.AfterEach;
5360
import org.junit.jupiter.api.BeforeEach;
5461
import org.junit.jupiter.api.Test;
62+
import org.scijava.code.lsp.Environment;
5563
import org.scijava.log.StderrLogService;
5664

5765
/**
@@ -145,6 +153,59 @@ public void testCloseOwnOnly() throws Exception {
145153
assertFalse(started.get(1).events.contains("close " + uri));
146154
}
147155

156+
/**
157+
* Tests that initializing the server says what its process can do, as far
158+
* as passed on: those of its features passed on, as it said; and documents
159+
* synchronized by their whole text, whatever it said.
160+
*/
161+
@Test
162+
public void testCapabilities() throws Exception {
163+
final ProcessLanguageServer s = (ProcessLanguageServer) servers.server(
164+
ENV);
165+
final ServerCapabilities c = s.initialize(new InitializeParams()).get(10,
166+
TimeUnit.SECONDS).getCapabilities();
167+
// NB: The fake server completes (resolving completions), but has no
168+
// hover or signature help...
169+
assertTrue(c.getCompletionProvider().getResolveProvider());
170+
assertNull(c.getHoverProvider());
171+
assertNull(c.getSignatureHelpProvider());
172+
// ...and its definitions and incremental changes are not passed on.
173+
assertNull(c.getDefinitionProvider());
174+
assertEquals(TextDocumentSyncKind.Full, c.getTextDocumentSync()
175+
.getLeft());
176+
}
177+
178+
/**
179+
* Tests that initializing a server whose process cannot start says it can
180+
* do nothing, but still syncs documents by their whole text.
181+
*/
182+
@Test
183+
public void testFallbackCapabilities() throws Exception {
184+
final ServerProcesses failing = new ServerProcesses(
185+
new FakeServers.Launcher()
186+
{
187+
188+
@Override
189+
public Process start(final Environment env) throws IOException {
190+
throw new IOException("No such server");
191+
}
192+
}, new StderrLogService(), 60_000, 2, System::currentTimeMillis);
193+
try {
194+
final ProcessLanguageServer s = (ProcessLanguageServer) failing.server(
195+
ENV);
196+
final ServerCapabilities c = s.initialize(new InitializeParams()).get(
197+
10, TimeUnit.SECONDS).getCapabilities();
198+
assertNull(c.getCompletionProvider());
199+
assertNull(c.getHoverProvider());
200+
assertNull(c.getSignatureHelpProvider());
201+
assertEquals(TextDocumentSyncKind.Full, c.getTextDocumentSync()
202+
.getLeft());
203+
}
204+
finally {
205+
failing.shutdown();
206+
}
207+
}
208+
148209
// -- Helper methods --
149210

150211
/**

‎scijava-code-lsp/src/test/java/org/scijava/code/lsp/server/ServerProcessesTest.java‎

Lines changed: 25 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -151,34 +151,40 @@ public void testStaleSlotReplaced() throws Exception {
151151
public void testRetry() throws Exception {
152152
// Create a ServerProcesses whose starts always fail, counting the tries
153153
final AtomicLong tries = new AtomicLong();
154-
servers = new ServerProcesses(new FakeServers.Launcher() {
154+
final ServerProcesses failing = new ServerProcesses(
155+
new FakeServers.Launcher()
156+
{
155157

156158
@Override
157159
public Process start(final Environment env) throws IOException {
158160
tries.incrementAndGet();
159161
throw new IOException("No such server");
160162
}
161163
}, new StderrLogService(), 60_000, 2, now::get);
164+
try {
165+
// Ask for a ServerProcess, get a failure
166+
final ServerProcesses.Slot slot = failing.slot(ENV);
167+
final CompletableFuture<ServerProcess> failed = slot.process();
168+
assertThrows(ExecutionException.class, () -> failed.get(10,
169+
TimeUnit.SECONDS));
170+
assertEquals(1, tries.get());
162171

163-
// Ask for a ServerProcess, get a failure
164-
final ServerProcesses.Slot slot = servers.slot(ENV);
165-
final CompletableFuture<ServerProcess> failed = slot.process();
166-
assertThrows(ExecutionException.class, () -> failed.get(10,
167-
TimeUnit.SECONDS));
168-
assertEquals(1, tries.get());
169-
170-
// Ask again, get another failure...
171-
assertSame(failed, slot.process());
172-
// ...but make sure we didn't actually try.
173-
assertEquals(1, tries.get());
172+
// Ask again, get another failure...
173+
assertSame(failed, slot.process());
174+
// ...but make sure we didn't actually try.
175+
assertEquals(1, tries.get());
174176

175-
// After waiting for the retry delay...
176-
now.addAndGet(60_000);
177-
// ...try again...
178-
assertThrows(ExecutionException.class, () -> slot.process().get(10,
179-
TimeUnit.SECONDS));
180-
// ...and we should see another try
181-
assertEquals(2, tries.get());
177+
// After waiting for the retry delay...
178+
now.addAndGet(60_000);
179+
// ...try again...
180+
assertThrows(ExecutionException.class, () -> slot.process().get(10,
181+
TimeUnit.SECONDS));
182+
// ...and we should see another try
183+
assertEquals(2, tries.get());
184+
}
185+
finally {
186+
failing.shutdown();
187+
}
182188
}
183189

184190
/**

0 commit comments

Comments
 (0)