[POM-leading for DSLs] Routing to dedicated remote language servers

rascal-lsp/.vscode/launch.json

@@ -26,6 +26,47 @@
         "-Drascal.compilerClasspath=${workspaceFolder}/target/lib/rascal.jar",
         "-Drascal.fallbackResolver=org.rascalmpl.vscode.lsp.uri.FallbackResolver"
       ]
+    },
+    {
+      "type": "java",
+      "name": "Parametric Routing Server",
+      "request": "launch",
+      "mainClass": "org.rascalmpl.vscode.lsp.parametric.routing.RoutingLanguageServer",
+      "projectName": "rascal-lsp",
+      "console": "internalConsole",
+      "vmArgs": [
+        "-Dlog4j2.level=TRACE",
+        "-Drascal.compilerClasspath=${workspaceFolder}/target/lib/rascal.jar",
+        "-Drascal.fallbackResolver=org.rascalmpl.vscode.lsp.uri.FallbackResolver"
+      ]
+    },
+    {
+      "type": "java",
+      "name": "Delegate Parametric Server [1]",
+      "request": "launch",
+      "mainClass": "org.rascalmpl.vscode.lsp.parametric.ParametricLanguageServer",
+      "args": ["--port", "9990"],
+      "projectName": "rascal-lsp",
+      "console": "internalConsole",
+      "vmArgs": [
+        "-Dlog4j2.level=TRACE",
+        "-Drascal.compilerClasspath=${workspaceFolder}/target/lib/rascal.jar",
+        "-Drascal.fallbackResolver=org.rascalmpl.vscode.lsp.uri.FallbackResolver"
+      ]
+    },
+    {
+      "type": "java",
+      "name": "Delegate Parametric Server [2]",
+      "request": "launch",
+      "mainClass": "org.rascalmpl.vscode.lsp.parametric.ParametricLanguageServer",
+      "args": ["--port", "9991"],
+      "projectName": "rascal-lsp",
+      "console": "internalConsole",
+      "vmArgs": [
+        "-Dlog4j2.level=TRACE",
+        "-Drascal.compilerClasspath=${workspaceFolder}/target/lib/rascal.jar",
+        "-Drascal.fallbackResolver=org.rascalmpl.vscode.lsp.uri.FallbackResolver"
+      ]
     }
   ]
 }

rascal-lsp/src/main/checkerframework/jdk.astub

@@ -69,3 +69,23 @@ public interface Map<K, V> {
             K key,
             BiFunction<? super K, ? super @Nullable V, ? extends @Nullable V> remappingFunction) {}
 }
+
+package java.util.concurrent;
+
+import org.checkerframework.checker.nullness.qual.*;
+
+public interface ConcurrentHashMap<K, V> {
+    // Since ConcurrentHashMap does not permit null values, compute functions can only return `null` if the compute function returns null
+
+    public @PolyNull V compute(
+            K key,
+            BiFunction<? super K, ? super @Nullable V, ? extends @PolyNull V> remappingFunction) {}
+
+    public @PolyNull V computeIfAbsent(
+            K key,
+            Function<? super K, ? extends @PolyNull V> computeFunction) {}
+
+    public @PolyNull V computeIfPresent(
+            K key,
+            BiFunction<? super K, ? super V, ? extends @PolyNull V> remappingFunction) {}
+}

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/BaseLanguageServer.java

