OWB-1155 - InjectionPoint.getQualifiers does not return the list of selected qualifiers with type and qualifiers programmatic lookup

Author: tandraschko

webbeans-impl/src/main/java/org/apache/webbeans/inject/instance/InstanceImpl.java

@@ -18,12 +18,15 @@
  */
 package org.apache.webbeans.inject.instance;
 
+import java.io.EOFException;
 import java.io.IOException;
 import java.io.ObjectInputStream;
+import java.io.OptionalDataException;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Member;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.Collections;
@@ -46,6 +49,7 @@
 import jakarta.inject.Provider;
 
 import org.apache.webbeans.annotation.DefaultLiteral;
+import org.apache.webbeans.config.OwbParametrizedTypeImpl;
 import org.apache.webbeans.config.WebBeansContext;
 import org.apache.webbeans.container.BeanManagerImpl;
 import org.apache.webbeans.container.InjectionResolver;
@@ -237,7 +241,30 @@ public <U extends T> Instance<U> select(Class<U> subtype, Annotation... qualifie
         final Annotation[] effectiveQualifiers = qualifiers != null && qualifiers.length > 0
             ? concatenateQualifiers(qualifiers)
             : qualifierAnnotations.toArray(new Annotation[0]);
-        return new InstanceImpl<>(sub, injectionPoint, webBeansContext, effectiveQualifiers);
+        final InjectionPoint nextInjectionPoint = injectionPoint == null ? null
+            : new InstanceInjectionPoint(injectionPoint, effectiveQualifiers, instanceTypeOverrideForSelectClass(injectionPoint, sub));
+        return new InstanceImpl<>(sub, nextInjectionPoint, webBeansContext, effectiveQualifiers);
+    }
+
+    /**
+     * OWB-1155: only override {@link InjectionPoint#getType()} to {@code Instance<subtype>} when the
+     * current injection point already represents an {@code Instance<…>} dependency. Otherwise
+     * (e.g. {@code BeanConfiguratorImpl#createInstance} uses {@code Object} with the field's
+     * {@link InjectionPoint}) forcing {@code Instance<subtype>} breaks {@link org.apache.webbeans.portable.InjectionPointProducer}.
+     */
+    private static Type instanceTypeOverrideForSelectClass(InjectionPoint injectionPoint, Type sub)
+    {
+        Type t = injectionPoint.getType();
+        if (!ParameterizedType.class.isInstance(t))
+        {
+            return null;
+        }
+        ParameterizedType pt = ParameterizedType.class.cast(t);
+        if (pt.getRawType() != Instance.class)
+        {
+            return null;
+        }
+        return new OwbParametrizedTypeImpl(null, Instance.class, sub);
     }
 
     /**
@@ -404,17 +431,24 @@ private static class InstanceInjectionPoint implements InjectionPoint, Serializa
     {
         private InjectionPoint delegate;
         private Set<Annotation> qualifiers;
+        private Type typeOverride;
 
         protected InstanceInjectionPoint(InjectionPoint injectionPoint, Annotation[] newQualifiersArray)
+        {
+            this(injectionPoint, newQualifiersArray, null);
+        }
+
+        protected InstanceInjectionPoint(InjectionPoint injectionPoint, Annotation[] newQualifiersArray, Type typeOverride)
         {
             this.delegate = injectionPoint;
             this.qualifiers = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(newQualifiersArray)));
+            this.typeOverride = typeOverride;
         }
 
         @Override
         public Type getType()
         {
-            return delegate.getType();
+            return typeOverride != null ? typeOverride : delegate.getType();
         }
 
         @Override
@@ -458,13 +492,22 @@ private void readObject(ObjectInputStream inp) throws IOException, ClassNotFound
             OwbCustomObjectInputStream owbCustomObjectInputStream = new OwbCustomObjectInputStream(inp, WebBeansUtil.getCurrentClassLoader());
             qualifiers = Set.class.cast(owbCustomObjectInputStream.readObject());
             delegate = InjectionPoint.class.cast(owbCustomObjectInputStream.readObject());
+            try
+            {
+                typeOverride = Type.class.cast(owbCustomObjectInputStream.readObject());
+            }
+            catch (EOFException | OptionalDataException ex)
+            {
+                typeOverride = null;
+            }
         }
 
         private void writeObject(ObjectOutputStream op) throws IOException
         {
             ObjectOutputStream out = new ObjectOutputStream(op);
             out.writeObject(qualifiers);
             out.writeObject(delegate);
+            out.writeObject(typeOverride);
         }
     }
 

webbeans-impl/src/test/java/org/apache/webbeans/test/instance/InstanceQualifierInjectionPointTest.java

@@ -55,10 +55,13 @@ public class InstanceQualifierInjectionPointTest extends AbstractUnitTest
     @Inject
     private Instance<ShardContract> instance2;
 
+    @Inject
+    @Any
+    private Instance<Number> numbers;
 
     @Test
     public void checkQualfiers() {
-        startContainer(Arrays.<Class<?>>asList(
+        startContainer(Arrays.asList(
             Qualifier1.class,
             QualifiersHolder.class,
             Factory.class), Collections.<String>emptyList(), true);
@@ -74,12 +77,27 @@ public void checkQualfiers() {
         assertNotNull(instance2.get());
         assertEquals(1, holder.getQualifiers().size());
         assertEquals(Default.class, holder.getQualifiers().iterator().next().annotationType());
+    }
 
+    /**
+     * OWB-1155: {@link Instance#select(Class, Annotation...)} must propagate selected qualifiers to
+     * {@link InjectionPoint} (OWB-1122 fixed only {@link Instance#select(Annotation...)}).
+     */
+    @Test
+    public void subtypeSelectPropagatesQualifiersToInjectionPointOw1155()
+    {
+        startContainer(Arrays.asList(
+            Qualifier1.class,
+            QualifiersHolder.class,
+            Factory.class), Collections.emptyList(), true);
 
-
+        assertNotNull(numbers.select(Integer.class, new AnnotationLiteral<Qualifier1>()
+        {
+        }).get());
+        assertEquals(holder.getQualifiers().toString(), 1, holder.getQualifiers().size());
+        assertEquals(Qualifier1.class, holder.getQualifiers().iterator().next().annotationType());
     }
 
-
     public static class Factory
     {
         @Inject
@@ -99,6 +117,15 @@ public ShardContract produces(final InjectionPoint ip)
             {
             };
         }
+
+        @Produces
+        @Qualifier1
+        @Default
+        public Integer produceNumber(final InjectionPoint ip)
+        {
+            holder.setQualifiers(ip.getQualifiers());
+            return 42;
+        }
     }
 
     @Target(METHOD)