Do not differentiate configuration type descriptors based on whether they come from a name or type field

Author: loicottet

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/ConfigurationParser.java

@@ -262,21 +262,25 @@ private static JsonParserException failOnSchemaError(String message) {
         throw new JsonParserException(message);
     }
 
-    protected static Optional<ConfigurationTypeDescriptor> parseTypeOrName(EconomicMap<String, Object> data, boolean treatAllNameEntriesAsType) {
+    protected record TypeDescriptorWithOrigin(ConfigurationTypeDescriptor typeDescriptor, boolean definedAsType) {
+    }
+
+    protected static Optional<TypeDescriptorWithOrigin> parseTypeOrName(EconomicMap<String, Object> data, boolean treatAllNameEntriesAsType) {
         Object typeObject = data.get(TYPE_KEY);
         Object name = data.get(NAME_KEY);
         if (typeObject != null) {
-            return parseTypeContents(typeObject);
+            return parseTypeContents(typeObject).map(typeDescriptor -> new TypeDescriptorWithOrigin(typeDescriptor, true));
         } else if (name != null) {
-            return Optional.of(new NamedConfigurationTypeDescriptor(asString(name), treatAllNameEntriesAsType));
+            NamedConfigurationTypeDescriptor typeDescriptor = new NamedConfigurationTypeDescriptor(asString(name));
+            return Optional.of(new TypeDescriptorWithOrigin(typeDescriptor, treatAllNameEntriesAsType));
         } else {
             throw failOnSchemaError("must have type or name specified for an element");
         }
     }
 
     protected static Optional<ConfigurationTypeDescriptor> parseTypeContents(Object typeObject) {
         if (typeObject instanceof String stringValue) {
-            return Optional.of(new NamedConfigurationTypeDescriptor(stringValue, true));
+            return Optional.of(new NamedConfigurationTypeDescriptor(stringValue));
         } else {
             EconomicMap<String, Object> type = asMap(typeObject, "type descriptor should be a string or object");
             if (type.containsKey(PROXY_KEY)) {

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

@@ -71,6 +71,4 @@ static String checkQualifiedJavaName(String javaName) {
         assert javaName.indexOf('/') == -1 || javaName.indexOf('/') > javaName.lastIndexOf('.') : "Requires qualified Java name, not internal representation: %s".formatted(javaName);
         return canonicalizeTypeName(javaName);
     }
-
-    boolean definedAsType();
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/LegacyReflectionConfigurationParser.java

@@ -62,10 +62,11 @@ protected void parseClass(EconomicMap<String, Object> data) {
         checkAttributes(data, "reflection class descriptor object", Collections.emptyList(), OPTIONAL_REFLECT_CONFIG_OBJECT_ATTRS);
         checkHasExactlyOneAttribute(data, "reflection class descriptor object", List.of(NAME_KEY, TYPE_KEY));
 
-        Optional<ConfigurationTypeDescriptor> type = parseTypeOrName(data, treatAllNameEntriesAsType);
+        Optional<TypeDescriptorWithOrigin> type = parseTypeOrName(data, treatAllNameEntriesAsType);
         if (type.isEmpty()) {
             return;
         }
+        ConfigurationTypeDescriptor typeDescriptor = type.get().typeDescriptor();
         /*
          * Classes registered using the old ("name") syntax requires elements (fields, methods,
          * constructors, ...) to be registered for runtime queries, whereas the new ("type") syntax
@@ -84,9 +85,9 @@ protected void parseClass(EconomicMap<String, Object> data) {
          * allow getDeclaredMethods() and similar bulk queries at run time.
          */
         C condition = conditionResult.get();
-        TypeResult<T> result = delegate.resolveType(condition, type.get(), true);
+        TypeResult<T> result = delegate.resolveType(condition, typeDescriptor, true);
         if (!result.isPresent()) {
-            handleMissingElement("Could not resolve " + type.get() + " for reflection configuration.", result.getException());
+            handleMissingElement("Could not resolve " + typeDescriptor + " for reflection configuration.", result.getException());
             return;
         }
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/LegacySerializationConfigurationParser.java

@@ -89,26 +89,28 @@ protected void parseSerializationDescriptorObject(EconomicMap<String, Object> da
             checkHasExactlyOneAttribute(data, "serialization descriptor object", List.of(TYPE_KEY, NAME_KEY));
         }
 
-        Optional<ConfigurationTypeDescriptor> targetSerializationClass = parseTypeOrName(data, false);
-        if (targetSerializationClass.isEmpty()) {
+        Optional<TypeDescriptorWithOrigin> target = parseTypeOrName(data, false);
+        if (target.isEmpty()) {
             return;
         }
+        ConfigurationTypeDescriptor targetSerializationClass = target.get().typeDescriptor();
+        boolean definedAsType = target.get().definedAsType();
 
-        UnresolvedConfigurationCondition unresolvedCondition = parseCondition(data, targetSerializationClass.get().definedAsType());
+        UnresolvedConfigurationCondition unresolvedCondition = parseCondition(data, definedAsType);
         var condition = conditionResolver.resolveCondition(unresolvedCondition);
         if (!condition.isPresent()) {
             return;
         }
 
         if (lambdaCapturingType) {
-            String className = ((NamedConfigurationTypeDescriptor) targetSerializationClass.get()).name();
+            String className = ((NamedConfigurationTypeDescriptor) targetSerializationClass).name();
             serializationSupport.registerLambdaCapturingClass(condition.get(), className);
         } else {
             Object optionalCustomCtorValue = data.get(CUSTOM_TARGET_CONSTRUCTOR_CLASS_KEY);
             String customTargetConstructorClass = optionalCustomCtorValue != null ? asString(optionalCustomCtorValue) : null;
-            if (targetSerializationClass.get() instanceof NamedConfigurationTypeDescriptor namedClass) {
+            if (targetSerializationClass instanceof NamedConfigurationTypeDescriptor namedClass) {
                 serializationSupport.registerWithTargetConstructorClass(condition.get(), namedClass.name(), customTargetConstructorClass);
-            } else if (targetSerializationClass.get() instanceof ProxyConfigurationTypeDescriptor proxyClass) {
+            } else if (targetSerializationClass instanceof ProxyConfigurationTypeDescriptor proxyClass) {
                 serializationSupport.registerProxyClass(condition.get(), Arrays.asList(proxyClass.interfaceNames()));
             } else {
                 throw new JsonParserException("Unknown configuration type descriptor: %s".formatted(targetSerializationClass.toString()));

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/NamedConfigurationTypeDescriptor.java

@@ -30,20 +30,10 @@
 
 import jdk.graal.compiler.util.json.JsonWriter;
 
-public record NamedConfigurationTypeDescriptor(String name, boolean definedAsType) implements ConfigurationTypeDescriptor {
+public record NamedConfigurationTypeDescriptor(String name) implements ConfigurationTypeDescriptor {
 
     public NamedConfigurationTypeDescriptor(String name) {
-        this(name, false);
-    }
-
-    public NamedConfigurationTypeDescriptor(String name, boolean definedAsType) {
         this.name = ConfigurationTypeDescriptor.checkQualifiedJavaName(name);
-        this.definedAsType = definedAsType;
-    }
-
-    @Override
-    public boolean definedAsType() {
-        return definedAsType;
     }
 
     @Override

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/ProxyConfigurationTypeDescriptor.java

@@ -65,11 +65,6 @@ public int compareTo(ConfigurationTypeDescriptor other) {
         }
     }
 
-    @Override
-    public boolean definedAsType() {
-        return true;
-    }
-
     @Override
     public void printJson(JsonWriter writer) throws IOException {
         writer.append("{").indent().newline();