gRPC: convert BeanConfiguratorBase.creator() usages to Gizmo 2

Author: Ladicek

extensions/grpc/deployment/src/main/java/io/quarkus/grpc/deployment/GrpcClientProcessor.java

@@ -7,7 +7,10 @@
 import static io.quarkus.grpc.deployment.GrpcDotNames.RETRIEVE_CHANNEL_METHOD;
 import static io.quarkus.grpc.deployment.GrpcInterceptors.MICROMETER_INTERCEPTORS;
 import static io.quarkus.grpc.deployment.ResourceRegistrationUtils.registerResourcesForProperties;
+import static org.jboss.jandex.gizmo2.Jandex2Gizmo.classDescOf;
 
+import java.lang.constant.ClassDesc;
+import java.lang.constant.MethodTypeDesc;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -16,7 +19,6 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiFunction;
-import java.util.function.Consumer;
 import java.util.regex.Pattern;
 
 import jakarta.enterprise.context.ApplicationScoped;
@@ -30,6 +32,7 @@
 import org.jboss.jandex.AnnotationTarget.Kind;
 import org.jboss.jandex.AnnotationValue;
 import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.ClassType;
 import org.jboss.jandex.DotName;
 import org.jboss.jandex.FieldInfo;
 import org.jboss.jandex.IndexView;
@@ -59,9 +62,13 @@
 import io.quarkus.deployment.builditem.nativeimage.NativeImageResourceBuildItem;
 import io.quarkus.deployment.builditem.nativeimage.RuntimeInitializedClassBuildItem;
 import io.quarkus.deployment.recording.RecorderContext;
-import io.quarkus.gizmo.MethodCreator;
-import io.quarkus.gizmo.MethodDescriptor;
-import io.quarkus.gizmo.ResultHandle;
+import io.quarkus.gizmo2.Const;
+import io.quarkus.gizmo2.Expr;
+import io.quarkus.gizmo2.Reflection2Gizmo;
+import io.quarkus.gizmo2.creator.BlockCreator;
+import io.quarkus.gizmo2.desc.ClassMethodDesc;
+import io.quarkus.gizmo2.desc.ConstructorDesc;
+import io.quarkus.gizmo2.desc.MethodDesc;
 import io.quarkus.grpc.GrpcClient;
 import io.quarkus.grpc.MutinyClient;
 import io.quarkus.grpc.RegisterClientInterceptor;
