[jnigen] Generate classes in Java SDK without providing path (#2082)

* [jnigen] Generate classes in Java SDK without providing path

Author: HosseinYousefi

pkgs/jnigen/CHANGELOG.md

@@ -3,6 +3,8 @@
 - The name `factory` can now also be used in a method name without renaming.
 - Throw when output folder contains non JNIgen files. Users with existing
   package bindings will need to delete them once for it to start working.
+- Added the ability to generate classes in Java SDK (`java.core`) module without
+  providing the class path.
 
 ## 0.14.1
 

pkgs/jnigen/java/src/main/java/com/github/dart_lang/jnigen/apisummarizer/Main.java

@@ -8,13 +8,10 @@
 import com.github.dart_lang.jnigen.apisummarizer.doclet.SummarizerDoclet;
 import com.github.dart_lang.jnigen.apisummarizer.elements.ClassDecl;
 import com.github.dart_lang.jnigen.apisummarizer.util.ClassFinder;
-import com.github.dart_lang.jnigen.apisummarizer.util.InputStreamProvider;
+import com.github.dart_lang.jnigen.apisummarizer.util.JavaCoreClassFinder;
 import com.github.dart_lang.jnigen.apisummarizer.util.JsonWriter;
 import com.github.dart_lang.jnigen.apisummarizer.util.StreamUtil;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.OutputStream;
+import java.io.*;
 import java.util.*;
 import javax.tools.DocumentationTool;
 import javax.tools.JavaFileObject;
@@ -81,7 +78,7 @@ public static void main(String[] args) throws FileNotFoundException {
     var javaDoc = ToolProvider.getSystemDocumentationTool();
 
     var sourceClasses = new LinkedHashMap<String, List<JavaFileObject>>();
-    var binaryClasses = new LinkedHashMap<String, List<InputStreamProvider>>();
+    var binaryClasses = new LinkedHashMap<String, List<InputStream>>();
 
     for (var qualifiedName : options.args) {
       sourceClasses.put(qualifiedName, null);
@@ -102,7 +99,22 @@ public static void main(String[] args) throws FileNotFoundException {
       var foundSource = sourceClasses.get(qualifiedName) != null;
       var foundBinary = binaryClasses.get(qualifiedName) != null;
       if (!foundBinary && !foundSource) {
-        notFound.add(qualifiedName);
+        Map<String, InputStream> inputStreams = null;
+        try {
+          inputStreams = JavaCoreClassFinder.findAll(qualifiedName);
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+        if (inputStreams != null) {
+          inputStreams.forEach(
+              (className, inputStream) -> {
+                var list = new ArrayList<InputStream>();
+                list.add(inputStream);
+                binaryClasses.put(className, list);
+              });
+        } else {
+          notFound.add(qualifiedName);
+        }
       }
     }
 

pkgs/jnigen/java/src/main/java/com/github/dart_lang/jnigen/apisummarizer/disasm/AsmSummarizer.java

@@ -7,20 +7,24 @@
 import static com.github.dart_lang.jnigen.apisummarizer.util.ExceptionUtil.wrapCheckedException;
 
 import com.github.dart_lang.jnigen.apisummarizer.elements.ClassDecl;
-import com.github.dart_lang.jnigen.apisummarizer.util.InputStreamProvider;
+import java.io.IOException;
+import java.io.InputStream;
 import java.util.List;
 import java.util.Map;
 import org.objectweb.asm.ClassReader;
 
 public class AsmSummarizer {
 
-  public static Map<String, ClassDecl> run(List<InputStreamProvider> inputProviders) {
+  public static Map<String, ClassDecl> run(List<InputStream> inputStreams) {
     var visitor = new AsmClassVisitor();
-    for (var provider : inputProviders) {
-      var inputStream = provider.getInputStream();
+    for (var inputStream : inputStreams) {
       var classReader = wrapCheckedException(ClassReader::new, inputStream);
       classReader.accept(visitor, 0);
-      provider.close();
+      try {
+        inputStream.close();
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
     }
     return visitor.getVisited();
   }

pkgs/jnigen/java/src/main/java/com/github/dart_lang/jnigen/apisummarizer/util/ClassFinder.java

@@ -2,8 +2,7 @@
 
 import static com.github.dart_lang.jnigen.apisummarizer.util.ExceptionUtil.wrapCheckedException;
 
-import java.io.File;
-import java.io.IOException;
+import java.io.*;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.*;
@@ -163,13 +162,29 @@ private static List<JavaFileObject> getJavaFileObjectsFromJar(
     return StreamUtil.map(entries, (entry) -> new JarEntryFileObject(jarFile, entry));
   }
 
-  private static List<InputStreamProvider> getInputStreamProvidersFromFiles(List<Path> files) {
-    return StreamUtil.map(files, (path) -> new FileInputStreamProvider(path.toFile()));
+  private static List<InputStream> getInputStreamProvidersFromFiles(List<Path> files) {
+    return StreamUtil.map(
+        files,
+        (path) -> {
+          try {
+            return new FileInputStream(path.toFile());
+          } catch (FileNotFoundException e) {
+            throw new RuntimeException(e);
+          }
+        });
   }
 
-  private static List<InputStreamProvider> getInputStreamProvidersFromJar(
+  private static List<InputStream> getInputStreamProvidersFromJar(
       JarFile jarFile, List<ZipEntry> entries) {
-    return StreamUtil.map(entries, entry -> new JarEntryInputStreamProvider(jarFile, entry));
+    return StreamUtil.map(
+        entries,
+        entry -> {
+          try {
+            return jarFile.getInputStream(entry);
+          } catch (IOException e) {
+            throw new RuntimeException(e);
+          }
+        });
   }
 
   public static void findJavaSources(
@@ -185,7 +200,7 @@ public static void findJavaSources(
   }
 
   public static void findJavaClasses(
-      Map<String, List<InputStreamProvider>> classes, List<String> searchPaths) {
+      Map<String, List<InputStream>> classes, List<String> searchPaths) {
     find(
         classes,
         searchPaths,

pkgs/jnigen/java/src/main/java/com/github/dart_lang/jnigen/apisummarizer/util/FileInputStreamProvider.java

@@ -0,0 +1,78 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.github.dart_lang.jnigen.apisummarizer.util;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.Opcodes;
+
+public class JavaCoreClassFinder {
+  private static List<String> findInnerClasses(InputStream inputStream) throws IOException {
+    List<String> innerClasses = new ArrayList<>();
+    ClassReader classReader = new ClassReader(inputStream);
+
+    classReader.accept(
+        new ClassVisitor(Opcodes.ASM9) {
+          @Override
+          public void visitInnerClass(String name, String outerName, String innerName, int access) {
+            innerClasses.add(name.replace('/', '.'));
+            super.visitInnerClass(name, outerName, innerName, access);
+          }
+        },
+        0);
+
+    return innerClasses;
+  }
+
+  private static InputStream find(String className) {
+    String classPath = "/" + className.replace('.', '/') + ".class";
+    URI uri = URI.create("jrt:/");
+    Map<String, String> env = new HashMap<>();
+    try (var fs = FileSystems.newFileSystem(uri, env)) {
+      Path path = fs.getPath("modules/java.base", classPath);
+      if (Files.notExists(path)) {
+        return null;
+      }
+      return Files.newInputStream(path);
+    } catch (IOException e) {
+      return null;
+    }
+  }
+
+  /// Finds the class and all its inner classes.
+  public static Map<String, InputStream> findAll(String className) throws IOException {
+    var classes = new HashMap<String, InputStream>();
+    var classInputStream = find(className);
+    if (classInputStream == null) {
+      return null;
+    }
+    var bytes = classInputStream.readAllBytes();
+    classInputStream.close();
+    classes.put(className, new ByteArrayInputStream(bytes));
+    try {
+      var innerClasses = findInnerClasses(new ByteArrayInputStream(bytes));
+      for (var innerClass : innerClasses) {
+        var innerClassInputStream = find(innerClass);
+        if (innerClassInputStream != null) {
+          classes.put(innerClass, innerClassInputStream);
+        }
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+    return classes;
+  }
+}

pkgs/jnigen/java/src/main/java/com/github/dart_lang/jnigen/apisummarizer/util/InputStreamProvider.java

@@ -0,0 +1,31 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:jnigen/src/config/config_types.dart';
+import 'package:test/test.dart';
+
+import 'test_util/test_util.dart';
+
+void main() {
+  test('Java core libraries are generated without providing class path',
+      () async {
+    await generateAndAnalyzeBindings(
+      Config(
+        outputConfig: OutputConfig(
+          dartConfig: DartCodeOutputConfig(
+            path: Uri.file('foo.dart'),
+            structure: OutputStructure.singleFile,
+          ),
+        ),
+        classes: [
+          // A random assortment of Java core classes.
+          'java.lang.StringBuilder',
+          'java.lang.ModuleLayer',
+          'java.net.SocketOption',
+        ],
+      ),
+      confirmExists: ['StringBuilder', 'ModuleLayer', 'SocketOption'],
+    );
+  });
+}

pkgs/jnigen/java/src/main/java/com/github/dart_lang/jnigen/apisummarizer/util/JarEntryInputStreamProvider.java

@@ -131,7 +131,8 @@ Future<void> generateAndCompareBindings(Config config) async {
   }
 }
 
-Future<void> generateAndAnalyzeBindings(Config config) async {
+Future<void> generateAndAnalyzeBindings(Config config,
+    {Iterable<String> confirmExists = const []}) async {
   final tempDir = Directory.current.createTempSync('jnigen_test_temp');
   try {
     await _generateTempBindings(config, tempDir);
@@ -140,6 +141,21 @@ Future<void> generateAndAnalyzeBindings(Config config) async {
       stderr.write(analyzeResult.stdout);
       fail('Analyzer exited with non-zero status (${analyzeResult.exitCode})');
     }
+    final singleFile =
+        config.outputConfig.dartConfig.structure == OutputStructure.singleFile;
+    if (!singleFile && confirmExists.isNotEmpty) {
+      throw UnimplementedError('Currently only supports single file mode '
+          'for confirming that classes exists');
+    } else if (singleFile && confirmExists.isNotEmpty) {
+      final generatedCode =
+          await File.fromUri(tempDir.uri.resolve('generated.dart'))
+              .readAsString();
+      for (final className in confirmExists) {
+        if (!generatedCode.contains(className)) {
+          fail('$className does not exist in the generated bindings');
+        }
+      }
+    }
   } finally {
     tempDir.deleteSync(recursive: true);
   }