Core: add Gizmo 2 variant of AnnotationProxyProvider.build()

Author: Ladicek

core/deployment/src/main/java/io/quarkus/deployment/recording/AnnotationProxyProvider.java

@@ -1,14 +1,17 @@
 package io.quarkus.deployment.recording;
 
+import static org.jboss.jandex.gizmo2.Jandex2Gizmo.classDescOf;
 import static org.objectweb.asm.Opcodes.ACC_FINAL;
 import static org.objectweb.asm.Opcodes.ACC_PRIVATE;
 import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
 
 import java.io.InputStream;
 import java.lang.annotation.Annotation;
+import java.lang.constant.ClassDesc;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.ListIterator;
@@ -32,6 +35,12 @@
 import io.quarkus.gizmo.FieldDescriptor;
 import io.quarkus.gizmo.MethodCreator;
 import io.quarkus.gizmo.MethodDescriptor;
+import io.quarkus.gizmo2.GenericType;
+import io.quarkus.gizmo2.Gizmo;
+import io.quarkus.gizmo2.ParamVar;
+import io.quarkus.gizmo2.TypeArgument;
+import io.quarkus.gizmo2.desc.ConstructorDesc;
+import io.quarkus.gizmo2.desc.FieldDesc;
 
 public class AnnotationProxyProvider {
 
@@ -70,9 +79,9 @@ public <A extends Annotation> AnnotationProxyBuilder<A> builder(AnnotationInstan
             }
             return clazz;
         });
-        String annotationLiteral = annotationLiterals.computeIfAbsent(annotationInstance.name(), name ->
-        // com.foo.MyAnnotation -> com.foo.MyAnnotation_Proxy_AnnotationLiteral
-        name.toString().replace('.', '/') + "_Proxy_AnnotationLiteral");
+        String annotationLiteral = annotationLiterals.computeIfAbsent(annotationInstance.name(),
+                // com.foo.MyAnnotation -> com.foo.MyAnnotation_Proxy_AnnotationLiteral
+                name -> name + "_Proxy_AnnotationLiteral");
 
         return new AnnotationProxyBuilder<>(annotationInstance, annotationType, annotationLiteral, annotationClass);
     }
@@ -134,7 +143,6 @@ public AnnotationProxyBuilder<A> withDefaultValue(String name, Object value) {
             return this;
         }
 
-        @SuppressWarnings("unchecked")
         public A build(ClassOutput classOutput) {
 
             // Generate literal class if needed
@@ -178,6 +186,11 @@ public A build(ClassOutput classOutput) {
                 return Boolean.TRUE;
             });
 
+            return proxy();
+        }
+
+        @SuppressWarnings("unchecked")
+        private A proxy() {
             ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
             if (classLoader == null) {
                 classLoader = AnnotationProxy.class.getClassLoader();
@@ -216,6 +229,58 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
                         }
                     });
         }
+
+        public A build(io.quarkus.gizmo2.ClassOutput classOutput) {
+            generatedLiterals.computeIfAbsent(annotationLiteral, generatedName -> {
+                Gizmo.create(classOutput).class_(generatedName, cc -> {
+                    ClassDesc annotationClassDesc = classDescOf(annotationInstance.name());
+                    cc.extends_(GenericType.ofClass(AnnotationLiteral.class, TypeArgument.of(annotationClassDesc)));
+                    cc.implements_(annotationClassDesc);
+
+                    List<MethodInfo> members = annotationClass.methods()
+                            .stream()
+                            .filter(m -> !m.isStaticInitializer() && !m.isConstructor())
+                            .toList();
+
+                    List<FieldDesc> fields = new ArrayList<>(members.size());
+                    for (MethodInfo member : members) {
+                        fields.add(cc.field(member.name(), fc -> {
+                            fc.private_();
+                            fc.final_();
+                            fc.setType(classDescOf(member.returnType()));
+                        }));
+                    }
+
+                    cc.constructor(mc -> {
+                        List<ParamVar> params = new ArrayList<>(members.size());
+                        for (MethodInfo member : members) {
+                            params.add(mc.parameter(member.name(), classDescOf(member.returnType())));
+                        }
+
+                        mc.body(bc -> {
+                            bc.invokeSpecial(ConstructorDesc.of(AnnotationLiteral.class), cc.this_());
+                            for (int i = 0; i < members.size(); i++) {
+                                bc.set(cc.this_().field(fields.get(i)), params.get(i));
+                            }
+                            bc.return_();
+                        });
+                    });
+
+                    for (int i = 0; i < members.size(); i++) {
+                        MethodInfo member = members.get(i);
+                        FieldDesc field = fields.get(i);
+                        cc.method(member.name(), mc -> {
+                            mc.returning(classDescOf(member.returnType()));
+                            mc.body(bc -> bc.return_(cc.this_().field(field)));
+                        });
+                    }
+                });
+
+                return Boolean.TRUE;
+            });
+
+            return proxy();
+        }
     }
 
 }