Adapt Truffle to queried-only methods

Author: loicottet

sdk/src/org.graalvm.nativeimage/snapshot.sigtest

@@ -257,6 +257,7 @@ meth public java.lang.Class<?> getDeclaringClass()
 meth public java.lang.Class<?> getElementType()
 meth public java.lang.Class<?>[] getParameterTypes()
 meth public java.lang.String getElementName()
+meth public static boolean isInvocable(java.lang.reflect.Executable)
 supr java.lang.LinkageError
 hfds declaringClass,elementName,elementType,parameterTypes,serialVersionUID
 

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/MissingReflectionRegistrationError.java

@@ -42,9 +42,12 @@
 
 import java.io.Serial;
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
+import org.graalvm.nativeimage.impl.ReflectionIntrospector;
+
 /**
  * This exception is thrown when a reflective query (such as
  * {@link Class#getMethod(String, Class[])}) tries to access an element that was not <a href=
@@ -152,4 +155,14 @@ public String getElementName() {
     public Class<?>[] getParameterTypes() {
         return parameterTypes;
     }
+
+    /**
+     * @return Whether the executable can be invoked without throwing a
+     *         {@link MissingReflectionRegistrationError}.
+     *
+     * @since 25.1
+     */
+    public static boolean isInvocable(Executable executable) {
+        return !ImageSingletons.contains(ReflectionIntrospector.class) || ImageSingletons.lookup(ReflectionIntrospector.class).isInvocable(executable);
+    }
 }

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/ReflectionIntrospector.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package org.graalvm.nativeimage.impl;
+
+import java.lang.reflect.Executable;
+
+/**
+ * Provides an interface to query whether an executable has invocation capabilities, or was only
+ * registered for reflective queries.
+ */
+public interface ReflectionIntrospector {
+    boolean isInvocable(Executable executable);
+}

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/ReflectionIntrospectorImpl.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.svm.core.reflect;
+
+import com.oracle.svm.core.SubstrateUtil;
+import com.oracle.svm.core.reflect.target.Target_java_lang_reflect_Constructor;
+import com.oracle.svm.core.reflect.target.Target_java_lang_reflect_Method;
+import org.graalvm.nativeimage.impl.ReflectionIntrospector;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
+import java.lang.reflect.Method;
+
+public class ReflectionIntrospectorImpl implements ReflectionIntrospector {
+    @Override
+    public boolean isInvocable(Executable executable) {
+        switch (executable) {
+            case Method method -> {
+                Target_java_lang_reflect_Method methodSubstitution = SubstrateUtil.cast(method, Target_java_lang_reflect_Method.class);
+                return methodSubstitution.methodAccessor != null || methodSubstitution.methodAccessorFromMetadata != null;
+            }
+            case Constructor<?> constructor -> {
+                Target_java_lang_reflect_Constructor constructorSubstitution = SubstrateUtil.cast(constructor, Target_java_lang_reflect_Constructor.class);
+                return constructorSubstitution.constructorAccessor != null || constructorSubstitution.constructorAccessorFromMetadata != null;
+            }
+        }
+    }
+}

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/serialize/SerializationSupport.java

@@ -25,8 +25,6 @@
  */
 package com.oracle.svm.core.reflect.serialize;
 
-import static com.oracle.svm.core.SubstrateOptions.ThrowMissingRegistrationErrors;
-
 import java.io.Serializable;
 import java.lang.invoke.SerializedLambda;
 import java.lang.reflect.Constructor;
@@ -284,14 +282,8 @@ public static Object getSerializationConstructorAccessor(Class<?> serializationT
         }
 
         String targetConstructorClassName = targetConstructorClass.getName();
-        if (ThrowMissingRegistrationErrors.hasBeenSet()) {
-            MissingSerializationRegistrationUtils.reportSerialization(declaringClass,
-                            "type '" + declaringClass.getTypeName() + "' with target constructor class '" + targetConstructorClassName + "'");
-        } else {
-            throw VMError.unsupportedFeature("SerializationConstructorAccessor class not found for declaringClass: " + declaringClass.getName() +
-                            " (targetConstructorClass: " + targetConstructorClassName + "). Usually adding " + declaringClass.getName() +
-                            " to serialization-config.json fixes the problem.");
-        }
+        MissingSerializationRegistrationUtils.reportSerialization(declaringClass,
+                        "type '" + declaringClass.getTypeName() + "' with target constructor class '" + targetConstructorClassName + "'");
         return null;
     }
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/target/Target_java_lang_reflect_Constructor.java

