how to make a implement a Language client using lsp4j

[subham008]

i have a language server running , so now how could i implement a Language client whihc will connect with that running language server , i read documentation but its incomplete for Language client .

Any help will be appreciated, Thank you

[pisv]

Depending on your needs, you could use either LSP4E or LXTK for this.

[subham008]

LSP4E is specially support Eclipse ide , am not working for Eclipse , am developing a IDE in Java just for learning , so i want LSP implementation in java and that is LSP4J

[pisv]

Basically, you need to implement the LanguageClient interface in LSP4J. However, it is not that simple as it may sound. That's why special language client frameworks such as LXTK have been created on top of LSP4J. Even if you prefer not to use them, I'd suggest taking a look at their code as an example, especially if your goal is learning.

[pisv]

I can also recommend this article as an introduction to the core concepts of LSP4J.

[subham008]

hey tried every thing its a pain I tried LSP4E and LXTKA too but i didnt achieve anything , can you please write a just to implment a client which wil get diagnostic , code completions , and get Documentation on hover , please help me in this

i am not using LSP43 or LXTK , am only using LSP4J now
here is my present code which is not working i dont know why :

public class client {

    public static void start()  {


        // Start the typescript-language-server as a subprocess
        ProcessBuilder processBuilder = new ProcessBuilder("typescript-language-server.cmd", "--stdio","--log-level=4" );
        processBuilder.redirectErrorStream(true);
        Process serverProcess = null;
        try {
            serverProcess = processBuilder.start();
            System.out.println("Server started");
        } catch (IOException exception) {
            System.err.println("Failed to create process :" + exception);
            System.exit(1);
        }


        // Obtain InputStream and OutputStream from the server process
        InputStream serverInput = serverProcess.getInputStream();
        OutputStream serverOutput = serverProcess.getOutputStream();

        LanguageClientImpl languageClient = new LanguageClientImpl();

        //  a launcher for the LSP client
        Launcher<LanguageServer> launcher = Launcher.createLauncher(languageClient, LanguageServer.class,serverInput,serverOutput);
        LanguageServer server = launcher.getRemoteProxy();
        launcher.startListening();

        InitializeParams params = new InitializeParams();
        List<WorkspaceFolder> folders = new ArrayList<>();
        folders.add(new WorkspaceFolder("file:///E:/languaug_server/LSP4jClient/app/src/main","resources"));
        params.setWorkspaceFolders(folders);
        params.setCapabilities(new ClientCapabilities());

        CompletableFuture<InitializeResult> initialized = server.initialize(params);

          

        try{

            initialized.get();
          // System.out.println("params initialized wait passed");
            // Open the document
            String fileUri = Paths.get("E:/languaug_server/LSP4jClient/app/src/main/resources/sample.ts").toAbsolutePath().toUri().toString();

            DidOpenTextDocumentParams openParams = new DidOpenTextDocumentParams();
            TextDocumentItem textDocumentItem = new TextDocumentItem(fileUri, "typescript", 1, "const num1 = 10;\n" +
                    "const num2 = 5;\n" +
                    "\n" +
                    "console.log(`${num1} + ${num2} = ${calculator.add(num1, num2)}`);\n" +
                "console.log(`${num1} - ${num2} = ${calculator.subtract(num1, num2)}`);\n" +
                    "console.log(`${num1} * ${num2} = ${calculator.multiply(num1, num2)}`);\n" +
                    "console.log(`${num1} / ${num2} = ${calculator.divide(num1, num2)}`);");
            openParams.setTextDocument(textDocumentItem);
        server.getTextDocumentService().didOpen(openParams);


     

            // Request diagnostics
            CompletableFuture<List<Diagnostic>> diagnosticsFuture = new CompletableFuture<>();
            languageClient.setDiagnosticsConsumer(diagnostics -> {
                System.out.println("Received diagnostics: " + diagnostics);
                diagnosticsFuture.complete(diagnostics);
            });



            // Wait for diagnostics
            List<Diagnostic> diagnostics = diagnosticsFuture.get();

          
            // Print diagnostics
            System.out.println("Diagnostics for " + fileUri + ":");
            for (Diagnostic diagnostic : diagnostics) {
                System.out.println(diagnostic.getSeverity() + ": " + diagnostic.getMessage() + " at " + diagnostic.getRange());
            }


        }catch (Exception e){
            System.out.println("Linting error :" + e.toString());

        }


        serverProcess.destroy();
    }// end of start

    private static class LanguageClientImpl implements LanguageClient, LanguageClientAware {
        private Consumer<List<Diagnostic>> diagnosticsConsumer;

        public void setDiagnosticsConsumer(Consumer<List<Diagnostic>> consumer) {
            this.diagnosticsConsumer = consumer;
        }

        @Override
        public void publishDiagnostics(PublishDiagnosticsParams diagnostics) {
            System.out.println("Diagnostics received: " + diagnostics.getDiagnostics().size() + " diagnostics");
            if (diagnosticsConsumer != null) {
                diagnosticsConsumer.accept(diagnostics.getDiagnostics());
            }
        }

        @Override
        public void telemetryEvent(Object object) {
              System.out.println("telemetry called:"+object.toString());
        }

        @Override
        public void showMessage(MessageParams messageParams) {
            System.out.println("Message received: " + messageParams.getMessage());
        }

