Register all polyglot java import classes for refective access

build.sbt

@@ -2433,14 +2433,15 @@ lazy val `engine-runner` = project
             // "-g",
             // "-H:+SourceLevelDebug",
             // "-H:-DeleteLocalSymbols",
+            // you may need to set smallJdk := None to use following flags:
+            // "--trace-class-initialization=org.enso.syntax2.Parser",
             "-Dnic=nic"
           ),
           mainClass = Some("org.enso.runner.Main"),
           initializeAtRuntime = Seq(
             "org.jline.nativ.JLineLibrary",
             "org.jline.terminal.impl.jna",
             "io.methvin.watchservice.jna.CarbonAPI",
-            "org.enso.syntax2.Parser",
             "zio.internal.ZScheduler$$anon$4",
             "org.enso.runner.Main$",
             "sun.awt",
@@ -2474,6 +2475,7 @@ lazy val `engine-runner` = project
   .dependsOn(`library-manager`)
   .dependsOn(`language-server`)
   .dependsOn(`edition-updater`)
+  .dependsOn(`runtime-parser`)
   .dependsOn(`logging-service`)
   .dependsOn(`logging-service-logback` % Runtime)
   .dependsOn(`polyglot-api`)

engine/runner/src/main/java/org/enso/runner/EnsoLibraryFeature.java

@@ -0,0 +1,77 @@
+package org.enso.runner;
+
+import static scala.jdk.javaapi.CollectionConverters.asJava;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.LinkedHashSet;
+import java.util.TreeSet;
+import org.enso.compiler.core.ir.module.scope.imports.Polyglot;
+import org.enso.pkg.PackageManager$;
+import org.graalvm.nativeimage.hosted.Feature;
+import org.graalvm.nativeimage.hosted.RuntimeReflection;
+
+public final class EnsoLibraryFeature implements Feature {
+  @Override
+  public void beforeAnalysis(BeforeAnalysisAccess access) {
+    var libs = new LinkedHashSet<Path>();
+    for (var p : access.getApplicationClassPath()) {
+      var p1 = p.getParent();
+      if (p1 != null && p1.getFileName().toString().equals("java")) {
+        var p2 = p1.getParent();
+        if (p2 != null
+            && p2.getFileName().toString().equals("polyglot")
+            && p2.getParent() != null) {
+          libs.add(p2.getParent());
+        }
+      }
+    }
+
+    var classes = new TreeSet<String>();
+    try (var parser = new org.enso.compiler.core.EnsoParser()) {
+      for (var p : libs) {
+        var result = PackageManager$.MODULE$.Default().loadPackage(p.toFile());
+        if (result.isSuccess()) {
+          var pkg = result.get();
+          for (var src : pkg.listSourcesJava()) {
+            var code = Files.readString(src.file().toPath());
+            var ir = parser.compile(code);
+            for (var imp : asJava(ir.imports())) {
+              if (imp instanceof Polyglot poly && poly.entity() instanceof Polyglot.Java entity) {
+                var name = new StringBuilder(entity.getJavaName());
+                Class<?> clazz;
+                for (; ; ) {
+                  clazz = access.findClassByName(name.toString());
+                  if (clazz != null) {
+                    break;
+                  }
+                  int at = name.toString().lastIndexOf('.');
+                  if (at < 0) {
+                    throw new IllegalStateException("Cannot load " + entity.getJavaName());
+                  }
+                  name.setCharAt(at, '$');
+                }
+                classes.add(clazz.getName());
+                RuntimeReflection.register(clazz);
+                RuntimeReflection.register(clazz.getConstructors());
+                RuntimeReflection.register(clazz.getMethods());
+                RuntimeReflection.register(clazz.getFields());
+                RuntimeReflection.registerAllConstructors(clazz);
+                RuntimeReflection.registerAllFields(clazz);
+                RuntimeReflection.registerAllMethods(clazz);
+              }
+            }
+          }
+        }
+      }
+    } catch (Exception ex) {
+      ex.printStackTrace();
+      throw new IllegalStateException(ex);
+    }
+    System.err.println("Summary for polyglot import java:");
+    for (var className : classes) {
+      System.err.println("  " + className);
+    }
+    System.err.println("Registered " + classes.size() + " classes for reflection");
+  }
+}

engine/runner/src/main/resources/META-INF/native-image/org/enso/runner/native-image.properties

@@ -0,0 +1 @@
+Args=--features=org.enso.runner.EnsoLibraryFeature

engine/runtime/src/main/java/org/enso/interpreter/runtime/EnsoContext.java

@@ -28,7 +28,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
@@ -522,34 +521,35 @@ public boolean isColorTerminalOutput() {
    */
   @TruffleBoundary
   public Object lookupJavaClass(String className) {
-    var items = Arrays.asList(className.split("\\."));
+    var binaryName = new StringBuilder(className);
     var collectedExceptions = new ArrayList<Exception>();
-    for (int i = items.size() - 1; i >= 0; i--) {
-      String pkgName = String.join(".", items.subList(0, i));
-      String curClassName = items.get(i);
-      List<String> nestedClassPart =
-          i < items.size() - 1 ? items.subList(i + 1, items.size()) : List.of();
+    for (; ; ) {
+      var fqn = binaryName.toString();
       try {
-        var hostSymbol = lookupHostSymbol(pkgName, curClassName);
-        if (nestedClassPart.isEmpty()) {
+        var hostSymbol = lookupHostSymbol(fqn);
+        if (hostSymbol != null) {
           return hostSymbol;
-        } else {
-          var fullInnerClassName = curClassName + "$" + String.join("$", nestedClassPart);
-          return lookupHostSymbol(pkgName, fullInnerClassName);
         }
       } catch (ClassNotFoundException | RuntimeException | InteropException ex) {
         collectedExceptions.add(ex);
       }
+      var at = fqn.lastIndexOf('.');
+      if (at < 0) {
+        break;
+      }
+      binaryName.setCharAt(at, '$');
     }
+    var level = Level.WARNING;
     for (var ex : collectedExceptions) {
-      logger.log(Level.WARNING, null, ex);
+      logger.log(level, ex.getMessage());
+      level = Level.FINE;
+      logger.log(Level.FINE, null, ex);
     }
     return null;
   }
 
-  private Object lookupHostSymbol(String pkgName, String curClassName)
+  private Object lookupHostSymbol(String fqn)
       throws ClassNotFoundException, UnknownIdentifierException, UnsupportedMessageException {
-    var fqn = pkgName + "." + curClassName;
     try {
       if (findGuestJava() == null) {
         return environment.asHostSymbol(hostClassLoader.loadClass(fqn));

lib/rust/parser/generate-java/java/org/enso/syntax2/Parser.java

@@ -7,7 +7,7 @@
 import java.nio.charset.StandardCharsets;
 
 public final class Parser implements AutoCloseable {
-  static {
+  private static void initializeLibraries() {
     String os = System.getProperty("os.name");
     String name;
     if (os.startsWith("Mac")) {
@@ -77,6 +77,7 @@ private Parser(long stateIn) {
   static native long getUuidLow(long metadata, long codeOffset, long codeLength);
 
   public static Parser create() {
+    initializeLibraries();
     var state = allocState();
     return new Parser(state);
   }

std-bits/base/src/main/java/org/enso/base/enso_cloud/audit/AuditLogAPI.java

@@ -22,8 +22,7 @@
 class AuditLogAPI {
   private static final Logger logger = Logger.getLogger(AuditLogAPI.class.getName());
   public static AuditLogAPI INSTANCE = new AuditLogAPI();
-  private final HttpClient httpClient =
-      HttpClient.newBuilder().followRedirects(HttpClient.Redirect.ALWAYS).build();
+  private HttpClient httpClient;
   private final ExecutorService executorService;
 
   private AuditLogAPI() {
@@ -70,6 +69,9 @@ private HttpRequest buildRequest(LogMessage message) {
   private void sendLogRequest(HttpRequest request, int retryCount) throws RequestFailureException {
     try {
       try {
+        if (httpClient == null) {
+          httpClient = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.ALWAYS).build();
+        }
         HttpResponse<String> response =
             httpClient.send(request, HttpResponse.BodyHandlers.ofString());
         if (response.statusCode() < 200 || response.statusCode() >= 300) {