Reduce usage of lambdas to reduce image size

Author: vjovanov

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/ConfigurationTypeDescriptor.java

@@ -29,6 +29,8 @@
 import java.util.Collection;
 import java.util.stream.Stream;
 
+import com.oracle.svm.util.StringUtil;
+
 import jdk.graal.compiler.java.LambdaUtils;
 import jdk.graal.compiler.util.json.JsonPrintable;
 
@@ -54,7 +56,7 @@ static ConfigurationTypeDescriptor fromClass(Class<?> clazz) {
         if (Proxy.isProxyClass(clazz)) {
             return ProxyConfigurationTypeDescriptor.fromInterfaceReflectionNames(interfacesStream.toList());
         } else if (LambdaUtils.isLambdaClass(clazz)) {
-            String declaringClass = LambdaUtils.capturingClass(clazz.getTypeName());
+            String declaringClass = StringUtil.split(clazz.getTypeName(), LambdaUtils.LAMBDA_CLASS_NAME_SUBSTRING)[0];
             return LambdaConfigurationTypeDescriptor.fromReflectionNames(declaringClass, interfacesStream.toList());
         } else {
             return NamedConfigurationTypeDescriptor.fromReflectionName(clazz.getTypeName());

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/LambdaConfigurationTypeDescriptor.java

@@ -33,22 +33,32 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Comparator;
 import java.util.List;
 
 import jdk.graal.compiler.util.json.JsonPrinter;
 import jdk.graal.compiler.util.json.JsonWriter;
 
 public record LambdaConfigurationTypeDescriptor(ConfigurationTypeDescriptor declaringClass, ConfigurationParser.ConfigurationMethodDescriptor declaringMethod,
                 List<NamedConfigurationTypeDescriptor> interfaces) implements ConfigurationTypeDescriptor {
+
+    public static final ConfigurationTypeDescriptor[] EMPTY_TYPE_DESCRIPTOR_ARRAY = new ConfigurationTypeDescriptor[0];
+
     public static LambdaConfigurationTypeDescriptor fromReflectionNames(String declaringClass, List<String> interfaces) {
-        return new LambdaConfigurationTypeDescriptor(NamedConfigurationTypeDescriptor.fromReflectionName(declaringClass), null,
-                        interfaces.stream().map(NamedConfigurationTypeDescriptor::fromReflectionName).toList());
+        return new LambdaConfigurationTypeDescriptor(NamedConfigurationTypeDescriptor.fromReflectionName(declaringClass),
+                        null, getNamedConfigurationTypeDescriptors(interfaces));
     }
 
     public static LambdaConfigurationTypeDescriptor fromTypeNames(String declaringClass, List<String> interfaces) {
         return new LambdaConfigurationTypeDescriptor(NamedConfigurationTypeDescriptor.fromTypeName(declaringClass), null,
-                        interfaces.stream().map(NamedConfigurationTypeDescriptor::fromTypeName).toList());
+                        getNamedConfigurationTypeDescriptors(interfaces));
+    }
+
+    private static List<NamedConfigurationTypeDescriptor> getNamedConfigurationTypeDescriptors(List<String> interfaces) {
+        List<NamedConfigurationTypeDescriptor> reflectionInterfaces = new ArrayList<>(interfaces.size());
+        for (var interfaceName : interfaces) {
+            reflectionInterfaces.add(NamedConfigurationTypeDescriptor.fromReflectionName(interfaceName));
+        }
+        return reflectionInterfaces;
     }
 
     @Override
@@ -67,11 +77,26 @@ public Collection<String> getAllQualifiedJavaNames() {
 
     @Override
     public int compareTo(ConfigurationTypeDescriptor other) {
-        if (other instanceof LambdaConfigurationTypeDescriptor lambdaOther) {
-            return Comparator.comparing(LambdaConfigurationTypeDescriptor::declaringClass)
-                            .thenComparing(LambdaConfigurationTypeDescriptor::declaringMethod, Comparator.nullsFirst(ConfigurationParser.ConfigurationMethodDescriptor::compareTo))
-                            .thenComparing((a, b) -> Arrays.compare(a.interfaces.toArray(ConfigurationTypeDescriptor[]::new), b.interfaces.toArray(ConfigurationTypeDescriptor[]::new)))
-                            .compare(this, lambdaOther);
+        if (other instanceof LambdaConfigurationTypeDescriptor otherLambda) {
+            int result = declaringClass.compareTo(otherLambda.declaringClass());
+            if (result != 0) {
+                return result;
+            }
+            // Compare declaringMethod with nullsFirst
+            if (this.declaringMethod() == null && otherLambda.declaringMethod() != null) {
+                return -1;
+            } else if (this.declaringMethod() != null && otherLambda.declaringMethod() == null) {
+                return 1;
+            } else if (this.declaringMethod() != null) {
+                result = this.declaringMethod().compareTo(otherLambda.declaringMethod());
+                if (result != 0) {
+                    return result;
+                }
+            }
+
+            return Arrays.compare(
+                            interfaces.toArray(EMPTY_TYPE_DESCRIPTOR_ARRAY),
+                            otherLambda.interfaces().toArray(EMPTY_TYPE_DESCRIPTOR_ARRAY));
         } else {
             return getDescriptorType().compareTo(other.getDescriptorType());
         }

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/config/ConfigurationType.java

@@ -498,10 +498,9 @@ public synchronized void printJson(JsonWriter writer) throws IOException {
             Set<ConfigurationMethod> accessedMethods = getMethodsByAccessibility(ConfigurationMemberAccessibility.ACCESSED);
             if (!accessedMethods.isEmpty()) {
                 writer.appendSeparator().quote("methods").appendFieldSeparator();
-                JsonPrinter.printCollection(writer,
-                                accessedMethods,
-                                Comparator.comparing(ConfigurationMethod::getName).thenComparing(Comparator.nullsFirst(Comparator.comparing(ConfigurationMethod::getInternalSignature))),
-                                JsonPrintable::printJson);
+                Comparator<ConfigurationMethod> methodComparator = Comparator.comparing(ConfigurationMethod::getName)
+                                .thenComparing(Comparator.nullsFirst(Comparator.comparing(ConfigurationMethod::getInternalSignature)));
+                JsonPrinter.printCollection(writer, accessedMethods, methodComparator, JsonPrintable::printJson);
             }
         }
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/MissingRegistrationUtils.java

@@ -47,6 +47,7 @@
 import com.oracle.svm.configure.config.ConfigurationType;
 import com.oracle.svm.core.util.ExitStatus;
 import com.oracle.svm.core.util.VMError;
+import com.oracle.svm.util.StringUtil;
 
 import jdk.graal.compiler.java.LambdaUtils;
 import jdk.graal.compiler.util.json.JsonPrettyWriter;
@@ -204,7 +205,7 @@ protected static String typeDescriptor(Class<?> clazz) {
         if (Proxy.isProxyClass(clazz)) {
             return "proxy class inheriting " + interfacesString(clazz.getInterfaces());
         } else if (LambdaUtils.isLambdaClass(clazz)) {
-            String declaringClass = LambdaUtils.capturingClass(clazz.getTypeName());
+            String declaringClass = StringUtil.split(clazz.getTypeName(), LambdaUtils.LAMBDA_CLASS_NAME_SUBSTRING)[0];
             return "lambda-proxy class declared in " + quote(declaringClass) + " inheriting " + interfacesString(clazz.getInterfaces());
         } else {
             return quote(clazz.getTypeName());