feat(jdk-codemodel): add classpath and module-path support to JdkInitializer

Author: deer

jdk-codemodel/src/main/java/build/codemodel/jdk/JdkInitializer.java

@@ -124,6 +124,8 @@ public class JdkInitializer
     private final List<File> sourceFiles;
     private final List<Path> sourceDirectories;
     private final List<JavaFileObject> javaFileObjects;
+    private final List<Path> classpath;
+    private final List<Path> modulePath;
 
     private boolean initialized = false;
 
@@ -137,16 +139,37 @@ public class JdkInitializer
     /**
      * Creates a {@link JdkInitializer} with explicit source inputs.
      *
-     * @param sourceFiles      individual {@link File} source files to parse
+     * @param sourceFiles       individual {@link File} source files to parse
      * @param sourceDirectories directories to walk recursively for {@code .java} files
-     * @param javaFileObjects  in-memory or pre-built {@link JavaFileObject} sources
+     * @param javaFileObjects   in-memory or pre-built {@link JavaFileObject} sources
      */
     public JdkInitializer(final List<File> sourceFiles,
                           final List<Path> sourceDirectories,
                           final List<JavaFileObject> javaFileObjects) {
+        this(sourceFiles, sourceDirectories, javaFileObjects, List.of(), List.of());
+    }
+
+    /**
+     * Creates a {@link JdkInitializer} with explicit source inputs and dependency paths.
+     * Callers are responsible for assembling the classpath and module-path lists; this class
+     * does no jar classification or module dependency resolution.
+     *
+     * @param sourceFiles       individual {@link File} source files to parse
+     * @param sourceDirectories directories to walk recursively for {@code .java} files
+     * @param javaFileObjects   in-memory or pre-built {@link JavaFileObject} sources
+     * @param classpath         jars or directories to pass as {@code --class-path}
+     * @param modulePath        jars or directories to pass as {@code --module-path}
+     */
+    public JdkInitializer(final List<File> sourceFiles,
+                          final List<Path> sourceDirectories,
+                          final List<JavaFileObject> javaFileObjects,
+                          final List<Path> classpath,
+                          final List<Path> modulePath) {
         this.sourceFiles = sourceFiles;
         this.sourceDirectories = sourceDirectories;
         this.javaFileObjects = javaFileObjects;
+        this.classpath = classpath;
+        this.modulePath = modulePath;
     }
 
     /**
@@ -193,7 +216,7 @@ public void initialize(final CodeModel codeModel) {
                 return;
             }
 
-            final var task = compiler.getTask(null, fileManager, diagnostic -> {}, null, null, combined);
+            final var task = compiler.getTask(null, fileManager, diagnostic -> {}, buildOptions(), null, combined);
             final var javacTask = (JavacTask) task;
             final var compilationUnits = javacTask.parse();
             javacTask.analyze();
@@ -226,6 +249,25 @@ public Void visitClass(final ClassTree classTree, final Void unused) {
         }
     }
 
+    // --- Compiler options ---
+
+    private List<String> buildOptions() {
+        final var options = new ArrayList<String>();
+        if (!classpath.isEmpty()) {
+            options.add("--class-path");
+            options.add(classpath.stream()
+                .map(Path::toString)
+                .collect(Collectors.joining(File.pathSeparator)));
+        }
+        if (!modulePath.isEmpty()) {
+            options.add("--module-path");
+            options.add(modulePath.stream()
+                .map(Path::toString)
+                .collect(Collectors.joining(File.pathSeparator)));
+        }
+        return options.isEmpty() ? null : options;
+    }
+
     // --- Source collection ---
 
     private List<JavaFileObject> collectSources(final StandardJavaFileManager fileManager) throws IOException {

jdk-codemodel/src/test/java/build/codemodel/jdk/JdkInitializerTests.java

@@ -15,8 +15,11 @@
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.PrintStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Optional;
+import javax.tools.ToolProvider;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -181,6 +184,45 @@ public class Foo {
         assertThat(field.type()).isInstanceOf(UnknownTypeUsage.class);
     }
 
+    @Test
+    void shouldResolveTypesFromClasspath() throws Exception {
+        // Compile a helper class to a temp directory, then pass that directory as the classpath.
+        // Without classpath support the field type would be UnknownTypeUsage.
+        final Path classpathDir = Files.createTempDirectory("jdk-initializer-test-cp");
+
+        final var helperSource = JavaFileObjects.forSourceString(
+            "com.example.Helper",
+            "package com.example; public class Helper {}");
+        final var compiler = ToolProvider.getSystemJavaCompiler();
+        try (final var fm = compiler.getStandardFileManager(null, null, null)) {
+            compiler.getTask(null, fm, diagnostic -> {},
+                List.of("-d", classpathDir.toString()), null, List.of(helperSource)).call();
+        }
+
+        final var consumer = JavaFileObjects.forSourceString(
+            "com.example.Consumer",
+            """
+            package com.example;
+            public class Consumer {
+                private com.example.Helper helper;
+            }
+            """);
+
+        final var codeModel = runInternal(
+            new JdkInitializer(List.of(), List.of(), List.of(consumer), List.of(classpathDir), List.of()));
+
+        final var typeName = codeModel.getNameProvider().getTypeName(Optional.empty(), "com.example.Consumer");
+        final var descriptor = codeModel.getTypeDescriptor(typeName).orElseThrow();
+        final var field = descriptor.traits(FieldDescriptor.class)
+            .filter(f -> f.fieldName().toString().equals("helper"))
+            .findFirst()
+            .orElseThrow();
+
+        assertThat(field.type())
+            .as("type from classpath entry should resolve, not degrade to UnknownTypeUsage")
+            .isNotInstanceOf(UnknownTypeUsage.class);
+    }
+
     @Test
     void shouldCaptureAnnotationsOnParameters() {
         final var source = JavaFileObjects.forSourceString(