fix(java): list dependencies' implementations after the project's in Go to Implementation (#1644)

Go to Implementation on a type or method declared in a dependency listed only the project's implementations once the project had one. openidea.java.implementations (java-usages 1.5.0) now answers {locations, complete}, complete when the type is declared in the sources, and also searches the Kotlin bridge's classes. When not complete, the chooser opens with the project's implementations (searching…) through the new lsp_goto_implementation channel and fills in the dependencies' when the standard request ends; closing it cancels the search.

java/java-usages/MANIFEST.MF

@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: OpenIDEA Java usages
 Bundle-SymbolicName: ai.openidea.usages;singleton:=true
-Bundle-Version: 1.4.0
+Bundle-Version: 1.5.0
 Bundle-RequiredExecutionEnvironment: JavaSE-21
 Require-Bundle: org.eclipse.jdt.ls.core,org.eclipse.jdt.core,
  org.eclipse.jdt.core.manipulation,org.eclipse.core.runtime,

java/java-usages/README.md

@@ -57,7 +57,7 @@ is not a claim of full IntelliJ feature parity.
 ## Rebuild and delivery
 
 The checked-in jar is embedded by ide-sdk `include_bytes!`, installed as
-`java-usages-1.4.0.jar`, and added alongside existing initialization bundles.
+`java-usages-1.5.0.jar`, and added alongside existing initialization bundles.
 Users need no compiler, Maven or Python. Manifest/install version must change
 when replacing the bundle because OSGi caches bundles.
 
@@ -78,6 +78,11 @@ Version 1.3.0 adds the class-hierarchy refactoring commands; its reproducible SH
 Version 1.4.0 adds `openidea.java.implementations` (Go to Implementation in the workspace's
 source folders, before the standard request that also searches every dependency jar); its
 reproducible SHA-256 is `d7601493eda846811b4bb8bfe7f3d56e3234a45e663648210db3937cebc770a5`.
+Version 1.5.0 answers `{locations, complete}`: `complete` when the type is declared in the sources
+(no dependency implements it), otherwise the app also runs the standard request and adds the
+dependencies' implementations after the first ones. The search also covers the project's Kotlin
+classes attached by the Kotlin bridge; its reproducible SHA-256 is
+`7588748c2797f9da2beb209714a75c29b4e31b155f095329bfb7e399d807c20a`.
 
 ```sh
 export PATH=/path/to/jdk25/bin:$PATH
@@ -107,6 +112,7 @@ python3 java/java-usages/tests/verify.py /path/to/jdtls /path/to/lombok.jar
 python3 java/java-usages/tests/read-write.py /path/to/jdtls /path/to/lombok.jar > /tmp/read-write.json
 OPENIDEA_USAGES_INDEX_STRESS=1 python3 java/java-usages/tests/read-write.py /path/to/jdtls /path/to/lombok.jar > /tmp/read-write-indexed.json
 python3 java/java-usages/tests/hierarchy.py /path/to/jdtls
+python3 java/java-usages/tests/implementations.py /path/to/jdtls
 ```
 
 The harnesses select the JDT LS configuration for the current platform. The first

java/java-usages/src/ai/openidea/implementations/ImplementationsCommand.java

@@ -2,6 +2,7 @@ package ai.openidea.implementations;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.OperationCanceledException;
@@ -13,39 +14,52 @@ import org.eclipse.jdt.ls.core.internal.JavaLanguageServerPlugin;
 import org.eclipse.lsp4j.Location;
 
 /**
- * Implementations of the type or method at a position, looked up in the workspace's source
- * folders only. The standard request builds the type hierarchy over every dependency jar too,
- * which takes long in a project with many dependencies; the client falls back to it when the
- * sources have none.
+ * Implementations of the type or method at a position, looked up in the workspace's own code
+ * only (source folders and bridged Kotlin classes): {@code {locations, complete}}. The standard
+ * request builds the type hierarchy over every dependency jar too, which takes long in a project
+ * with many dependencies. {@code complete} when the type is declared in the sources, which no
+ * dependency extends; otherwise the client also asks the standard request for the dependencies'
+ * implementations.
  */
 public final class ImplementationsCommand implements IDelegateCommandHandler {
+    /** Classpath attribute of the Kotlin bridge's library entries (`java/kotlin-bridge`). */
+    private static final String KOTLIN_OUTPUT = "ai.openidea.kotlin";
+
     @Override
     public Object executeCommand(String command, List<Object> arguments, IProgressMonitor monitor) throws Exception {
+        List<Location> locations = new ArrayList<>();
+        boolean complete = find(arguments, locations, monitor);
+        return Map.of("locations", locations, "complete", complete);
+    }
+
+    /** Adds the implementations to {@code result}; whether they are all there are. */
+    private static boolean find(List<Object> arguments, List<Location> result, IProgressMonitor monitor) throws Exception {
         String uri = (String) arguments.get(0);
         int line = ((Number) arguments.get(1)).intValue();
         int column = ((Number) arguments.get(2)).intValue();
-        List<Location> result = new ArrayList<>();
         ITypeRoot root = JDTUtils.resolveTypeRoot(uri);
-        if (root == null) return result;
+        if (root == null) return false;
         var preferences = JavaLanguageServerPlugin.getPreferencesManager();
         IJavaElement element = JDTUtils.findElementAtSelection(root, line, column, preferences, monitor);
         IMethod method = null;
         IType type;
         if (element instanceof IMethod m) {
             int flags = m.getFlags();
-            if (m.isConstructor() || Flags.isStatic(flags) || Flags.isPrivate(flags) || Flags.isFinal(flags)) return result;
+            if (m.isConstructor() || Flags.isStatic(flags) || Flags.isPrivate(flags) || Flags.isFinal(flags)) return false;
             method = m;
             type = m.getDeclaringType();
         } else if (element instanceof IType t) {
             type = t;
         } else {
-            return result;
+            return false;
         }
-        if (type == null || type.getJavaProject() == null) return result;
+        if (type == null || type.getJavaProject() == null) return false;
         IRegion sources = JavaCore.newRegion();
         for (IJavaProject project : JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()).getJavaProjects()) {
             for (IPackageFragmentRoot fragmentRoot : project.getPackageFragmentRoots()) {
-                if (fragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE) sources.add(fragmentRoot);
+                if (fragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE || isKotlinOutput(fragmentRoot)) {
+                    sources.add(fragmentRoot);
+                }
             }
         }
         ITypeHierarchy hierarchy = type.getJavaProject().newTypeHierarchy(type, sources, monitor);
@@ -62,6 +76,17 @@ public final class ImplementationsCommand implements IDelegateCommandHandler {
             Location location = found == null ? null : JDTUtils.toLocation(found);
             if (location != null) result.add(location);
         }
-        return result;
+        return !type.isBinary();
+    }
+
+    /** The project's compiled Kotlin classes, attached as a library by the Kotlin bridge. */
+    private static boolean isKotlinOutput(IPackageFragmentRoot root) throws JavaModelException {
+        if (root.getKind() != IPackageFragmentRoot.K_BINARY) return false;
+        IClasspathEntry entry = root.getRawClasspathEntry();
+        if (entry == null) return false;
+        for (IClasspathAttribute attribute : entry.getExtraAttributes()) {
+            if (KOTLIN_OUTPUT.equals(attribute.getName()) && "true".equals(attribute.getValue())) return true;
+        }
+        return false;
     }
 }

