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

ArC: fix construction of interception proxies

Author: geoand

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

@@ -201,13 +201,7 @@ private void createInterceptionSubclass(ClassOutput classOutput, InterceptionPro
 
             for (MethodInfo method : pseudoBean.getInterceptedMethods().keySet()) {
                 forwardingMethods.put(MethodDescriptor.of(method), SubclassGenerator.createForwardingMethod(clazz,
-                        pseudoBeanClassName, method, (bytecode, virtualMethod, params) -> {
-                            ResultHandle delegateHandle = bytecode.readInstanceField(delegate.getFieldDescriptor(),
-                                    bytecode.getThis());
-                            return isInterface
-                                    ? bytecode.invokeInterfaceMethod(virtualMethod, delegateHandle, params)
-                                    : bytecode.invokeVirtualMethod(virtualMethod, delegateHandle, params);
-                        }));
+                        pseudoBeanClassName, method));
             }
 
             FieldCreator constructedField = clazz.getFieldCreator(SubclassGenerator.FIELD_NAME_CONSTRUCTED, boolean.class)
@@ -364,16 +358,22 @@ private void createInterceptionSubclass(ClassOutput classOutput, InterceptionPro
             MethodCreator getDelegate = clazz.getMethodCreator("arc_delegate", Object.class);
             getDelegate.returnValue(getDelegate.readInstanceField(delegate.getFieldDescriptor(), getDelegate.getThis()));
 
-            // forward non-intercepted methods to the delegate unconditionally
+            // forward non-intercepted methods to the delegate
             Collection<MethodInfo> methodsToForward = collectMethodsToForward(pseudoBean,
                     bytecodeTransformerConsumer, transformUnproxyableClasses);
             for (MethodInfo method : methodsToForward) {
                 MethodCreator mc = clazz.getMethodCreator(MethodDescriptor.of(method));
-                ResultHandle dlgt = mc.readInstanceField(delegate.getFieldDescriptor(), mc.getThis());
+
                 ResultHandle[] args = new ResultHandle[method.parametersCount()];
                 for (int i = 0; i < method.parametersCount(); i++) {
                     args[i] = mc.getMethodParam(i);
                 }
+
+                BytecodeCreator notConstructed = mc.ifFalse(
+                        mc.readInstanceField(constructedField.getFieldDescriptor(), mc.getThis())).trueBranch();
+                notConstructed.returnValue(notConstructed.invokeSpecialMethod(method, notConstructed.getThis(), args));
+
+                ResultHandle dlgt = mc.readInstanceField(delegate.getFieldDescriptor(), mc.getThis());
                 ResultHandle result = method.declaringClass().isInterface()
                         ? mc.invokeInterfaceMethod(method, dlgt, args)
                         : mc.invokeVirtualMethod(method, dlgt, args);

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

@@ -190,9 +190,7 @@ 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,
-                    (bytecode, virtualMethod, params) -> bytecode.invokeSpecialMethod(virtualMethod, bytecode.getThis(),
-                            params)));
+            forwardingMethods.put(MethodDescriptor.of(method), createForwardingMethod(subclass, providerTypeName, method));
         }
 
         // If a decorator is associated:
@@ -864,13 +862,7 @@ private boolean isDecorated(Set<MethodDescriptor> decoratedMethodDescriptors, Me
         return false;
     }
 
-    @FunctionalInterface
-    interface ForwardInvokeGenerator {
-        ResultHandle generate(BytecodeCreator bytecode, MethodDescriptor virtualMethod, ResultHandle[] params);
-    }
-
-    static MethodDescriptor createForwardingMethod(ClassCreator subclass, String providerTypeName, MethodInfo method,
-            ForwardInvokeGenerator forwardInvokeGenerator) {
+    static MethodDescriptor createForwardingMethod(ClassCreator subclass, String providerTypeName, MethodInfo method) {
         MethodDescriptor methodDescriptor = MethodDescriptor.of(method);
         String forwardMethodName = method.name() + "$$superforward";
         MethodDescriptor forwardDescriptor = MethodDescriptor.ofMethod(subclass.getClassName(), forwardMethodName,
@@ -884,7 +876,7 @@ static MethodDescriptor createForwardingMethod(ClassCreator subclass, String pro
         }
         MethodDescriptor virtualMethod = MethodDescriptor.ofMethod(providerTypeName, methodDescriptor.getName(),
                 methodDescriptor.getReturnType(), methodDescriptor.getParameterTypes());
-        forward.returnValue(forwardInvokeGenerator.generate(forward, virtualMethod, params));
+        forward.returnValue(forward.invokeSpecialMethod(virtualMethod, forward.getThis(), params));
         return forwardDescriptor;
     }
 

independent-projects/arc/tests/src/test/java/io/quarkus/arc/test/interceptors/producer/ProducerWithInterceptionAndVirtualCallInCtorTest.java

@@ -0,0 +1,92 @@
+package io.quarkus.arc.test.interceptors.producer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.ArrayList;
+import java.util.List;
+
+import jakarta.annotation.Priority;
+import jakarta.enterprise.context.Dependent;
+import jakarta.enterprise.inject.Produces;
+import jakarta.interceptor.AroundInvoke;
+import jakarta.interceptor.Interceptor;
+import jakarta.interceptor.InterceptorBinding;
+import jakarta.interceptor.InvocationContext;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.arc.Arc;
+import io.quarkus.arc.InterceptionProxy;
+import io.quarkus.arc.test.ArcTestContainer;
+
+public class ProducerWithInterceptionAndVirtualCallInCtorTest {
+    @RegisterExtension
+    public ArcTestContainer container = new ArcTestContainer(MyBinding.class, MyInterceptor.class, MyProducer.class);
+
+    @Test
+    public void test() {
+        MyNonbean nonbean = Arc.container().instance(MyNonbean.class).get();
+        assertEquals("intercepted: hello", nonbean.hello());
+        assertEquals("intercepted: MyNonbean", nonbean.getThisClass_intercepted());
+        assertEquals("MyNonbean", nonbean.getThisClass_notIntercepted());
+
+        assertEquals(List.of(
+                "MyNonbean",
+                "ProducerWithInterceptionAndVirtualCallInCtorTest$MyNonbean_InterceptionSubclass"),
+                MyNonbean.constructedInstances_intercepted);
+        assertEquals(MyNonbean.constructedInstances_intercepted, MyNonbean.constructedInstances_notIntercepted);
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR })
+    @InterceptorBinding
+    @interface MyBinding {
+    }
+
+    @MyBinding
+    @Priority(1)
+    @Interceptor
+    static class MyInterceptor {
+        @AroundInvoke
+        Object intercept(InvocationContext ctx) throws Exception {
+            return "intercepted: " + ctx.proceed();
+        }
+    }
+
+    static class MyNonbean {
+        static final List<String> constructedInstances_intercepted = new ArrayList<>();
+        static final List<String> constructedInstances_notIntercepted = new ArrayList<>();
+
+        MyNonbean() {
+            constructedInstances_intercepted.add(getThisClass_intercepted());
+            constructedInstances_notIntercepted.add(getThisClass_notIntercepted());
+        }
+
+        @MyBinding
+        String getThisClass_intercepted() {
+            return this.getClass().getSimpleName();
+        }
+
+        String getThisClass_notIntercepted() {
+            return this.getClass().getSimpleName();
+        }
+
+        @MyBinding
+        String hello() {
+            return "hello";
+        }
+    }
+
+    @Dependent
+    static class MyProducer {
+        @Produces
+        MyNonbean produce(InterceptionProxy<MyNonbean> proxy) {
+            return proxy.create(new MyNonbean());
+        }
+    }
+}