@@ -82,7 +82,7 @@
 public abstract class BaseLanguageServer {
     private static final PrintStream capturedOut;
     private static final InputStream capturedIn;
-    private static final boolean DEPLOY_MODE;
+    public static final boolean DEPLOY_MODE;
     private static final String LOG_CONFIGURATION_KEY = "log4j2.configurationFactory";
 
     static {
@@ -108,13 +108,13 @@ protected BaseLanguageServer() {}
 
     private static final Logger logger = LogManager.getLogger(BaseLanguageServer.class);
 
-    private static Launcher<IBaseLanguageClient> constructLSPClient(Socket client, ActualLanguageServer server, ExecutorService threadPool)
+    protected static Launcher<IBaseLanguageClient> constructLSPClient(Socket client, ActualLanguageServer server, ExecutorService threadPool)
         throws IOException {
         client.setTcpNoDelay(true);
         return constructLSPClient(client.getInputStream(), client.getOutputStream(), server, threadPool);
     }
 
-    private static Launcher<IBaseLanguageClient> constructLSPClient(InputStream in, OutputStream out, ActualLanguageServer server, ExecutorService threadPool) {
+    protected static Launcher<IBaseLanguageClient> constructLSPClient(InputStream in, OutputStream out, ActualLanguageServer server, ExecutorService threadPool) {
         Launcher<IBaseLanguageClient> clientLauncher = new Launcher.Builder<IBaseLanguageClient>()
             .setLocalService(server)
             .setRemoteInterface(IBaseLanguageClient.class)
@@ -129,12 +129,21 @@ private static Launcher<IBaseLanguageClient> constructLSPClient(InputStream in,
         return clientLauncher;
     }
 
-    private static void printClassPath() {
+    protected static void printClassPath() {
         logger.trace("Started with classpath: {}", () -> System.getProperty("java.class.path"));
     }
 
+    @FunctionalInterface
+    protected interface ServerBuilder {
+        ActualLanguageServer apply(Runnable a, ExecutorService b, IBaseTextDocumentService c, BaseWorkspaceService d);
+    }
+
+    protected static void startLanguageServer(String requestPoolName, String workerPoolName, Function<ExecutorService, IBaseTextDocumentService> docServiceProvider, Function<ExecutorService, BaseWorkspaceService> workspaceServiceProvider, int portNumber) {
+        startLanguageServer(ActualLanguageServer::new, requestPoolName, workerPoolName, docServiceProvider, workspaceServiceProvider, portNumber);
+    }
+
     @SuppressWarnings({"java:S2189", "java:S106"})
-    public static void startLanguageServer(String requestPoolName, String workerPoolName, Function<ExecutorService, IBaseTextDocumentService> docServiceProvider, Function<ExecutorService, BaseWorkspaceService> workspaceServiceProvider, int portNumber) {
+    protected static void startLanguageServer(ServerBuilder serverBuilder, String requestPoolName, String workerPoolName, Function<ExecutorService, IBaseTextDocumentService> docServiceProvider, Function<ExecutorService, BaseWorkspaceService> workspaceServiceProvider, int portNumber) {
         logger.info("Starting Rascal Language Server: {}", getVersion());
         printClassPath();
 
@@ -145,9 +154,7 @@ public static void startLanguageServer(String requestPoolName, String workerPool
             try {
                 var docService = docServiceProvider.apply(workerPool);
                 var wsService = workspaceServiceProvider.apply(workerPool);
-                docService.pair(wsService);
-                wsService.pair(docService);
-                startLSP(constructLSPClient(capturedIn, capturedOut, new ActualLanguageServer(() -> System.exit(0), workerPool, docService, wsService), requestPool));
+                startLSP(constructLSPClient(capturedIn, capturedOut, serverBuilder.apply(() -> System.exit(0), workerPool, docService, wsService), requestPool));
             } finally {
                 requestPool.shutdown();
                 workerPool.shutdown();
@@ -164,9 +171,7 @@ public static void startLanguageServer(String requestPoolName, String workerPool
                         logger.info("New client connected to Rascal LSP server (listening on port number: {})", portNumber);
                         var docService = docServiceProvider.apply(workerPool);
                         var wsService = workspaceServiceProvider.apply(workerPool);
-                        docService.pair(wsService);
-                        wsService.pair(docService);
-                        startLSP(constructLSPClient(clientSocket, new ActualLanguageServer(() -> {}, workerPool, docService, wsService), requestPool));
+                        startLSP(constructLSPClient(clientSocket, serverBuilder.apply(() -> {}, workerPool, docService, wsService), requestPool));
                     }
                     finally {
                         requestPool.shutdown();
@@ -181,7 +186,7 @@ public static void startLanguageServer(String requestPoolName, String workerPool
 
     private static final String DEFAULT_VERSION = "unknown";
 
-    private static String getVersion() {
+    protected static String getVersion() {
         try (InputStream prop =  ActualLanguageServer.class.getClassLoader().getResourceAsStream("project.properties")) {
             if (prop == null) {
                 logger.error("Could not find project.properties file");
@@ -198,7 +203,7 @@ private static String getVersion() {
         }
     }
 
-    private static void startLSP(Launcher<IBaseLanguageClient> server) {
+    protected static void startLSP(Launcher<IBaseLanguageClient> server) {
         try {
             server.startListening().get();
         } catch (InterruptedException e) {
@@ -216,19 +221,23 @@ private static void startLSP(Launcher<IBaseLanguageClient> server) {
             }
         }
     }
-    private static class ActualLanguageServer implements IBaseLanguageServerExtensions, LanguageClientAware {
+    public static class ActualLanguageServer implements IBaseLanguageServerExtensions, LanguageClientAware {
         static final Logger logger = LogManager.getLogger(ActualLanguageServer.class);
         private final IBaseTextDocumentService lspDocumentService;
         private final BaseWorkspaceService lspWorkspaceService;
         private final Runnable onExit;
         private final ExecutorService executor;
+
         private @MonotonicNonNull IDEServicesConfiguration remoteIDEServicesConfiguration;
+        private @MonotonicNonNull IBaseLanguageClient client;
 
-        private ActualLanguageServer(Runnable onExit, ExecutorService executor, IBaseTextDocumentService lspDocumentService, BaseWorkspaceService lspWorkspaceService) {
+        protected ActualLanguageServer(Runnable onExit, ExecutorService executor, IBaseTextDocumentService lspDocumentService, BaseWorkspaceService lspWorkspaceService) {
             this.onExit = onExit;
             this.executor = executor;
             this.lspDocumentService = lspDocumentService;
             this.lspWorkspaceService = lspWorkspaceService;
+            lspDocumentService.pair(lspWorkspaceService);
+            lspWorkspaceService.pair(lspDocumentService);
         }
 
         @Override
@@ -266,15 +275,20 @@ public CompletableFuture<Two<String, URI[]>[]> supplyPathConfig(PathConfigParame
 
         @Override
         public CompletableFuture<Void> sendRegisterLanguage(LanguageParameter lang) {
+            logger.debug("rascal/sendRegisterLanguage({}, {})", lang.getName(), lang.getMainFunction());
             return CompletableFuture.runAsync(() -> lspDocumentService.registerLanguage(lang), executor);
         }
         @Override
         public CompletableFuture<Void> sendUnregisterLanguage(LanguageParameter lang) {
+            logger.debug("rascal/sendUnregisterLanguage({})", lang.getName());
             return CompletableFuture.runAsync(() -> lspDocumentService.unregisterLanguage(lang), executor);
         }
 
         @Override
         public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
+            // Exit when our parent process exits
+            executor.submit(() -> ProcessHandle.of(params.getProcessId()).ifPresent(p -> p.onExit().thenAccept(ignored -> this.exit())));
+
             return CompletableFuture.supplyAsync(() -> {
                 logger.info("LSP connection started (connected to {} version {})", params.getClientInfo().getName(), params.getClientInfo().getVersion());
                 logger.debug("LSP client capabilities: {}", params.getCapabilities());
@@ -324,13 +338,20 @@ public void setTrace(SetTraceParams params) {
 
         @Override
         public void connect(LanguageClient client) {
-            var proxy = addShutdownDetectionTo(client);
-            lspDocumentService.connect(proxy);
-            lspWorkspaceService.connect(proxy);
-            remoteIDEServicesConfiguration = RemoteIDEServicesThread.startRemoteIDEServicesServer(proxy, lspDocumentService, executor);
+            this.client = addShutdownDetectionTo(client);
+            lspDocumentService.connect(this.client);
+            lspWorkspaceService.connect(this.client);
+            remoteIDEServicesConfiguration = RemoteIDEServicesThread.startRemoteIDEServicesServer(this.client, lspDocumentService, executor);
             logger.debug("Remote IDE Services Port {}", remoteIDEServicesConfiguration);
         }
 
+        protected IBaseLanguageClient availableClient() {
+            if (client == null) {
+                throw new IllegalStateException("Language Client has not been connected yet");
+            }
+            return client;
+        }
+
         /**
          * Creates a proxy instance that forwards method calls to the provided
          * language client only when (the thread pool of) this language server
@@ -371,5 +392,10 @@ public void setMinimumLogLevel(String level) {
             final var l = Level.toLevel(level, Level.DEBUG); // fall back to debug when the string cannot be mapped
             Configurator.setRootLevel(l);
         }
+
+        protected ExecutorService getExecutor() {
+            return executor;
+        }
+
     }
 }

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/IBaseLanguageServerExtensions.java

@@ -28,7 +28,6 @@
 
 import java.net.URI;
 import java.util.concurrent.CompletableFuture;
-
 import org.eclipse.lsp4j.jsonrpc.messages.Tuple.Two;
 import org.eclipse.lsp4j.jsonrpc.services.JsonNotification;
 import org.eclipse.lsp4j.jsonrpc.services.JsonRequest;
@@ -63,4 +62,5 @@ default CompletableFuture<Two<String, URI[]>[]> supplyPathConfig(PathConfigParam
 
     @JsonNotification("rascal/logLevel")
     void setMinimumLogLevel(String level);
+
 }

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/log/LogJsonConfiguration.java

@@ -63,11 +63,16 @@ public Configuration getConfiguration(LoggerContext loggerContext, Configuration
         return buildConfiguration();
     }
 
-    private Configuration buildConfiguration() {
-        Level targetLevel = Level.getLevel(System.getProperty("log4j2.level", "INFO"));
+    public static Level getLogLevel() {
+        var targetLevel = Level.getLevel(System.getProperty("log4j2.level", "INFO"));
         if (targetLevel == null) {
-            targetLevel = Level.INFO;
+            return Level.INFO;
         }
+        return targetLevel;
+    }
+
+    private Configuration buildConfiguration() {
+        Level targetLevel = getLogLevel();
 
         ConfigurationBuilder<BuiltConfiguration> builder = ConfigurationBuilderFactory.newConfigurationBuilder();
         builder.setConfigurationName("JsonLogger");

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/log/LogRedirectConfiguration.java

@@ -63,10 +63,7 @@ public Configuration getConfiguration(LoggerContext loggerContext, Configuration
     }
 
     private static Configuration buildRedirectConfig() {
-        Level targetLevel = Level.getLevel(System.getProperty("log4j2.level", "INFO"));
-        if (targetLevel == null) {
-            targetLevel = Level.INFO;
-        }
+        Level targetLevel = LogJsonConfiguration.getLogLevel();
 
         ConfigurationBuilder<BuiltConfiguration> builder = ConfigurationBuilderFactory.newConfigurationBuilder();
         builder.setConfigurationName("DefaultLogger");

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/parametric/ParametricLanguageServer.java

@@ -27,26 +27,75 @@
 package org.rascalmpl.vscode.lsp.parametric;
 
 
+import com.google.gson.GsonBuilder;
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.rascalmpl.vscode.lsp.BaseLanguageServer;
 import org.rascalmpl.vscode.lsp.parametric.LanguageRegistry.LanguageParameter;
 
-import com.google.gson.GsonBuilder;
-
 public class ParametricLanguageServer extends BaseLanguageServer {
-    public static void main(String[] args) {
-        LanguageParameter dedicatedLanguage;
-        if (args.length > 0) {
-            dedicatedLanguage = new GsonBuilder().create().fromJson(args[0], LanguageParameter.class);
-        }
-        else {
-            dedicatedLanguage = null;
-        }
 
+    protected static void startParametric(ServerArgs args) {
         startLanguageServer("parametric-lsp"
             , "parametric"
-            , threadPool -> new ParametricTextDocumentService(threadPool, dedicatedLanguage)
+            , threadPool -> new ParametricTextDocumentService(threadPool, args.getDedicatedLanguage(), args.isExitWhenEmpty())
             , ParametricWorkspaceService::new
-            , 9999
+            , args.getPort()
         );
     }
+
+    public static void main(String[] args) {
+        startParametric(parseArgs(args));
+    }
+
+    public static class ServerArgs {
+        private int port = 9999;
+        private @Nullable LanguageParameter dedicatedLanguage = null;
+        private boolean exitWhenEmpty = false;
+
+        public int getPort() {
+            return port;
+        }
+
+        public void setPort(int port) {
+            this.port = port;
+        }
+
+        public @Nullable LanguageParameter getDedicatedLanguage() {
+            return dedicatedLanguage;
+        }
+
+        public void setDedicatedLanguage(LanguageParameter dedicatedLanguage) {
+            this.dedicatedLanguage = dedicatedLanguage;
+        }
+
+        public boolean isExitWhenEmpty() {
+            return exitWhenEmpty;
+        }
+
+        public void setExitWhenEmpty(boolean exitWhenEmpty) {
+            this.exitWhenEmpty = exitWhenEmpty;
+        }
+
+    }
+
+    @SuppressWarnings("java:S127") // skipping next argument from loop
+    protected static ServerArgs parseArgs(String[] args) {
+        var serverArgs = new ServerArgs();
+        for (int i = 0; i < args.length; i++) {
+            switch (args[i]) {
+                case "--port":
+                    serverArgs.setPort(Integer.parseInt(args[++i]));
+                    break;
+                case "--exitWhenEmpty":
+                    serverArgs.setExitWhenEmpty(true);
+                    break;
+                default:
+                    if (serverArgs.getDedicatedLanguage() == null) {
+                        serverArgs.setDedicatedLanguage(new GsonBuilder().create().fromJson(args[i], LanguageParameter.class));
+                    }
+                    break;
+            }
+        }
+        return serverArgs;
+    }
 }