java/java-usages/tests/implementations.py

@@ -24,7 +24,8 @@ config_source = next(home / name / 'config.ini' for name in config_names if (hom
 project = work / 'project'
 (project / 'src/zoo').mkdir(parents=True)
 (project / '.project').write_text('<projectDescription><name>zoo</name><buildSpec><buildCommand><name>org.eclipse.jdt.core.javabuilder</name></buildCommand></buildSpec><natures><nature>org.eclipse.jdt.core.javanature</nature></natures></projectDescription>')
-(project / '.classpath').write_text('<classpath><classpathentry kind="src" path="src"/><classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/><classpathentry kind="output" path="bin"/></classpath>')
+# `kotlin`: the project's compiled Kotlin classes, as the Kotlin bridge attaches them.
+(project / '.classpath').write_text('<classpath><classpathentry kind="src" path="src"/><classpathentry kind="lib" path="kotlin"><attributes><attribute name="ai.openidea.kotlin" value="true"/></attributes></classpathentry><classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/><classpathentry kind="output" path="bin"/></classpath>')
 sources = {
     'Repo.java': '''package zoo;
 
@@ -88,6 +89,10 @@ public class Use {
 for name, text in sources.items():
     (project / 'src/zoo' / name).write_text(text)
 uri = lambda name: (project / 'src/zoo' / name).as_uri()
+# Stands in for a Kotlin class of the project implementing the Java interface.
+(work / 'kotlin-src/zoo').mkdir(parents=True)
+(work / 'kotlin-src/zoo/Longs.java').write_text('package zoo;\n\npublic class Longs implements Repo<Long> {\n    public void save(Long item) {\n    }\n}\n')
+subprocess.run(['javac', '-implicit:none', '-sourcepath', str(project / 'src'), '-d', str(project / 'kotlin'), str(work / 'kotlin-src/zoo/Longs.java')], check=True)
 
 log = (work / 'stderr.log').open('w')
 proc = subprocess.Popen(['java', '-Declipse.application=org.eclipse.jdt.ls.core.id1', '-Dosgi.bundles.defaultStartLevel=4', '-Declipse.product=org.eclipse.jdt.ls.core.product', '-Xmx1G', '--add-modules=ALL-SYSTEM', '--add-opens', 'java.base/java.util=ALL-UNNAMED', '--add-opens', 'java.base/java.lang=ALL-UNNAMED', '-jar', str(next((home / 'plugins').glob('org.eclipse.equinox.launcher_*.jar'))), '-configuration', str(config), '-data', str(work / 'metadata')], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=log)
@@ -154,30 +159,31 @@ def implementations(file, needle):
     line, col = position(file, needle)
     found = command('openidea.java.implementations', uri(file), line, col)
     names = []
-    for loc in found:
+    for loc in found['locations']:
         name = pathlib.Path(urllib.parse.unquote(urllib.parse.urlparse(loc['uri']).path)).name
         names.append(f"{name}:{loc['range']['start']['line']}")
-    return sorted(names)
+    return sorted(names), found['complete']
 
 
 try:
-    init = request('initialize', {'processId': None, 'rootUri': project.as_uri(), 'workspaceFolders': [{'uri': project.as_uri(), 'name': 'zoo'}], 'capabilities': {}, 'initializationOptions': {'bundles': [str(bundle)], 'settings': {'java': {'import': {'gradle': {'enabled': False}, 'maven': {'enabled': False}}}}}})
+    init = request('initialize', {'processId': None, 'rootUri': project.as_uri(), 'workspaceFolders': [{'uri': project.as_uri(), 'name': 'zoo'}], 'capabilities': {}, 'initializationOptions': {'bundles': [str(bundle)], 'extendedClientCapabilities': {'classFileContentsSupport': True}, 'settings': {'java': {'import': {'gradle': {'enabled': False}, 'maven': {'enabled': False}}}}}})
     assert 'openidea.java.implementations' in init['capabilities']['executeCommandProvider']['commands']
     send({'jsonrpc': '2.0', 'method': 'initialized', 'params': {}})
     for name, text in sources.items():
         send({'jsonrpc': '2.0', 'method': 'textDocument/didOpen', 'params': {'textDocument': {'uri': uri(name), 'languageId': 'java', 'version': 1, 'text': text}}})
     request('java/buildWorkspace', True)
+    # (implementations in the sources, whether they are all there are)
     cases = {
-        # Classes, abstract ones too; not the sub-interface.
-        ('Repo.java', 'Repo<T>'): ['Base.java:2', 'Numbers.java:2', 'Words.java:2'],
+        # Classes, abstract ones too, and those of the bridged Kotlin output; not the sub-interface.
+        ('Repo.java', 'Repo<T>'): (['Base.java:2', 'Longs.java:0', 'Numbers.java:2', 'Words.java:2'], True),
         # Through the type arguments; not the abstract re-declaration.
-        ('Repo.java', 'save(T'): ['Numbers.java:3', 'Words.java:3'],
-        ('Use.java', 'save("x")'): ['Numbers.java:3', 'Words.java:3'],
-        ('Repo.java', 'name()'): ['Words.java:6'],
-        # A library type's implementations in the sources.
-        ('Use.java', 'Runnable task'): ['Task.java:2'],
-        ('Use.java', 'run();'): ['Task.java:3'],
-        ('Use.java', 'alone()'): [],
+        ('Repo.java', 'save(T'): (['Longs.java:0', 'Numbers.java:3', 'Words.java:3'], True),
+        ('Use.java', 'save("x")'): (['Longs.java:0', 'Numbers.java:3', 'Words.java:3'], True),
+        ('Repo.java', 'name()'): (['Words.java:6'], True),
+        # A library type's implementations in the sources; the library has more.
+        ('Use.java', 'Runnable task'): (['Task.java:2'], False),
+        ('Use.java', 'run();'): (['Task.java:3'], False),
+        ('Use.java', 'alone()'): ([], True),
     }
     failures = []
     for (file, needle), expected in cases.items():