@@ -241,19 +248,14 @@ public void generateGrpcClientProducers(List<GrpcClientBuildItem> clients,
                             .scope(Singleton.class)
                             .unremovable()
                             .forceApplicationClass()
-                            .creator(new Consumer<>() {
-                                @Override
-                                public void accept(MethodCreator mc) {
-                                    GrpcClientProcessor.this.generateChannelProducer(mc, clientName, clientInfo);
-                                }
-                            })
+                            .creator(cg -> GrpcClientProcessor.this.generateChannelProducer(cg.createMethod(),
+                                    clientName, clientInfo))
                             .destroyer(Channels.ChannelDestroyer.class);
                     if (!clientInfo.interceptors.isEmpty()) {
                         for (String interceptorClass : clientInfo.interceptors) {
-                            configurator.addQualifier(AnnotationInstance.create(GrpcDotNames.REGISTER_CLIENT_INTERCEPTOR, null,
-                                    new AnnotationValue[] { AnnotationValue.createClassValue("value",
-                                            Type.create(DotName.createSimple(interceptorClass),
-                                                    org.jboss.jandex.Type.Kind.CLASS)) }));
+                            configurator.addQualifier(AnnotationInstance.builder(GrpcDotNames.REGISTER_CLIENT_INTERCEPTOR)
+                                    .value(ClassType.create(interceptorClass))
+                                    .build());
                         }
                     }
                     syntheticBeans.produce(configurator.done());
@@ -267,18 +269,13 @@ public void accept(MethodCreator mc) {
                             .unremovable()
                             .forceApplicationClass()
                             .addType(MutinyClient.class)
-                            .creator(new Consumer<>() {
-                                @Override
-                                public void accept(MethodCreator mc) {
-                                    GrpcClientProcessor.this.generateClientProducer(mc, clientName, clientInfo);
-                                }
-                            });
+                            .creator(cg -> GrpcClientProcessor.this.generateClientProducer(cg.createMethod(),
+                                    clientName, clientInfo));
                     if (!clientInfo.interceptors.isEmpty()) {
                         for (String interceptorClass : clientInfo.interceptors) {
-                            configurator.addQualifier(AnnotationInstance.create(GrpcDotNames.REGISTER_CLIENT_INTERCEPTOR, null,
-                                    new AnnotationValue[] { AnnotationValue.createClassValue("value",
-                                            Type.create(DotName.createSimple(interceptorClass),
-                                                    org.jboss.jandex.Type.Kind.CLASS)) }));
+                            configurator.addQualifier(AnnotationInstance.builder(GrpcDotNames.REGISTER_CLIENT_INTERCEPTOR)
+                                    .value(ClassType.create(interceptorClass))
+                                    .build());
                         }
                     }
                     syntheticBeans.produce(configurator.done());
@@ -467,18 +464,9 @@ private DeploymentException invalidInjectionPoint(InjectionPointInfo injectionPo
                         + " - only Mutiny service interfaces, blocking stubs, reactive stubs based on Mutiny and io.grpc.Channel can be injected via @GrpcClient");
     }
 
-    private void generateChannelProducer(MethodCreator mc, String clientName, ClientInfo client) {
-        ResultHandle name = mc.load(clientName);
-        ResultHandle interceptorsArray = mc.newArray(String.class, client.interceptors.size());
-        int idx = 0;
-        for (String interceptor : client.interceptors) {
-            mc.writeArrayValue(interceptorsArray, idx++, mc.load(interceptor));
-        }
-        ResultHandle interceptorsSet = mc.invokeStaticInterfaceMethod(
-                MethodDescriptor.ofMethod(Set.class, "of", Set.class, Object[].class), interceptorsArray);
-        ResultHandle result = mc.invokeStaticMethod(CREATE_CHANNEL_METHOD, name, interceptorsSet);
-        mc.returnValue(result);
-        mc.close();
+    private void generateChannelProducer(BlockCreator bc, String clientName, ClientInfo client) {
+        bc.return_(bc.invokeStatic(CREATE_CHANNEL_METHOD, Const.of(clientName),
+                bc.setOf(client.interceptors.stream().toList(), Const::of)));
     }
 
     private static Set<DotName> getRawTypeClosure(ClassInfo classInfo, IndexView index) {
@@ -508,50 +496,40 @@ private static Set<DotName> getRawTypeClosure(ClassInfo classInfo, IndexView ind
         return types;
     }
 
-    private void generateClientProducer(MethodCreator mc, String clientName, ClientInfo clientInfo) {
-        ResultHandle name = mc.load(clientName);
-        ResultHandle interceptorsArray = mc.newArray(String.class, clientInfo.interceptors.size());
-        int idx = 0;
-        for (String interceptor : clientInfo.interceptors) {
-            mc.writeArrayValue(interceptorsArray, idx++, mc.load(interceptor));
-        }
-        ResultHandle interceptorsSet = mc.invokeStaticInterfaceMethod(
-                MethodDescriptor.ofMethod(Set.class, "of", Set.class, Object[].class), interceptorsArray);
+    private void generateClientProducer(BlockCreator bc, String clientName, ClientInfo clientInfo) {
+        Const name = Const.of(clientName);
 
         // First obtain the channel instance for the given service name
-        ResultHandle channel = mc.invokeStaticMethod(RETRIEVE_CHANNEL_METHOD, name, interceptorsSet);
-        ResultHandle client;
+        Expr channel = bc.invokeStatic(RETRIEVE_CHANNEL_METHOD, name,
+                bc.setOf(clientInfo.interceptors.stream().toList(), Const::of));
 
+        Expr client;
         if (clientInfo.type == ClientType.MUTINY_CLIENT) {
             // Instantiate the client, e.g. new HealthClient(serviceName,channel,GrpcClientConfigProvider.getStubConfigurator())
-            ResultHandle stubConfigurator = mc.invokeStaticMethod(GrpcDotNames.GET_STUB_CONFIGURATOR);
-            client = mc.newInstance(
-                    MethodDescriptor.ofConstructor(clientInfo.implName.toString(), String.class.getName(),
-                            Channel.class.getName(), BiFunction.class),
-                    name, channel, stubConfigurator);
+            client = bc.new_(
+                    ConstructorDesc.of(classDescOf(clientInfo.implName), String.class, Channel.class, BiFunction.class),
+                    name, channel, bc.invokeStatic(GrpcDotNames.GET_STUB_CONFIGURATOR));
         } else {
             // Create the stub, e.g. newBlockingStub(channel)
-            MethodDescriptor factoryMethod = MethodDescriptor
-                    .ofMethod(convertToServiceName(clientInfo.className), clientInfo.type.getFactoryMethodName(),
-                            clientInfo.className.toString(),
-                            Channel.class.getName());
-            client = mc.invokeStaticMethod(factoryMethod, channel);
+            MethodDesc factoryMethod = ClassMethodDesc.of(convertToServiceName(clientInfo.className),
+                    clientInfo.type.getFactoryMethodName(),
+                    MethodTypeDesc.of(classDescOf(clientInfo.className), Reflection2Gizmo.classDescOf(Channel.class)));
+            client = bc.invokeStatic(factoryMethod, channel);
 
             // If needed, modify the call options, e.g. stub = stub.withCompression("gzip")
-            client = mc.invokeStaticMethod(CONFIGURE_STUB, name, client);
+            client = bc.invokeStatic(CONFIGURE_STUB, name, client);
             if (clientInfo.type.isBlocking()) {
-                client = mc.invokeStaticMethod(ADD_BLOCKING_CLIENT_INTERCEPTOR, client);
+                client = bc.invokeStatic(ADD_BLOCKING_CLIENT_INTERCEPTOR, client);
             }
         }
-        mc.returnValue(client);
-        mc.close();
+        bc.return_(client);
     }
 
-    private String convertToServiceName(DotName stubName) {
+    private static ClassDesc convertToServiceName(DotName stubName) {
         if (stubName.isInner()) {
-            return stubName.prefix().toString();
+            return classDescOf(stubName.prefix());
         } else {
-            return stubName.toString();
+            return classDescOf(stubName);
         }
     }
 }

extensions/grpc/deployment/src/main/java/io/quarkus/grpc/deployment/GrpcDotNames.java

@@ -12,7 +12,7 @@
 import io.grpc.ServerInterceptor;
 import io.grpc.stub.AbstractBlockingStub;
 import io.grpc.stub.AbstractStub;
-import io.quarkus.gizmo.MethodDescriptor;
+import io.quarkus.gizmo2.desc.MethodDesc;
 import io.quarkus.grpc.GlobalInterceptor;
 import io.quarkus.grpc.GrpcClient;
 import io.quarkus.grpc.GrpcService;
@@ -63,17 +63,17 @@ public class GrpcDotNames {
     public static final DotName CHANNEL_BUILDER_CUSTOMIZER = DotName.createSimple(ChannelBuilderCustomizer.class.getName());
     public static final DotName SERVER_BUILDER_CUSTOMIZER = DotName.createSimple(ServerBuilderCustomizer.class.getName());
 
-    static final MethodDescriptor CREATE_CHANNEL_METHOD = MethodDescriptor.ofMethod(Channels.class, "createChannel",
+    static final MethodDesc CREATE_CHANNEL_METHOD = MethodDesc.of(Channels.class, "createChannel",
             Channel.class, String.class, Set.class);
-    static final MethodDescriptor RETRIEVE_CHANNEL_METHOD = MethodDescriptor.ofMethod(Channels.class, "retrieveChannel",
+    static final MethodDesc RETRIEVE_CHANNEL_METHOD = MethodDesc.of(Channels.class, "retrieveChannel",
             Channel.class, String.class, Set.class);
 
-    static final MethodDescriptor CONFIGURE_STUB = MethodDescriptor.ofMethod(GrpcClientConfigProvider.class,
-            "configureStub", AbstractStub.class, String.class, AbstractStub.class);
-    static final MethodDescriptor ADD_BLOCKING_CLIENT_INTERCEPTOR = MethodDescriptor.ofMethod(GrpcClientConfigProvider.class,
+    static final MethodDesc CONFIGURE_STUB = MethodDesc.of(GrpcClientConfigProvider.class, "configureStub",
+            AbstractStub.class, String.class, AbstractStub.class);
+    static final MethodDesc ADD_BLOCKING_CLIENT_INTERCEPTOR = MethodDesc.of(GrpcClientConfigProvider.class,
             "addBlockingClientInterceptor", AbstractStub.class, AbstractStub.class);
-    static final MethodDescriptor GET_STUB_CONFIGURATOR = MethodDescriptor.ofMethod(GrpcClientConfigProvider.class,
-            "getStubConfigurator", BiFunction.class);
+    static final MethodDesc GET_STUB_CONFIGURATOR = MethodDesc.of(GrpcClientConfigProvider.class, "getStubConfigurator",
+            BiFunction.class);
 
     static boolean isGrpcClient(AnnotationInstance instance) {
         return instance.name().equals(GRPC_CLIENT);