refactoring

Author: aloubyansky

core/deployment/src/main/java/io/quarkus/deployment/pkg/steps/ClassLoadingChainAnalyzer.java

@@ -38,8 +38,9 @@
  * <h3>Phase 1 -- Bytecode analysis (seed propagation)</h3>
  * <p>
  * Scans all reachable classes and builds a method-level call graph. Starting from seed
- * methods ({@code ClassLoader.loadClass(String)}, {@code Class.forName(String)}, and
- * {@code Class.forName(String, boolean, ClassLoader)}), propagates backwards through the
+ * methods ({@code ClassLoader.loadClass(String)}, {@code Class.forName(String)},
+ * {@code Class.forName(String, boolean, ClassLoader)}, and
+ * {@code MethodHandles.Lookup.findClass(String)}), propagates backwards through the
  * call graph using a fixed-point algorithm to identify every application method that
  * transitively calls a class-loading seed. JDK and infrastructure classes
  * ({@code java/}, {@code javax/}, {@code jakarta/}, {@code sun/}, {@code org/objectweb/})
@@ -96,9 +97,12 @@ class ClassLoadingChainAnalyzer {
 
     private static final Logger log = Logger.getLogger(ClassLoadingChainAnalyzer.class.getName());
 
-    private static final String CLASSLOADER_LOAD_CLASS = "java/lang/ClassLoader.loadClass(Ljava/lang/String;)Ljava/lang/Class;";
-    private static final String CLASS_FOR_NAME_1 = "java/lang/Class.forName(Ljava/lang/String;)Ljava/lang/Class;";
-    private static final String CLASS_FOR_NAME_3 = "java/lang/Class.forName(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;";
+    /** JDK methods that load classes by name — the seeds for call chain propagation. */
+    private static final Set<String> SEED_METHODS = Set.of(
+            "java/lang/ClassLoader.loadClass(Ljava/lang/String;)Ljava/lang/Class;",
+            "java/lang/Class.forName(Ljava/lang/String;)Ljava/lang/Class;",
+            "java/lang/Class.forName(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;",
+            "java/lang/invoke/MethodHandles$Lookup.findClass(Ljava/lang/String;)Ljava/lang/Class;");
 
     private static final int MAX_CALLER_DEPTH = 5;
 
@@ -121,16 +125,14 @@ static Set<String> analyze(
         Map<String, Set<String>> callerIndex = new HashMap<>();
         Set<String> classLoadingMethods = findClassLoadingMethods(reachableClasses, allBytecode, callerIndex);
         if (classLoadingMethods.isEmpty()) {
-            log.debug("No class-loading methods found in reachable classes");
-            return new HashSet<>();
+            return Set.of();
         }
         log.debugf("Found %d class-loading methods", classLoadingMethods.size());
 
         // Phase 2: Find entry point classes
         Set<String> entryPointClasses = findEntryPointClasses(classLoadingMethods, callerIndex);
         if (entryPointClasses.isEmpty()) {
-            log.debug("No entry point classes found for class-loading chains");
-            return new HashSet<>();
+            return Set.of();
         }
         log.debugf("Found %d entry point classes for class-loading chains", entryPointClasses.size());
 
@@ -154,14 +156,22 @@ private static Set<String> findClassLoadingMethods(
             Map<String, Supplier<byte[]>> allBytecode,
             Map<String, Set<String>> callerIndex) {
 
-        // Seed set
-        Set<String> classLoadingMethods = new HashSet<>();
-        classLoadingMethods.add(CLASSLOADER_LOAD_CLASS);
-        classLoadingMethods.add(CLASS_FOR_NAME_1);
-        classLoadingMethods.add(CLASS_FOR_NAME_3);
+        Map<String, Set<String>> methodCallees = buildCallGraph(reachableClasses, allBytecode, callerIndex);
+        return propagateFromSeeds(methodCallees);
+    }
+
+    /**
+     * Scans reachable bytecode and builds two maps in a single pass:
+     * <ul>
+     * <li>{@code methodCallees}: method → set of methods it calls</li>
+     * <li>{@code callerIndex}: method → set of methods that call it (reverse index)</li>
+     * </ul>
+     */
+    private static Map<String, Set<String>> buildCallGraph(
+            Set<String> reachableClasses,
+            Map<String, Supplier<byte[]>> allBytecode,
+            Map<String, Set<String>> callerIndex) {
 
-        // Build method call graph and caller index in one pass
-        // methodCallees: method -> set of methods it calls
         Map<String, Set<String>> methodCallees = new HashMap<>();
 
         for (String className : reachableClasses) {
@@ -195,8 +205,17 @@ public void visitMethodInsn(int opcode, String owner, String mname,
             }, ClassReader.SKIP_FRAMES | ClassReader.SKIP_DEBUG);
         }
 
-        // Propagate to fixed point: if method A calls method B which is a class-loading method
-        // (and B is not a JDK/infra class), then A is also a class-loading method
+        return methodCallees;
+    }
+
+    /**
+     * Starting from {@link #SEED_METHODS}, propagates through the call graph to find all
+     * application methods that transitively call a class-loading seed.
+     * JDK/infrastructure methods are excluded from propagation.
+     */
+    private static Set<String> propagateFromSeeds(Map<String, Set<String>> methodCallees) {
+        Set<String> classLoadingMethods = new HashSet<>(SEED_METHODS);
+
         boolean changed = true;
         while (changed) {
             changed = false;
@@ -217,11 +236,7 @@ public void visitMethodInsn(int opcode, String owner, String mname,
             }
         }
 
-        // Remove the seed JDK methods
-        classLoadingMethods.remove(CLASSLOADER_LOAD_CLASS);
-        classLoadingMethods.remove(CLASS_FOR_NAME_1);
-        classLoadingMethods.remove(CLASS_FOR_NAME_3);
-
+        classLoadingMethods.removeAll(SEED_METHODS);
         return classLoadingMethods;
     }
 
@@ -280,33 +295,26 @@ private static Set<String> findEntryPointClasses(
     }
 
     /**
-     * Extracts the method name from a method key like "com/example/Foo.methodName(Ljava/lang/String;)V".
+     * Finds the dot+paren boundary in a method key like "com/example/Foo.methodName(...)V".
+     * Returns the dot index, or -1 if the key is malformed.
      */
-    private static String extractMethodName(String methodKey) {
+    private static int findMethodSeparator(String methodKey) {
         int parenIdx = methodKey.indexOf('(');
-        if (parenIdx < 0) {
-            return null;
-        }
-        int dotIdx = methodKey.lastIndexOf('.', parenIdx);
-        if (dotIdx < 0) {
-            return null;
-        }
-        return methodKey.substring(dotIdx + 1, parenIdx);
+        return parenIdx < 0 ? -1 : methodKey.lastIndexOf('.', parenIdx);
+    }
+
+    /** Extracts the method name from a key like {@code "com/example/Foo.bar(I)V"} → {@code "bar"}. */
+    private static String extractMethodName(String methodKey) {
+        int dotIdx = findMethodSeparator(methodKey);
+        return dotIdx < 0 ? null : methodKey.substring(dotIdx + 1, methodKey.indexOf('('));
     }
 
     /**
-     * Extracts the class name (internal form) from a method key.
+     * Extracts the class name (internal form) from a key like {@code "com/example/Foo.bar(I)V"} → {@code "com/example/Foo"}.
      */
     private static String extractClassName(String methodKey) {
-        int parenIdx = methodKey.indexOf('(');
-        if (parenIdx < 0) {
-            return null;
-        }
-        int dotIdx = methodKey.lastIndexOf('.', parenIdx);
-        if (dotIdx < 0) {
-            return null;
-        }
-        return methodKey.substring(0, dotIdx);
+        int dotIdx = findMethodSeparator(methodKey);
+        return dotIdx < 0 ? null : methodKey.substring(0, dotIdx);
     }
 
     /**
@@ -318,9 +326,29 @@ private static Set<String> executeWithRecordingClassLoader(
             Map<String, Supplier<byte[]>> allBytecode,
             Set<String> allKnownClasses) {
 
+        Map<String, byte[]> bytecodeMap = resolveBytecodeMap(allBytecode);
         Set<String> allDiscovered = new HashSet<>();
 
-        // Resolve bytecode once for all entry points
+        // Suppress stdout/stderr: loaded classes may print warnings or stack traces
+        // during their static initialization. These are expected and harmless.
+        java.io.PrintStream originalOut = System.out;
+        java.io.PrintStream originalErr = System.err;
+        try {
+            System.setOut(new java.io.PrintStream(java.io.OutputStream.nullOutputStream()));
+            System.setErr(new java.io.PrintStream(java.io.OutputStream.nullOutputStream()));
+            for (String entryPoint : entryPointClasses) {
+                executeEntryPoint(entryPoint, bytecodeMap, allKnownClasses, allDiscovered);
+            }
+        } finally {
+            System.setOut(originalOut);
+            System.setErr(originalErr);
+        }
+
+        return allDiscovered;
+    }
+
+    /** Resolves all bytecode suppliers into a concrete map for use by the RecordingClassLoader. */
+    private static Map<String, byte[]> resolveBytecodeMap(Map<String, Supplier<byte[]>> allBytecode) {
         Map<String, byte[]> bytecodeMap = new HashMap<>();
         for (Map.Entry<String, Supplier<byte[]>> entry : allBytecode.entrySet()) {
             try {
@@ -329,57 +357,51 @@ private static Set<String> executeWithRecordingClassLoader(
                 // skip unreadable classes
             }
         }
+        return bytecodeMap;
+    }
 
-        // Suppress stdout/stderr during recording: loaded classes (BouncyCastle, SLF4J, etc.)
-        // may print warnings, stack traces, or status messages during their static initialization.
-        // These are expected and harmless — redirect to a null stream to keep the build log clean.
-        java.io.PrintStream originalOut = System.out;
-        java.io.PrintStream originalErr = System.err;
-        java.io.PrintStream nullStream = new java.io.PrintStream(java.io.OutputStream.nullOutputStream());
-        try {
-            System.setOut(nullStream);
-            System.setErr(nullStream);
-            for (String entryPoint : entryPointClasses) {
-                log.debugf("Executing entry point class: %s", entryPoint);
-
-                RecordingClassLoader loader = new RecordingClassLoader(bytecodeMap);
-
-                try {
-                    Class<?> clazz = Class.forName(entryPoint, true, loader);
-                    try {
-                        Object instance = clazz.getConstructor().newInstance();
-                        // If the instance is a Map (like BouncyCastle's Provider which extends Properties),
-                        // iterate values and record strings that match known classes
-                        if (instance instanceof java.util.Map) {
-                            java.util.Map<?, ?> map = (java.util.Map<?, ?>) instance;
-                            for (Object value : map.values()) {
-                                if (value instanceof String) {
-                                    String strValue = (String) value;
-                                    if (allKnownClasses.contains(strValue)) {
-                                        allDiscovered.add(strValue);
-                                    }
-                                }
-                            }
-                        }
-                    } catch (Exception e) {
-                        log.debugf("Could not instantiate entry point %s: %s", entryPoint, e.getMessage());
-                    } catch (LinkageError e) {
-                        log.debugf("LinkageError instantiating entry point %s: %s", entryPoint, e.getMessage());
-                    }
-                } catch (Exception e) {
-                    log.debugf("Could not load entry point %s: %s", entryPoint, e.getMessage());
-                } catch (LinkageError e) {
-                    log.debugf("LinkageError loading entry point %s: %s", entryPoint, e.getMessage());
-                }
+    /**
+     * Loads and instantiates a single entry point class in a fresh RecordingClassLoader.
+     * Records all class load attempts, plus class name strings from Map values.
+     */
+    private static void executeEntryPoint(String entryPoint, Map<String, byte[]> bytecodeMap,
+            Set<String> allKnownClasses, Set<String> discovered) {
+        log.debugf("Executing entry point class: %s", entryPoint);
+        RecordingClassLoader loader = new RecordingClassLoader(bytecodeMap);
 
-                allDiscovered.addAll(loader.getLoadedClassNames());
+        try {
+            Class<?> clazz = Class.forName(entryPoint, true, loader);
+            try {
+                Object instance = clazz.getConstructor().newInstance();
+                collectClassNamesFromMapValues(instance, allKnownClasses, discovered);
+            } catch (Exception e) {
+                log.debugf("Could not instantiate entry point %s: %s", entryPoint, e.getMessage());
+            } catch (LinkageError e) {
+                log.debugf("LinkageError instantiating entry point %s: %s", entryPoint, e.getMessage());
             }
-        } finally {
-            System.setOut(originalOut);
-            System.setErr(originalErr);
+        } catch (Exception e) {
+            log.debugf("Could not load entry point %s: %s", entryPoint, e.getMessage());
+        } catch (LinkageError e) {
+            log.debugf("LinkageError loading entry point %s: %s", entryPoint, e.getMessage());
         }
 
-        return allDiscovered;
+        discovered.addAll(loader.getLoadedClassNames());
+    }
+
+    /**
+     * If the object is a Map (e.g., BouncyCastle's Provider extends Properties),
+     * extracts String values that match known class names. These are class names stored
+     * via methods like {@code addAlgorithm(key, className)} for deferred loading.
+     */
+    private static void collectClassNamesFromMapValues(Object instance,
+            Set<String> allKnownClasses, Set<String> discovered) {
+        if (instance instanceof java.util.Map<?, ?> map) {
+            for (Object value : map.values()) {
+                if (value instanceof String strValue && allKnownClasses.contains(strValue)) {
+                    discovered.add(strValue);
+                }
+            }
+        }
     }
 
     /**

core/deployment/src/main/java/io/quarkus/deployment/pkg/steps/JarTreeShaker.java

@@ -177,7 +177,6 @@ private Set<String> traceReachableClasses(Set<String> startingRoots, Set<String>
             }
 
             enqueueBytecodeReferences(name, bytecode, allKnownClasses, visited, queue);
-            includeAllClassesIfDynamicLoading(name, bytecode, visited, queue);
             includeDeserializedClasses(name, bytecode, depDeserializationFlags, visited, queue);
         }
         return visited;
@@ -330,25 +329,6 @@ private void enqueueBytecodeReferences(String name, byte[] bytecode, Set<String>
         }
     }
 
-    /**
-     * If this class uses dynamic class loading (MethodHandles.Lookup.findClass),
-     * include all classes from the same dependency since the loaded class names
-     * are constructed at runtime and can't be statically determined.
-     */
-    private void includeAllClassesIfDynamicLoading(String name, byte[] bytecode, Set<String> visited,
-            Queue<String> queue) {
-        ArtifactKey depKey = input.classToDep.get(name);
-        if (depKey != null && usesDynamicClassLoading(bytecode)) {
-            log.debugf("Dynamic class loading detected in %s, keeping all classes from %s", name, depKey);
-            for (var entry : input.classToDep.entrySet()) {
-                if (depKey.equals(entry.getValue()) && visited.add(entry.getKey())) {
-                    queue.add(entry.getKey());
-                }
-            }
-        }
-
-    }
-
     private static final int FLAG_RESOURCE_ACCESS = 1;
     private static final int FLAG_OBJECT_INPUT_STREAM = 2;
     private static final int FLAG_RESOURCE_DESERIALIZATION = FLAG_RESOURCE_ACCESS | FLAG_OBJECT_INPUT_STREAM;
@@ -925,37 +905,6 @@ private static String formatSize(long bytes) {
         return String.format("%.1f MB", bytes / (1024.0 * 1024.0));
     }
 
-    /**
-     * Detects whether bytecode uses dynamic class loading patterns where class names
-     * are constructed at runtime (e.g. MethodHandles.Lookup.findClass). When detected,
-     * all classes from the same dependency must be preserved since the loaded class names
-     * can't be statically determined.
-     */
-    private static boolean usesDynamicClassLoading(byte[] bytecode) {
-        boolean[] found = new boolean[1];
-        ClassReader reader = new ClassReader(bytecode);
-        reader.accept(new ClassVisitor(Opcodes.ASM9) {
-            @Override
-            public MethodVisitor visitMethod(int access, String name, String descriptor,
-                    String signature, String[] exceptions) {
-                if (found[0]) {
-                    return null;
-                }
-                return new MethodVisitor(Opcodes.ASM9) {
-                    @Override
-                    public void visitMethodInsn(int opcode, String owner, String mname,
-                            String mdescriptor, boolean isInterface) {
-                        if ("findClass".equals(mname)
-                                && "java/lang/invoke/MethodHandles$Lookup".equals(owner)) {
-                            found[0] = true;
-                        }
-                    }
-                };
-            }
-        }, ClassReader.SKIP_FRAMES | ClassReader.SKIP_DEBUG);
-        return found[0];
-    }
-
     /**
      * Checks whether bytecode contains both an LDC string constant for the sisu named resource path
      * and a ClassLoader.getResources()/getResource() call. These may be in different methods