@@ -78,7 +78,7 @@ public final class Target_java_lang_reflect_Constructor {
      */
     @Inject //
     @RecomputeFieldValue(kind = Kind.Reset) //
-    Target_jdk_internal_reflect_ConstructorAccessor constructorAccessorFromMetadata;
+    public Target_jdk_internal_reflect_ConstructorAccessor constructorAccessorFromMetadata;
 
     @Alias
     @TargetElement(name = CONSTRUCTOR_NAME)

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/reflect/target/Target_java_lang_reflect_Method.java

@@ -117,7 +117,7 @@ public final class Target_java_lang_reflect_Method {
      */
     @Inject //
     @RecomputeFieldValue(kind = Kind.Reset) //
-    Target_jdk_internal_reflect_MethodAccessor methodAccessorFromMetadata;
+    public Target_jdk_internal_reflect_MethodAccessor methodAccessorFromMetadata;
 
     @Inject //
     @RecomputeFieldValue(kind = Kind.Custom, declClass = LayerIdComputer.class) //

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionFeature.java

@@ -46,6 +46,7 @@
 import org.graalvm.nativeimage.dynamicaccess.AccessCondition;
 import org.graalvm.nativeimage.hosted.RuntimeReflection;
 import org.graalvm.nativeimage.impl.AnnotationExtractor;
+import org.graalvm.nativeimage.impl.ReflectionIntrospector;
 import org.graalvm.nativeimage.impl.RuntimeJNIAccessSupport;
 import org.graalvm.nativeimage.impl.RuntimeProxyRegistrySupport;
 import org.graalvm.nativeimage.impl.RuntimeReflectionSupport;
@@ -73,6 +74,7 @@
 import com.oracle.svm.core.meta.MethodPointer;
 import com.oracle.svm.core.meta.MethodRef;
 import com.oracle.svm.core.reflect.ReflectionAccessorHolder;
+import com.oracle.svm.core.reflect.ReflectionIntrospectorImpl;
 import com.oracle.svm.core.reflect.SubstrateAccessor;
 import com.oracle.svm.core.reflect.SubstrateConstructorAccessor;
 import com.oracle.svm.core.reflect.SubstrateMethodAccessor;
@@ -310,6 +312,8 @@ public void afterRegistration(AfterRegistrationAccess access) {
         ImageSingletons.add(RuntimeReflectionSupport.class, reflectionData);
         ImageSingletons.add(ReflectionHostedSupport.class, reflectionData);
 
+        ImageSingletons.add(ReflectionIntrospector.class, new ReflectionIntrospectorImpl());
+
         /*
          * Querying Object members is allowed to enable these accesses on array classes, since those
          * don't define any additional members.

truffle/src/com.oracle.truffle.host/src/com/oracle/truffle/host/HostInteropReflect.java

@@ -187,20 +187,14 @@ static boolean isModifiable(HostObject object, Class<?> clazz, String name, bool
     static boolean isInvokable(HostObject object, Class<?> clazz, String name, boolean onlyStatic) {
         HostClassDesc classDesc = HostClassDesc.forClass(object.context, clazz);
         HostMethodDesc foundMethod = classDesc.lookupMethod(name, onlyStatic);
-        if (foundMethod != null) {
-            return true;
-        } else if (isSignature(name)) {
-            foundMethod = classDesc.lookupMethodBySignature(name, onlyStatic);
-            if (foundMethod != null) {
-                return true;
-            }
-        } else if (isJNIName(name)) {
-            foundMethod = classDesc.lookupMethodByJNIName(name, onlyStatic);
-            if (foundMethod != null) {
-                return true;
+        if (foundMethod == null) {
+            if (isSignature(name)) {
+                foundMethod = classDesc.lookupMethodBySignature(name, onlyStatic);
+            } else if (isJNIName(name)) {
+                foundMethod = classDesc.lookupMethodByJNIName(name, onlyStatic);
             }
         }
-        return false;
+        return foundMethod != null && foundMethod.isInvocable();
     }
 
     @TruffleBoundary

truffle/src/com.oracle.truffle.host/src/com/oracle/truffle/host/HostMethodDesc.java

@@ -77,6 +77,8 @@ boolean isInternal() {
 
     abstract boolean isConstructor();
 
+    abstract boolean isInvocable();
+
     abstract static class SingleMethod extends HostMethodDesc {
 
         static final int[] EMTPY_SCOPED_PARAMETERS = new int[0];
@@ -143,6 +145,25 @@ public boolean isOnlyVisibleFromJniName() {
 
         public abstract Executable getReflectionMethod();
 
+        private static final Method isInvocableMethod = TruffleOptions.AOT ? getIsInvocableMethod() : null;
+
+        private static Method getIsInvocableMethod() {
+            try {
+                return Class.forName("org.graalvm.nativeimage.MissingReflectionRegistrationError").getMethod("isInvocable", Executable.class);
+            } catch (ClassNotFoundException | NoSuchMethodException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        @Override
+        boolean isInvocable() {
+            try {
+                return !TruffleOptions.AOT || (boolean) isInvocableMethod.invoke(null, getReflectionMethod());
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
         public final boolean isVarArgs() {
             return varArgs;
         }
@@ -598,6 +619,16 @@ public boolean isInternal() {
             }
             return true;
         }
+
+        @Override
+        boolean isInvocable() {
+            for (SingleMethod overload : overloads) {
+                if (!overload.isInvocable()) {
+                    return false;
+                }
+            }
+            return true;
+        }
     }
 
 }