Merge pull request quarkusio#50366 from Ladicek/arc-fix-construction-of-interception-proxies

ArC: fix construction of interception proxies, part 2

Author: geoand

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/ClientProxyGenerator.java

@@ -184,12 +184,13 @@ Collection<Resource> generate(BeanInfo bean, String beanClassName,
 
             if (!superClass.equals(Object.class.getName())) {
                 // Skip delegation if proxy is not constructed yet
-                // This check is unnecessary for producers that return an interface
+                // This is not necessary for producers of interfaces, because interfaces cannot have constructors
+                // Similarly, this is not necessary for producers of `Object`, because its constructor does nothing
                 // if(!this.bean == null) return super.foo()
                 BytecodeCreator notConstructed = forward
                         .ifNull(forward.readInstanceField(beanField.getFieldDescriptor(), forward.getThis())).trueBranch();
-                if (Modifier.isAbstract(method.flags())) {
-                    notConstructed.throwException(IllegalStateException.class, "Cannot delegate to an abstract method");
+                if (method.isAbstract()) {
+                    notConstructed.throwException(IllegalStateException.class, "Cannot invoke abstract method");
                 } else {
                     MethodDescriptor superDescriptor = MethodDescriptor.ofMethod(superClass, method.name(),
                             method.returnType().name().toString(),

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/InterceptionProxyGenerator.java

@@ -201,7 +201,7 @@ private void createInterceptionSubclass(ClassOutput classOutput, InterceptionPro
 
             for (MethodInfo method : pseudoBean.getInterceptedMethods().keySet()) {
                 forwardingMethods.put(MethodDescriptor.of(method), SubclassGenerator.createForwardingMethod(clazz,
-                        pseudoBeanClassName, method));
+                        pseudoBeanClassName, method, isInterface));
             }
 
             FieldCreator constructedField = clazz.getFieldCreator(SubclassGenerator.FIELD_NAME_CONSTRUCTED, boolean.class)
@@ -369,9 +369,22 @@ private void createInterceptionSubclass(ClassOutput classOutput, InterceptionPro
                     args[i] = mc.getMethodParam(i);
                 }
 
-                BytecodeCreator notConstructed = mc.ifFalse(
-                        mc.readInstanceField(constructedField.getFieldDescriptor(), mc.getThis())).trueBranch();
-                notConstructed.returnValue(notConstructed.invokeSpecialMethod(method, notConstructed.getThis(), args));
+                if (!superClass.equals(Object.class.getName())) {
+                    // Skip delegation if proxy is not constructed yet
+                    // This is not necessary when intercepting interfaces, because interfaces cannot have constructors
+                    // Similarly, this is not necessary when intercepting `Object`, because its constructor does nothing
+                    BytecodeCreator notConstructed = mc.ifFalse(
+                            mc.readInstanceField(constructedField.getFieldDescriptor(), mc.getThis())).trueBranch();
+                    if (method.isAbstract()) {
+                        notConstructed.throwException(IllegalStateException.class, "Cannot invoke abstract method");
+                    } else {
+                        MethodDescriptor superDescriptor = MethodDescriptor.ofMethod(superClass, method.name(),
+                                method.returnType().name().toString(),
+                                method.parameterTypes().stream().map(p -> p.name().toString()).toArray());
+                        notConstructed.returnValue(
+                                notConstructed.invokeSpecialMethod(superDescriptor, notConstructed.getThis(), args));
+                    }
+                }
 
                 ResultHandle dlgt = mc.readInstanceField(delegate.getFieldDescriptor(), mc.getThis());
                 ResultHandle result = method.declaringClass().isInterface()

independent-projects/arc/processor/src/main/java/io/quarkus/arc/processor/SubclassGenerator.java

@@ -190,7 +190,8 @@ protected FieldDescriptor createConstructor(ClassOutput classOutput, BeanInfo be
         Map<MethodDescriptor, MethodDescriptor> forwardingMethods = new HashMap<>();
         List<MethodInfo> interceptedOrDecoratedMethods = bean.getInterceptedOrDecoratedMethods();
         for (MethodInfo method : interceptedOrDecoratedMethods) {
-            forwardingMethods.put(MethodDescriptor.of(method), createForwardingMethod(subclass, providerTypeName, method));
+            forwardingMethods.put(MethodDescriptor.of(method),
+                    createForwardingMethod(subclass, providerTypeName, method, false));
         }
 
         // If a decorator is associated:
@@ -862,7 +863,8 @@ private boolean isDecorated(Set<MethodDescriptor> decoratedMethodDescriptors, Me
         return false;
     }
 
-    static MethodDescriptor createForwardingMethod(ClassCreator subclass, String providerTypeName, MethodInfo method) {
+    static MethodDescriptor createForwardingMethod(ClassCreator subclass, String providerTypeName, MethodInfo method,
+            boolean isInterface) {
         MethodDescriptor methodDescriptor = MethodDescriptor.of(method);
         String forwardMethodName = method.name() + "$$superforward";
         MethodDescriptor forwardDescriptor = MethodDescriptor.ofMethod(subclass.getClassName(), forwardMethodName,
@@ -876,7 +878,9 @@ static MethodDescriptor createForwardingMethod(ClassCreator subclass, String pro
         }
         MethodDescriptor virtualMethod = MethodDescriptor.ofMethod(providerTypeName, methodDescriptor.getName(),
                 methodDescriptor.getReturnType(), methodDescriptor.getParameterTypes());
-        forward.returnValue(forward.invokeSpecialMethod(virtualMethod, forward.getThis(), params));
+        forward.returnValue(isInterface
+                ? forward.invokeSpecialInterfaceMethod(virtualMethod, forward.getThis(), params)
+                : forward.invokeSpecialMethod(virtualMethod, forward.getThis(), params));
         return forwardDescriptor;
     }
 
@@ -908,8 +912,8 @@ static void createInterceptedMethod(MethodInfo method, ClassCreator subclass, Fi
         for (int i = 0; i < parameters.size(); ++i) {
             params[i] = notConstructed.getMethodParam(i);
         }
-        if (Modifier.isAbstract(method.flags())) {
-            notConstructed.throwException(IllegalStateException.class, "Cannot delegate to an abstract method");
+        if (method.isAbstract()) {
+            notConstructed.throwException(IllegalStateException.class, "Cannot invoke abstract method");
         } else {
             notConstructed.returnValue(notConstructed.invokeVirtualMethod(forwardMethod, notConstructed.getThis(), params));
         }