Setup delegateCommandHandler to set KLS classpath entry

Author: daplf

.gitignore

@@ -6,4 +6,5 @@ target
 .DS_Store
 **/.DS_Store
 jars
-.vscode/settings.json
+.vscode/settings.json
+out

README.md

@@ -1,6 +1,6 @@
 # VSCode Extension for Java + Kotlin
 
-A VSCode extension that enchances [vscode-java](https://github.com/redhat-developer/vscode-java) and [vscode-kotlin](https://github.com/fwcd/vscode-kotlin) with java + kotlin interoperability. This uses a JDT LS extension with a custom project importer to allow Java code to have access to Kotlin code.
+A VSCode extension that enchances [vscode-java](https://github.com/redhat-developer/vscode-java) and [vscode-kotlin](https://github.com/fwcd/vscode-kotlin) with java + kotlin interoperability. This uses a JDT LS extension with a delegate command handler that can work together with the Kotlin Language Server, in order for Java code to have access to Kotlin code.
 
 **Disclaimer**: This is very experimental, but it seems to work for small maven and gradle projects at least.
 

jdt-ls-extension/org.javacs.kt.jdt.ls.extension/plugin.xml

@@ -1,17 +1,12 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.4"?>
 <plugin>
-      <extension
-            id="importers"
-            point="org.eclipse.jdt.ls.core.importers">
-            <importer
-                  id = "kotlinGradleImporter"
-                  order = "125"
-                  class = "org.javacs.kt.jdt.ls.extension.KotlinGradleImporter"/>
-            <importer
-                  id = "kotlinMavenImporter"
-                  order = "150"
-                  class = "org.javacs.kt.jdt.ls.extension.KotlinMavenImporter"/>
+      <extension point="org.eclipse.jdt.ls.core.delegateCommandHandler">
+            <delegateCommandHandler class="org.javacs.kt.jdt.ls.extension.SetKotlinBuildOutputCommandHandler">
+                  <command
+                        id="kotlin.java.setKotlinBuildOutput"
+                        static="true"/>
+            </delegateCommandHandler>
       </extension>
 </plugin>
 

jdt-ls-extension/org.javacs.kt.jdt.ls.extension/src/org/javacs/kt/jdt/ls/extension/KotlinGradleImporter.java

@@ -26,45 +26,51 @@
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.jdt.core.IClasspathAttribute;
 import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.internal.core.ClasspathEntry;
 import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
 import org.eclipse.jdt.ls.core.internal.managers.IBuildSupport;
 import org.eclipse.jdt.ls.core.internal.managers.ProjectsManager.CHANGE_TYPE;
 
 @SuppressWarnings("restriction")
 public class KotlinImporterUtils {
-    
-    /**
-     * Checks if any kotlin files exist in the given directory and subdirectories.
-     */
-    public static boolean anyKotlinFiles(java.nio.file.Path directory) {
-        try (Stream<java.nio.file.Path> files = Files.walk(directory)) {
-            return files.anyMatch(f -> f.getFileName().toString().endsWith(".kt"));
-        } catch (IOException ex) {
-            return false;
-        }
-    }
 
+	/**
+	 * Sets the KLS classpath entry.
+	 * This is the path where the KLS stores build outputs (i.e., Kotlin compiled code).
+	 * The entry has an extra attribute, which is used to remove old paths whenever they change, since this is something that is kept between sessions.
+	 */
     public static void setKlsClasspathEntry(IProject project, java.nio.file.Path path, IProgressMonitor monitor, IBuildSupport buildSupport) throws CoreException {
 		IJavaProject javaProject = JavaCore.create(project);
 
 		List<IClasspathEntry> entries = new ArrayList<>(Arrays.asList(javaProject.getRawClasspath()));
 		IPath klsPath = Path.fromOSString(path.toString());
 
 		entries.removeIf(entry -> entry.getPath().equals(klsPath));
-		IClasspathEntry classpathEntry = JavaCore.newLibraryEntry(klsPath, null, null);
+		entries.removeIf(entry -> Stream.of(entry.getExtraAttributes()).anyMatch(attribute -> attribute.getName().equals("kls")));
+		IClasspathEntry classpathEntry = JavaCore.newLibraryEntry(
+			klsPath,
+			null,
+			null,
+			ClasspathEntry.NO_ACCESS_RULES,
+			new IClasspathAttribute[]{
+				JavaCore.newClasspathAttribute("kls", "true")
+			},
+			false
+		);
 		entries.add(classpathEntry);
 
 		javaProject.setRawClasspath(entries.toArray(new IClasspathEntry[0]), monitor);
 		buildSupport.refresh(project, CHANGE_TYPE.CHANGED, monitor);
 	}
 
     /**
-	 * Registers a watcher for the kls directory.
+	 * Registers a watcher for the kls build output directory.
 	 * Any file change leads to an update in the classpath.
-     * The classpath update is done using a function send as parameter, since it's different for each importer.
+     * The classpath update is done using a function sent as parameter, since it's dependent on the build tool used.
 	 */
 	public static void registerKlsWatcher(java.nio.file.Path path, Function<IProgressMonitor, IStatus> updateClasspathJob) {
 		new Thread(() -> {

jdt-ls-extension/org.javacs.kt.jdt.ls.extension/src/org/javacs/kt/jdt/ls/extension/KotlinImporterUtils.java

@@ -0,0 +1,67 @@
+package org.javacs.kt.jdt.ls.extension;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jdt.ls.core.internal.IDelegateCommandHandler;
+import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
+import org.eclipse.jdt.ls.core.internal.ProjectUtils;
+import org.eclipse.jdt.ls.core.internal.managers.GradleBuildSupport;
+import org.eclipse.jdt.ls.core.internal.managers.IBuildSupport;
+import org.eclipse.jdt.ls.core.internal.managers.MavenBuildSupport;
+
+/**
+ * Delegate command handler that adds a Kotlin build output to the classpath.
+ * This also registers a directory watcher to update the classpath as new compiled files are added and removed.
+ */
+@SuppressWarnings("restriction")
+public class SetKotlinBuildOutputCommandHandler implements IDelegateCommandHandler {
+
+	/**
+	 * Goes through all the projects and updates their classpath with the argument received in this command.
+	 */
+	@Override
+	public Object executeCommand(String commandId, List<Object> arguments, IProgressMonitor monitor) throws Exception {
+		if (!arguments.isEmpty()) {
+			String outputLocation = arguments.get(0).toString();
+			Path path = Paths.get(outputLocation);
+
+			for (IProject project : ProjectUtils.getAllProjects()) {
+				IBuildSupport buildSupport = null;
+				
+				if (ProjectUtils.isMavenProject(project)) {
+					buildSupport = new MavenBuildSupport();
+				} else if (ProjectUtils.isGradleProject(project)) {
+					buildSupport = new GradleBuildSupport();
+				}
+
+				if (buildSupport != null) {
+					KotlinImporterUtils.setKlsClasspathEntry(project, path, monitor, buildSupport);
+					KotlinImporterUtils.registerKlsWatcher(path, subMonitor -> {
+						try {
+							for (IProject underlyingProject : ProjectUtils.getAllProjects()) {
+								if (ProjectUtils.isMavenProject(project)) {
+									KotlinImporterUtils.setKlsClasspathEntry(underlyingProject, path, subMonitor, new MavenBuildSupport());
+								} else if (ProjectUtils.isGradleProject(project)) {
+									KotlinImporterUtils.setKlsClasspathEntry(underlyingProject, path, subMonitor, new GradleBuildSupport());
+								}
+							}
+		
+							return Status.OK_STATUS;
+						} catch (CoreException ex) {
+							JavaLanguageServerPlugin.logException(ex);
+							return Status.error("An error occurred while updating the kotlin classpath entry");
+						}
+					});
+				}
+			}
+		}
+
+		return null;
+	}
+}

jdt-ls-extension/org.javacs.kt.jdt.ls.extension/src/org/javacs/kt/jdt/ls/extension/KotlinMavenImporter.java

@@ -4,4 +4,15 @@ import * as vscode from 'vscode';
 
 /** Called when extension is activated */
 export async function activate(context: vscode.ExtensionContext) {
+    // We call vscode-kotlin's API to fetch the build output path.
+    // Note that this code is only executed after vscode-kotlin is setup, so the API should be ready to receive requests.
+    const vscodekotlinApi = vscode.extensions.getExtension('fwcd.kotlin').exports as ExtensionAPI;
+
+    // Execute a java workspace command to update the kotlin build output path. This triggers a classpath change on the JDT language server.
+    await vscode.commands.executeCommand("java.execute.workspaceCommand", "kotlin.java.setKotlinBuildOutput", vscodekotlinApi.getBuildOutputPath());
 }
+
+// vscode-kotlin API stub.
+interface ExtensionAPI {
+    getBuildOutputPath(): string;
+}