Support dynamic proxies for TypeHint (#12088)

Fixes #11837

Author: dstepanov

core/src/main/java/io/micronaut/core/annotation/TypeHint.java

@@ -78,6 +78,10 @@ enum AccessType {
         /**
          * All public fields require access.
          */
-        ALL_PUBLIC_FIELDS
+        ALL_PUBLIC_FIELDS,
+        /**
+         * The type is a dynamic proxy.
+         */
+        DYNAMIC_PROXY
     }
 }

core/src/main/java/io/micronaut/core/graal/GraalReflectionConfigurer.java

@@ -68,6 +68,9 @@ default void configure(ReflectionConfigurationContext context) {
                 final Set<TypeHint.AccessType> accessType = CollectionUtils.setOf(
                     accessTypes
                 );
+                if (accessType.contains(TypeHint.AccessType.DYNAMIC_PROXY)) {
+                    context.registerDynamicProxy(t);
+                }
                 if (accessType.contains(TypeHint.AccessType.ALL_PUBLIC_METHODS)) {
                     final Method[] methods = t.getMethods();
                     for (Method method : methods) {
@@ -196,5 +199,11 @@ interface ReflectionConfigurationContext {
          * @param constructors The constructors
          */
         void register(Constructor<?>... constructors);
+
+        /**
+         * Register a dynamic proxy.
+         * @param proxyClass The proxy class
+         */
+        void registerDynamicProxy(Class<?> proxyClass);
     }
 }

core/src/main/java/io/micronaut/core/io/service/ServiceLoaderFeature.java

@@ -28,6 +28,7 @@
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.hosted.Feature;
 import org.graalvm.nativeimage.hosted.RuntimeClassInitialization;
+import org.graalvm.nativeimage.hosted.RuntimeProxyCreation;
 import org.graalvm.nativeimage.hosted.RuntimeReflection;
 
 import java.io.IOException;
@@ -233,6 +234,11 @@ public void register(Field... fields) {
             public void register(Constructor<?>... constructors) {
                 RuntimeReflection.register(constructors);
             }
+
+            @Override
+            public void registerDynamicProxy(Class<?> proxyClass) {
+                RuntimeProxyCreation.register(proxyClass);
+            }
         };
         for (GraalReflectionConfigurer configurer : configurers) {
             initializeAtBuildTime(configurer.getClass());

graal/src/main/java/io/micronaut/graal/reflect/GraalTypeElementVisitor.java

@@ -27,7 +27,6 @@
 import io.micronaut.core.annotation.ReflectionConfig;
 import io.micronaut.core.annotation.ReflectiveAccess;
 import io.micronaut.core.annotation.TypeHint;
-import io.micronaut.core.util.StringUtils;
 import io.micronaut.inject.annotation.MutableAnnotationMetadata;
 import io.micronaut.inject.ast.ClassElement;
 import io.micronaut.inject.ast.ElementModifier;
@@ -156,20 +155,18 @@ public void visitClass(ClassElement element, VisitorContext context) {
             }
 
             if (element.hasAnnotation(TypeHint.class)) {
-                final String[] introspectedClasses = element.stringValues(TypeHint.class);
-                final TypeHint typeHint = element.synthesize(TypeHint.class);
-                TypeHint.AccessType[] accessTypes = DEFAULT_ACCESS_TYPE;
-
-                if (typeHint != null) {
-                    accessTypes = typeHint.accessType();
+                String[] introspectedClasses = element.stringValues(TypeHint.class);
+                String[] typeNames = element.stringValues(TypeHint.class, "typeNames");
+                TypeHint.AccessType[] accessTypes = element.enumValues(TypeHint.class, "accessType", TypeHint.AccessType.class);
+                if (accessTypes.length == 0) {
+                    accessTypes = DEFAULT_ACCESS_TYPE;
+                }
+                if (introspectedClasses.length == 0 && typeNames.length == 0) {
+                    processClasses(accessTypes, reflectiveClasses, element.getName());
+                } else {
+                    processClasses(accessTypes, reflectiveClasses, introspectedClasses);
+                    processClasses(accessTypes, reflectiveClasses, typeNames);
                 }
-                processClasses(accessTypes, reflectiveClasses, introspectedClasses);
-                processClasses(accessTypes, reflectiveClasses, element.getValue(
-                        TypeHint.class,
-                        "typeNames",
-                        String[].class).orElse(StringUtils.EMPTY_STRING_ARRAY
-                    )
-                );
             }
 
             if (element.hasAnnotation(Import.class)) {

graal/src/test/groovy/io/micronaut/graal/reflect/GraalTypeElementVisitorSpec.groovy

@@ -440,4 +440,51 @@ enum Test {
         config.getAnnotations("methods").size() == 2 // Two methods from Enum
 
     }
+
+    void "test dynamic proxy"() {
+        given:
+            GraalReflectionConfigurer configurer = buildReflectionConfigurer('test.Foobar', '''
+package test;
+
+import io.micronaut.core.annotation.*;
+
+@TypeHint(value = Bar.class, accessType = TypeHint.AccessType.DYNAMIC_PROXY)
+class Foobar {
+}
+
+interface Bar {
+}
+
+''')
+
+        when:
+            AnnotationValue<ReflectionConfig> config = configurer.getAnnotationMetadata().getAnnotationValuesByType(ReflectionConfig).first()
+
+        then:
+            config
+            config.stringValue("type").get() == 'test.Bar'
+            config.enumValues("accessType", TypeHint.AccessType) == [TypeHint.AccessType.DYNAMIC_PROXY] as TypeHint.AccessType[]
+    }
+
+    void "test dynamic proxy 2"() {
+        given:
+            GraalReflectionConfigurer configurer = buildReflectionConfigurer('test.Foobar', '''
+package test;
+
+import io.micronaut.core.annotation.*;
+
+@TypeHint(accessType = TypeHint.AccessType.DYNAMIC_PROXY)
+interface Foobar {
+}
+
+''')
+
+        when:
+            AnnotationValue<ReflectionConfig> config = configurer.getAnnotationMetadata().getAnnotationValuesByType(ReflectionConfig).first()
+
+        then:
+            config
+            config.stringValue("type").get() == 'test.Foobar'
+            config.enumValues("accessType", TypeHint.AccessType) == [TypeHint.AccessType.DYNAMIC_PROXY] as TypeHint.AccessType[]
+    }
 }