        @Override
        public void logMessage(MessageParams messageParams) {
            System.out.println("Log received: " + messageParams.getMessage());
        }

        @Override
        public CompletableFuture<MessageActionItem> showMessageRequest(ShowMessageRequestParams requestParams) {
            System.out.println("showMessageRequest called:"+requestParams.getMessage());
           // throw new UnsupportedOperationException("Unimplemented method 'showMessageRequest'");
            return null;
        }

        @Override
        public void connect(LanguageClient client) {
            System.out.println("connect called");
        }
    }

}

[cmoulliard]

I created a project which is working where the jdt-ls server is launched and client can access it using a SOCKET 3333
https://github.com/ch007m/my-lsp4j

Remark: I will polish the code to start the server within the same JVM as the client as exposing it with a SOCKET for test/demo don't make sense

[cmoulliard]

I created a new class to test the approcah where the jdt-ls server is started as a process part of the java class and that works

import dev.snowdrop.lsp.common.utils.LSClient;
import dev.snowdrop.lsp.model.LSPSymbolInfo;
import org.eclipse.lsp4j.*;
import org.eclipse.lsp4j.jsonrpc.Launcher;
import org.eclipse.lsp4j.launch.LSPLauncher;
import org.eclipse.lsp4j.services.LanguageServer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import static dev.snowdrop.lsp.common.services.LsSearchService.executeCmd;
import static dev.snowdrop.lsp.common.utils.FileUtils.getExampleDir;

public class JdtlsSocketClient {

    private static final Logger logger = LoggerFactory.getLogger(JdtlsSocketClient.class);
    private static final int SERVER_PORT = 3333;
    private static final long TIMEOUT = 2000;

    public static void main(String[] args) throws Exception {
        Launcher<LanguageServer> launcher;
        ExecutorService executor;

        logger.info("Connecting to the JDT Language Server on port {}...", SERVER_PORT);

        try (ServerSocket serverSocket = new ServerSocket(SERVER_PORT)) {
            Socket socket = serverSocket.accept();
            executor = Executors.newSingleThreadExecutor();
            LSClient client = new LSClient();

            launcher = LSPLauncher.createClientLauncher(
                client,
                socket.getInputStream(),
                socket.getOutputStream(),
                executor,
                (writer) -> writer // No-op, we don't want to wrap the writer
            );
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        launcher.startListening();

        LanguageServer remoteProxy = launcher.getRemoteProxy();

        InitializeParams p = new InitializeParams();
        p.setProcessId((int) ProcessHandle.current().pid());
        p.setRootUri(getExampleDir().toUri().toString());
        p.setCapabilities(new ClientCapabilities());

        CompletableFuture<InitializeResult> future = remoteProxy.initialize(p);
        future.get(TIMEOUT, TimeUnit.MILLISECONDS).toString();

        InitializedParams initialized = new InitializedParams();
        remoteProxy.initialized(initialized);


        String annotationToFind = "MySearchableAnnotation";
        //logger.info("CLIENT: Sending custom command '{}' to find '@{}'...", customCmd, annotationToFind);

        // Send by example the command java.project.getAll to the jdt-ls as it supports it
        String customCmd = Optional.ofNullable(System.getenv("LS_CMD")).orElse("java.project.getAll");
        logger.info("CLIENT: Sending custom command '{}' ...", customCmd);

        future
            .thenRunAsync(() -> {
                executeCmd(customCmd, null, remoteProxy);
            })
            .exceptionally(
                t -> {
                    t.printStackTrace();
                    return null;
                }
            );
    }

    /**
     * Search about the annotation
     *
     * @param server                 The proxy to the language server.
     * @param projectRoot            The root directory of the project to be analyzed.
     * @param mySearchableAnnotation
     * @return A CompletableFuture that completes when the entire sequence is finished.
     */
    private static CompletableFuture<List<LSPSymbolInfo>> searchAnnotation(LanguageServer server, Path projectRoot, String mySearchableAnnotation) {
        logger.info("CLIENT: Starting search for @{} annotation...", mySearchableAnnotation);

        if (server == null) {
            logger.error("No LanguageServer available, skipping LSP discovery");
            return CompletableFuture.completedFuture(null);
        }

        return server.getWorkspaceService().symbol(new WorkspaceSymbolParams(mySearchableAnnotation))
            .thenApplyAsync(eitherResult -> {
                List<LSPSymbolInfo> lspSymbols = new ArrayList<>();

                if (eitherResult.isLeft()) {
                    List<? extends SymbolInformation> symbols = eitherResult.getLeft();
                    for (SymbolInformation symbol : symbols) {
                        lspSymbols.add(new LSPSymbolInfo(
                            symbol.getName(),
                            symbol.getLocation().getUri(),
                            symbol.getKind(),
                            symbol.getLocation()
                        ));
                    }
                } else {
                    List<? extends WorkspaceSymbol> symbols = eitherResult.getRight();
                    for (WorkspaceSymbol symbol : symbols) {
                        if (symbol.getLocation().isLeft()) {
                            Location location = symbol.getLocation().getLeft();
                            lspSymbols.add(new LSPSymbolInfo(
                                symbol.getName(),
                                location.getUri(),
                                symbol.getKind(),
                                location
                            ));
                        }
                    }
                }

                logger.info("LSP workspace/symbol found {} symbols for '{}'", lspSymbols.size(), mySearchableAnnotation);
                return lspSymbols;
            });
    }
}