feat: resolve symbols from JDK/dependency bytecode for native-image parity

The GraalVM native binary diverged from `java -jar`: empty callee
signatures/return types and missing CRUD detection. Root cause is that
in a native image `Class.forName` resolves a class but
`getDeclaredMethods()`/`getDeclaredFields()` return empty for
unregistered types, so a `ReflectionTypeSolver` silently "resolves"
every lookup while enumerating zero members.

Add `JmodTypeSolver`, a reflection-free JavaParser `TypeSolver` that
reads `.class` bytecode straight out of zip archives (the JDK's `.jmod`
files and the project's downloaded dependency jars) via a custom
`javassist.ClassPath` backed by `ZipFile`. This works identically in
the JVM and the native image. Wire it ahead of `ReflectionTypeSolver`
in all three extract paths; keep `JarTypeSolver` only as a JVM fallback
when no jmods are present.

Supporting changes:
- ScopeUtils.resolveJmodsDir() made public and honors a
  CODEANALYZER_JMODS_DIR override so the packaged distribution can point
  at bundled jmods instead of a host JAVA_HOME.
- VersionProvider reads the version from an embedded resource (no JAR
  manifest exists at runtime in a native image).
- Declare the native-image-config dir as a nativeCompile input so edits
  to reflect-/resource-config reliably trigger a rebuild.
- Regenerate targeted reflect-/resource-config.json.

Verified byte-identical native vs `java -jar` output (Anonymous-UUIDs
masked) across call-graph-test (L2), record-class-test, init-blocks-test,
plantsbywebsphere (CRUD 38=38), and daytrader8.

Author: rahlk

build.gradle

@@ -160,6 +160,14 @@ compileJava.dependsOn spotlessApply
 // Optionally, automatically format before compilation
 // compileJava.dependsOn googleJavaFormat
 
+// Bake the project version into an embedded resource so the native image (which
+// has no JAR manifest at runtime) can report it identically to `java -jar`.
+processResources {
+    filesMatching('codeanalyzer-version.properties') {
+        expand(version: project.version)
+    }
+}
+
 task fatJar(type: Jar) {
     archiveBaseName = 'codeanalyzer'
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
@@ -193,7 +201,6 @@ graalvmNative {
             buildArgs.add("-Ob")
             buildArgs.add("-march=compatibility")
             buildArgs.add("--no-fallback")
-            buildArgs.add("--no-server")
             buildArgs.add("-H:ReflectionConfigurationFiles=$projectDir/src/main/resources/META-INF/native-image-config/reflect-config.json")
             buildArgs.add("-H:ResourceConfigurationFiles=$projectDir/src/main/resources/META-INF/native-image-config/resource-config.json")
             buildArgs.add("-H:JNIConfigurationFiles=$projectDir/src/main/resources/META-INF/native-image-config/jni-config.json")
@@ -208,6 +215,14 @@ graalvmNative {
     }
 }
 
+// The native-image config above is passed via -H flags as absolute source
+// paths, which Gradle does not track. Declare the directory as a task input so
+// editing reflect-/resource-/jni-/proxy-config.json reliably re-runs the build.
+tasks.named('nativeCompile').configure {
+    inputs.dir("$projectDir/src/main/resources/META-INF/native-image-config")
+            .withPropertyName('nativeImageConfig')
+}
+
 // Define a property for the output directory
 def binDir = project.hasProperty('binDir') ? project.property('binDir') : "$projectDir/artifacts/bin"
 
@@ -294,5 +309,5 @@ tasks.register('bumpVersion') {
 
 nativeCompile.finalizedBy copyNativeExecutable
     kotlin {
-        jvmToolchain(11)
+        jvmToolchain(21)
     }

src/main/java/com/ibm/cldk/CodeAnalyzer.java

@@ -27,12 +27,14 @@
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.io.InputStream;
 import java.lang.reflect.Type;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.List;
 import java.util.Map;
+import java.util.Properties;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.tuple.Pair;
 import picocli.CommandLine;
@@ -42,6 +44,21 @@
 class VersionProvider implements CommandLine.IVersionProvider {
 
     public String[] getVersion() throws Exception {
+        // Read the version baked into an embedded resource at build time. The JAR
+        // manifest's Implementation-Version is unavailable in a GraalVM native
+        // image (no manifest at runtime), so the resource is the portable source.
+        try (InputStream in = getClass().getResourceAsStream("/codeanalyzer-version.properties")) {
+            if (in != null) {
+                Properties props = new Properties();
+                props.load(in);
+                String v = props.getProperty("version");
+                if (v != null && !v.isBlank() && !v.contains("${")) {
+                    return new String[] { v };
+                }
+            }
+        } catch (IOException ignored) {
+            // fall through to manifest lookup
+        }
         String version = getClass().getPackage().getImplementationVersion();
         return new String[] { version != null ? version : "unknown" };
     }

src/main/java/com/ibm/cldk/SymbolTable.java

@@ -18,6 +18,8 @@
 import com.github.javaparser.resolution.types.ResolvedType;
 import com.github.javaparser.symbolsolver.JavaSymbolSolver;
 import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
 import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
 import com.github.javaparser.symbolsolver.utils.SymbolSolverCollectionStrategy;
 import com.github.javaparser.utils.ProjectRoot;
@@ -29,8 +31,10 @@
 import com.ibm.cldk.javaee.EntrypointsFinderFactory;
 import com.ibm.cldk.javaee.utils.enums.CRUDOperationType;
 import com.ibm.cldk.javaee.utils.enums.CRUDQueryType;
+import com.ibm.cldk.utils.JmodTypeSolver;
 import com.ibm.cldk.utils.Log;
 import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.*;
@@ -1171,6 +1175,61 @@ private static boolean excludeSourceRoot(Path sourceRoot) {
         return false;
     }
 
+    /**
+     * Builds the JavaParser symbol solver used for project-mode analysis.
+     * Mirrors {@link SymbolSolverCollectionStrategy}'s composition (a
+     * {@code JavaParserTypeSolver} per source root + reflection + the project's
+     * dependency jars) but resolves JDK and dependency types from bytecode via a
+     * {@link JmodTypeSolver} instead of reflection / javassist's
+     * {@code JarTypeSolver}.
+     *
+     * <p>The bytecode solver precedes reflection because, in the native image,
+     * {@code Class.forName} succeeds for reachable JDK classes so the reflection
+     * solver "wins" the type lookup but then enumerates zero members
+     * (methods/fields aren't registered), leaving calls unresolved. Reading
+     * bytecode first yields identical results in the JVM and the native image.
+     * Dependency jars are indexed into the same bytecode solver rather than
+     * javassist's {@code JarTypeSolver}, whose built-in jar class path cannot
+     * read class bytes under native-image.
+     */
+    private static JavaSymbolSolver buildProjectSymbolSolver(ProjectRoot projectRoot, Path projectRootPath,
+            ParserConfiguration config) {
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        JmodTypeSolver jmodTypeSolver = JmodTypeSolver.tryCreate();
+        if (jmodTypeSolver != null) {
+            jmodTypeSolver.addJars(findDependencyJars(projectRootPath));
+            combinedTypeSolver.add(jmodTypeSolver);
+        }
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        for (SourceRoot sourceRoot : projectRoot.getSourceRoots()) {
+            if (excludeSourceRoot(sourceRoot.getRoot())) {
+                continue;
+            }
+            combinedTypeSolver.add(new JavaParserTypeSolver(sourceRoot.getRoot(), config));
+        }
+        // Fallback for environments without jmods (e.g. a JRE-only dev box):
+        // resolve dependency jars via javassist's JarTypeSolver under the JVM.
+        if (jmodTypeSolver == null) {
+            for (Path jar : findDependencyJars(projectRootPath)) {
+                try {
+                    combinedTypeSolver.add(new JarTypeSolver(jar.toString()));
+                } catch (IOException e) {
+                    Log.warn("Skipping unreadable jar for symbol resolution: " + jar + " (" + e.getMessage() + ")");
+                }
+            }
+        }
+        return new JavaSymbolSolver(combinedTypeSolver);
+    }
+
+    private static List<Path> findDependencyJars(Path projectRootPath) {
+        try (java.util.stream.Stream<Path> paths = Files.walk(projectRootPath)) {
+            return paths.filter(p -> p.toString().endsWith(".jar")).collect(Collectors.toList());
+        } catch (IOException e) {
+            Log.warn("Failed to scan for jars under " + projectRootPath + ": " + e.getMessage());
+            return Collections.emptyList();
+        }
+    }
+
     /**
      * Sets up lexical preserving printer for the given compilation unit in a safe manner by checking
      * whether any node in the unit is missing ranges, which can result in exception.
@@ -1197,8 +1256,8 @@ public static Pair<Map<String, JavaCompilationUnit>, Map<String, List<Problem>>>
                 .setLanguageLevel(ParserConfiguration.LanguageLevel.JAVA_21);
         SymbolSolverCollectionStrategy symbolSolverCollectionStrategy = new SymbolSolverCollectionStrategy(config);
         ProjectRoot projectRoot = symbolSolverCollectionStrategy.collect(projectRootPath);
-        javaSymbolSolver = (JavaSymbolSolver) symbolSolverCollectionStrategy.getParserConfiguration()
-                .getSymbolResolver().get();
+        javaSymbolSolver = buildProjectSymbolSolver(projectRoot, projectRootPath, config);
+        config.setSymbolResolver(javaSymbolSolver);
         Map<String, JavaCompilationUnit> symbolTable = new LinkedHashMap<>();
         Map<String, List<Problem>> parseProblems = new HashMap<>();
         for (SourceRoot sourceRoot : projectRoot.getSourceRoots()) {
@@ -1223,8 +1282,14 @@ public static Pair<Map<String, JavaCompilationUnit>, Map<String, List<Problem>>>
             throws IOException {
         Map symbolTable = new LinkedHashMap<String, JavaCompilationUnit>();
         Map parseProblems = new HashMap<String, List<Problem>>();
-        // Setting up symbol solvers
+        // Setting up symbol solvers. The jmod (bytecode) solver precedes the
+        // reflection solver so JDK types resolve identically in the JVM and the
+        // native image (see buildProjectSymbolSolver for the rationale).
         CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        JmodTypeSolver jmodTypeSolver = JmodTypeSolver.tryCreate();
+        if (jmodTypeSolver != null) {
+            combinedTypeSolver.add(jmodTypeSolver);
+        }
         combinedTypeSolver.add(new ReflectionTypeSolver());
 
         ParserConfiguration parserConfiguration = new ParserConfiguration()
@@ -1259,15 +1324,15 @@ public static Pair<Map<String, JavaCompilationUnit>, Map<String, List<Problem>>>
             List<Path> javaFilePaths) throws IOException {
 
         // create symbol solver and parser configuration
-        SymbolSolverCollectionStrategy symbolSolverCollectionStrategy = new SymbolSolverCollectionStrategy();
-        ProjectRoot projectRoot = symbolSolverCollectionStrategy.collect(projectRootPath);
-        javaSymbolSolver = (JavaSymbolSolver) symbolSolverCollectionStrategy.getParserConfiguration()
-                .getSymbolResolver().get();
         Log.info("Setting parser language level to JAVA_21");
         ParserConfiguration parserConfiguration = new ParserConfiguration()
                 .setStoreTokens(true)
                 .setAttributeComments(true)
                 .setLanguageLevel(ParserConfiguration.LanguageLevel.JAVA_21);
+        SymbolSolverCollectionStrategy symbolSolverCollectionStrategy =
+                new SymbolSolverCollectionStrategy(parserConfiguration);
+        ProjectRoot projectRoot = symbolSolverCollectionStrategy.collect(projectRootPath);
+        javaSymbolSolver = buildProjectSymbolSolver(projectRoot, projectRootPath, parserConfiguration);
         parserConfiguration.setSymbolResolver(javaSymbolSolver);
 
         // create java parser with the configuration