Can a service to search/find an annotation be the same using a Proxy or Client/Server ?

[cmoulliard]

I created a simple project where it is possible to launch the LSP server using either the "proxy" approach (1) - see code here

            // Create and start server
            JavaLanguageServer server = new JavaLanguageServer();
            Launcher<org.eclipse.lsp4j.services.LanguageServer> serverLauncher = new LSPLauncher.Builder<org.eclipse.lsp4j.services.LanguageServer>()
                .setLocalService(server)
                .setRemoteInterface(org.eclipse.lsp4j.services.LanguageServer.class)
                .setInput(serverIn)
                .setOutput(serverOut)
                .setExecutorService(executor)
                .create();
            
            serverLauncher.startListening();
            
            // Create client
            LspClient client = new LspClient();
            Launcher<org.eclipse.lsp4j.services.LanguageServer> clientLauncher = new LSPLauncher.Builder<org.eclipse.lsp4j.services.LanguageServer>()
                .setLocalService(client)
                .setRemoteInterface(org.eclipse.lsp4j.services.LanguageServer.class)
                .setInput(clientIn)
                .setOutput(clientOut)
                .setExecutorService(executor)
                .create();

or the LSP server (2) is started as a Java process and exposed behind a socket -

        ProcessBuilder pb = new ProcessBuilder(
            "java",
            "-Declipse.application=org.eclipse.jdt.ls.core.id1",
            "-Dosgi.bundles.defaultStartLevel=4",
            "-Declipse.product=org.eclipse.jdt.ls.core.product",
            "-Dlog.level=ALL",
            "-Djdt.ls.debug=true",
            "-noverify",
            "-Xmx1G",
            "--add-modules=ALL-SYSTEM",
            "--add-opens", "java.base/java.util=ALL-UNNAMED",
            "--add-opens", "java.base/java.lang=ALL-UNNAMED",
            "-jar", Paths.get(JDT_LS_PATH, "plugins", launcherJar).toString(),
            "-configuration", configPath.toString(),
            "-data", wksDir.resolve(".jdt_workspace").toString()
        );
...

To perform an annotation search, I execute a command with approach (1)

ExecuteCommandParams commandParams = new ExecuteCommandParams(
            "java/findAnnotatedClasses",
            Collections.singletonList(annotationToFind)
        );

        CompletableFuture<Object> commandResult = lspConnection.getServerProxy().getWorkspaceService().executeCommand(commandParams);
        Object result = commandResult.get();

but do a workspace symbol and text search for approach (2) - code

        WorkspaceSymbolParams symbolParams = new WorkspaceSymbolParams(annotationName);
        
        return languageServer.getWorkspaceService().symbol(symbolParams)

Can (1) and (2) use the same code to the search or some limitations exist which prevents to do that ?

[mickaelistria]

Do I get it right that what you want is to

• create your own Language Server ( myServerLauncher.startListening() ), which
• starts the JDT-LS ( jdtLanguageServer.startListening() ), and
• proxy it, by creating a client ( clientLauncher.startListening() ) and using it to implement myServerLauncher ?

If so, it's very possible to have it all in the same bit of code but making sure that

• different streams/ports are used for your 2 language servers to avoid data from different execution domains from colliding in the client streams, and
• maybe ensuring you're using passing different ExecutorService to setExecutorService when creating the launcher to avoid potential deadlocks

However, in that particular case, I would recommend that instead of creating a proxy LS delegating to JDT-LS, you consider creating an extension/plugin to JDT-LS to hook your extra command in it. The eclipse-jdt/eclipse.jdt.ls repo is where that particular approach
can be documented/discussed

HTH

[cmoulliard]

• create your own Language Server ( myServerLauncher.startListening() ), which

• starts the JDT-LS ( jdtLanguageServer.startListening() ), and

• proxy it, by creating a client ( clientLauncher.startListening() ) and using it to implement myServerLauncher ?

I did 2 separate things:

• Created a Java main application able to create using LanguageServer a serverLauncher and client launcher. No jdt-ls binary is then used here and we perform the search (= to find a java annotation) by executing the command getServerProxy().getWorkspaceService().executeCommand(commandParams);
• Created another Java main application where the server is started using (= java -jar ... launcherJar) and can be accessed from socket port 3333. When the client starts and access the server, then it will use .getWorkspaceService().symbol(symbolParams) to find an annotation like .getTextDocumentService().references(params); to find using textReferences java files

[mickaelistria]

OK, I think I understand it.
The exact same client code can be used to interact with the language server, whether it is started as a process and bound through socket, or started in the same process using in memory Piped*Streams. The only difference is the stream that you should pass to the Builder depending on how you choose to start/connect to the LS.
It looks like you could simply override/tweak the new JavaLanguageServer() instance you create along with your server to add support for your custom operation without need to proxy anything.