Streamline classes used in resolution

impl/src/main/java/org/jboss/weld/bean/AbstractBean.java

@@ -385,7 +385,7 @@ public Class<T> getType()
     * 
     * @return The set of API types
     * 
-    * @see org.jboss.weld.bean.BaseBean#getTypeClosure()
+    * @see org.jboss.weld.bean.BaseBean#getTypes()
     */
    public Set<Type> getTypes()
    {

impl/src/main/java/org/jboss/weld/bean/builtin/FacadeBeanResolvableTransformer.java

@@ -70,7 +70,7 @@ public Set<Annotation> getQualifiers()
             }
 
             @Override
-            public Set<Type> getTypeClosure()
+            public Set<Type> getTypes()
             {
                return Collections.unmodifiableSet(types);
             }

impl/src/main/java/org/jboss/weld/bean/builtin/InstanceImpl.java

@@ -38,7 +38,7 @@
 import org.jboss.weld.exceptions.InvalidObjectException;
 import org.jboss.weld.injection.CurrentInjectionPoint;
 import org.jboss.weld.manager.BeanManagerImpl;
-import org.jboss.weld.resolution.ResolvableWeldClass;
+import org.jboss.weld.resolution.ResolvableBuilder;
 import org.jboss.weld.util.Beans;
 import org.jboss.weld.util.Names;
 
@@ -65,8 +65,8 @@ private InstanceImpl(Type type, Annotation[] qualifiers, InjectionPoint injectio
    }
 
    public T get()
-   {
-      Bean<?> bean = getBeanManager().getBean(ResolvableWeldClass.of(getType(), getQualifiers(), getBeanManager()), getQualifiers());
+   {      
+      Bean<?> bean = getBeanManager().getBean(new ResolvableBuilder().setType(getType()).addQualifiers(getQualifiers()).setDeclaringBean(getInjectionPoint().getBean()).create());
       // Push in an empty CC to ensure that we don't get the CC of whatever is injecting the bean containing the Instance injection point
       try
       {

impl/src/main/java/org/jboss/weld/bootstrap/BeanDeployerEnvironment.java

@@ -50,7 +50,7 @@
 import org.jboss.weld.introspector.WeldClass;
 import org.jboss.weld.introspector.WeldMethod;
 import org.jboss.weld.manager.BeanManagerImpl;
-import org.jboss.weld.resolution.ResolvableFactory;
+import org.jboss.weld.resolution.ResolvableBuilder;
 import org.jboss.weld.resolution.TypeSafeDisposerResolver;
 import org.jboss.weld.resources.ClassTransformer;
 import org.jboss.weld.util.AnnotatedTypes;
@@ -282,12 +282,12 @@ public EjbDescriptors getEjbDescriptors()
     * disposal methods are used. For internal use.
     * 
     * @param apiType The API type to match
-    * @param bindings The binding types to match
+    * @param qualifiers The binding types to match
     * @return The set of matching disposal methods
     */
-   public <X> Set<DisposalMethod<X, ?>> resolveDisposalBeans(Set<Type> types, Set<Annotation> bindings, AbstractClassBean<X> declaringBean)
+   public <X> Set<DisposalMethod<X, ?>> resolveDisposalBeans(Set<Type> types, Set<Annotation> qualifiers, AbstractClassBean<X> declaringBean)
    {
-      Set<DisposalMethod<X, ?>> beans = (Set) disposalMethodResolver.resolve(ResolvableFactory.of(types, bindings, declaringBean));
+      Set<DisposalMethod<X, ?>> beans = (Set) disposalMethodResolver.resolve(new ResolvableBuilder().addTypes(types).addQualifiers(qualifiers).setDeclaringBean(declaringBean).create());
       resolvedDisposalBeans.addAll(beans);
       return Collections.unmodifiableSet(beans);
    }

impl/src/main/java/org/jboss/weld/bootstrap/Validator.java

@@ -84,10 +84,8 @@
 import org.jboss.weld.exceptions.NullableDependencyException;
 import org.jboss.weld.exceptions.UnproxyableResolutionException;
 import org.jboss.weld.exceptions.UnserializableDependencyException;
-import org.jboss.weld.introspector.WeldAnnotated;
 import org.jboss.weld.manager.BeanManagerImpl;
 import org.jboss.weld.metadata.cache.MetaAnnotationStore;
-import org.jboss.weld.resolution.ResolvableWeldClass;
 import org.jboss.weld.serialization.spi.helpers.SerializableContextual;
 import org.jboss.weld.util.Beans;
 import org.jboss.weld.util.Proxies;
@@ -180,7 +178,7 @@ private void validateDirectlyDefinedInterceptorClasses(BeanManagerImpl beanManag
                InjectionTarget<Object> injectionTarget = (InjectionTarget<Object>) beanManager.createInjectionTarget(beanManager.createAnnotatedType(interceptorClass));
                for (InjectionPoint injectionPoint : injectionTarget.getInjectionPoints())
                {
-                  Bean<?> resolvedBean = beanManager.resolve(beanManager.getInjectableBeans(injectionPoint));
+                  Bean<?> resolvedBean = beanManager.resolve(beanManager.getBeans(injectionPoint));
                   validateInjectionPointPassivationCapable(injectionPoint, resolvedBean, beanManager);
                }
             }
@@ -204,7 +202,7 @@ private void validateCdiBoundInterceptors(BeanManagerImpl beanManager, AbstractC
                }
                for (InjectionPoint injectionPoint : serializableContextual.get().getInjectionPoints())
                {
-                  Bean<?> resolvedBean = beanManager.resolve(beanManager.getInjectableBeans(injectionPoint));
+                  Bean<?> resolvedBean = beanManager.resolve(beanManager.getBeans(injectionPoint));
                   validateInjectionPointPassivationCapable(injectionPoint, resolvedBean, beanManager);
                }
             }
@@ -222,7 +220,7 @@ private void validateDecorators(BeanManagerImpl beanManager, AbstractClassBean<?
          }
          for (InjectionPoint ij : decorator.getInjectionPoints())
          {
-            Bean<?> resolvedBean = beanManager.resolve(beanManager.getInjectableBeans(ij));
+            Bean<?> resolvedBean = beanManager.resolve(beanManager.getBeans(ij));
             validateInjectionPointPassivationCapable(ij, resolvedBean, beanManager);
          }
       }
@@ -257,8 +255,7 @@ public void validateInjectionPoint(InjectionPoint ij, BeanManagerImpl beanManage
       checkFacadeInjectionPoint(ij, Instance.class);
       checkFacadeInjectionPoint(ij, Event.class);
       Annotation[] bindings = ij.getQualifiers().toArray(new Annotation[0]);
-      WeldAnnotated<?, ?> annotatedItem = ResolvableWeldClass.of(ij.getType(), bindings, beanManager);
-      Set<?> resolvedBeans = beanManager.getBeanResolver().resolve(beanManager.getInjectableBeans(ij));
+      Set<?> resolvedBeans = beanManager.getBeanResolver().resolve(beanManager.getBeans(ij));
       if (!isInjectionPointSatisfied(ij, resolvedBeans, beanManager))
       {
          throw new DeploymentException(INJECTION_POINT_HAS_UNSATISFIED_DEPENDENCIES, ij, Arrays.toString(bindings));
@@ -275,7 +272,7 @@ public void validateInjectionPoint(InjectionPoint ij, BeanManagerImpl beanManage
          {
             throw new UnproxyableResolutionException(INJECTION_POINT_HAS_NON_PROXYABLE_DEPENDENCIES, ij);
          }
-         if (annotatedItem.isPrimitive() && resolvedBean.isNullable())
+         if (Reflections.isPrimitive(ij.getType()) && resolvedBean.isNullable())
          {
             throw new NullableDependencyException(INJECTION_POINT_HAS_NULLABLE_DEPENDENCIES, ij);
          }

impl/src/main/java/org/jboss/weld/manager/BeanManagerImpl.java

@@ -19,11 +19,6 @@
 import static org.jboss.weld.logging.messages.BeanManagerMessage.AMBIGUOUS_BEANS_FOR_DEPENDENCY;
 import static org.jboss.weld.logging.messages.BeanManagerMessage.CONTEXT_NOT_ACTIVE;
 import static org.jboss.weld.logging.messages.BeanManagerMessage.DUPLICATE_ACTIVE_CONTEXTS;
-import static org.jboss.weld.logging.messages.BeanManagerMessage.DUPLICATE_INTERCEPTOR_BINDING;
-import static org.jboss.weld.logging.messages.BeanManagerMessage.DUPLICATE_QUALIFIERS;
-import static org.jboss.weld.logging.messages.BeanManagerMessage.INTERCEPTOR_BINDINGS_EMPTY;
-import static org.jboss.weld.logging.messages.BeanManagerMessage.INTERCEPTOR_RESOLUTION_WITH_NONBINDING_TYPE;
-import static org.jboss.weld.logging.messages.BeanManagerMessage.INVALID_QUALIFIER;
 import static org.jboss.weld.logging.messages.BeanManagerMessage.NON_NORMAL_SCOPE;
 import static org.jboss.weld.logging.messages.BeanManagerMessage.NOT_INTERCEPTOR_BINDING_TYPE;
 import static org.jboss.weld.logging.messages.BeanManagerMessage.NOT_PROXYABLE;
@@ -38,7 +33,6 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -66,7 +60,6 @@
 import javax.enterprise.inject.spi.Interceptor;
 import javax.enterprise.inject.spi.ObserverMethod;
 import javax.enterprise.inject.spi.PassivationCapable;
-import javax.inject.Qualifier;
 
 import org.jboss.interceptor.registry.InterceptorRegistry;
 import org.jboss.weld.Container;
@@ -96,16 +89,15 @@
 import org.jboss.weld.exceptions.UnproxyableResolutionException;
 import org.jboss.weld.exceptions.UnsatisfiedResolutionException;
 import org.jboss.weld.injection.CurrentInjectionPoint;
-import org.jboss.weld.introspector.WeldAnnotated;
 import org.jboss.weld.literal.AnyLiteral;
 import org.jboss.weld.manager.api.WeldManager;
 import org.jboss.weld.metadata.cache.MetaAnnotationStore;
 import org.jboss.weld.metadata.cache.ScopeModel;
 import org.jboss.weld.resolution.InterceptorResolvable;
+import org.jboss.weld.resolution.InterceptorResolvableBuilder;
 import org.jboss.weld.resolution.NameBasedResolver;
 import org.jboss.weld.resolution.Resolvable;
-import org.jboss.weld.resolution.ResolvableFactory;
-import org.jboss.weld.resolution.ResolvableWeldClass;
+import org.jboss.weld.resolution.ResolvableBuilder;
 import org.jboss.weld.resolution.TypeSafeBeanResolver;
 import org.jboss.weld.resolution.TypeSafeDecoratorResolver;
 import org.jboss.weld.resolution.TypeSafeInterceptorResolver;
@@ -486,35 +478,9 @@ public void addInterceptor(Interceptor<?> bean)
 
 
    @SuppressWarnings("unchecked")
-   public <T> Set<ObserverMethod<? super T>> resolveObserverMethods(Type eventType, Annotation... bindings)
-   {
-      checkQualifiers(Arrays.asList(bindings));    
-      HashSet<Annotation> bindingAnnotations = new HashSet<Annotation>(Arrays.asList(bindings));
-      bindingAnnotations.add(AnyLiteral.INSTANCE);
-      Set<ObserverMethod<? super T>> observers = new HashSet<ObserverMethod<? super T>>();
-      Set<ObserverMethod<?>> eventObservers = observerResolver.resolve(ResolvableFactory.of(new HierarchyDiscovery(eventType).getTypeClosure(),  bindingAnnotations, null));
-      for (ObserverMethod<?> observer : eventObservers)
-      {
-         observers.add((ObserverMethod<T>) observer);
-      }
-      return observers;
-   }
-
-   private void checkQualifiers(Collection<Annotation> bindings)
+   public <T> Set<ObserverMethod<? super T>> resolveObserverMethods(Type eventType, Annotation... qualifiers)
    {
-      HashSet<Annotation> bindingAnnotations = new HashSet<Annotation>(bindings);
-      for (Annotation annotation : bindings)
-      {
-         if (!getServices().get(MetaAnnotationStore.class).getBindingTypeModel(annotation.annotationType()).isValid())
-         {
-            throw new ForbiddenArgumentException(INVALID_QUALIFIER, annotation);
-         }
-      }
-      if (bindingAnnotations.size() < bindings.size())
-      {
-         throw new ForbiddenArgumentException(DUPLICATE_QUALIFIERS, bindings);
-      }
-
+      return (Set) observerResolver.resolve(new ResolvableBuilder().addTypes(new HierarchyDiscovery(eventType).getTypeClosure()).addQualifiers(qualifiers).addQualifierIfAbsent(AnyLiteral.INSTANCE).create());
    }
 
    /**
@@ -575,39 +541,12 @@ public void setEnabledInterceptorClasses(List<Class<?>> enabledInterceptorClasse
       this.enabledInterceptorClasses = enabledInterceptorClasses;
    }
 
-   public Set<Bean<?>> getBeans(Type beanType, Annotation... bindings)
+   public Set<Bean<?>> getBeans(Type beanType, Annotation... qualifiers)
    {
-      return getBeans(ResolvableWeldClass.of(beanType, bindings, this), bindings);
-   }
-
-   public Set<Bean<?>> getBeans(WeldAnnotated<?, ?> element, Annotation... bindings)
-   {
-      for (Annotation annotation : element.getAnnotations())
-      {
-         if (!getServices().get(MetaAnnotationStore.class).getBindingTypeModel(annotation.annotationType()).isValid())
-         {
-            throw new ForbiddenArgumentException(INVALID_QUALIFIER, annotation);
-         }
-      }
-//      for (Type type : element.getActualTypeArguments())
-//      {
-//         if (type instanceof WildcardType)
-//         {
-//            throw new IllegalArgumentException("Cannot resolve a type parameterized with a wildcard " + element);
-//         }
-//         if (type instanceof TypeVariable<?>)
-//         {
-//            throw new IllegalArgumentException("Cannot resolve a type parameterized with a type parameter " + element);
-//         }
-//      }
-      if (bindings != null && bindings.length > element.getMetaAnnotations(Qualifier.class).size())
-      {
-         throw new ForbiddenArgumentException(DUPLICATE_QUALIFIERS, Arrays.asList(bindings));
-      }
-      return beanResolver.resolve(ResolvableFactory.of(element));
+      return beanResolver.resolve(new ResolvableBuilder().setType(beanType).addQualifiers(qualifiers).create());
    }
 
-   public Set<Bean<?>> getInjectableBeans(InjectionPoint injectionPoint)
+   public Set<Bean<?>> getBeans(InjectionPoint injectionPoint)
    {
       boolean registerInjectionPoint = !injectionPoint.getType().equals(InjectionPoint.class);
       try
@@ -616,17 +555,7 @@ public Set<Bean<?>> getInjectableBeans(InjectionPoint injectionPoint)
          {
             Container.instance().services().get(CurrentInjectionPoint.class).push(injectionPoint);
          }
-         // TODO Do this properly
-         Set<Bean<?>> beans = getBeans(ResolvableWeldClass.of(injectionPoint.getType(), injectionPoint.getQualifiers().toArray(new Annotation[0]), this));
-         Set<Bean<?>> injectableBeans = new HashSet<Bean<?>>();
-         for (Bean<?> bean : beans)
-         {
-            if (!(bean instanceof Decorator<?> || bean instanceof Interceptor<?>))
-            {
-               injectableBeans.add(bean);
-            }
-         }
-         return injectableBeans;
+         return beanResolver.resolve(new ResolvableBuilder().setInjectionPoint(injectionPoint).create());
       }
       finally
       {
@@ -869,8 +798,7 @@ public Object getInjectableReference(InjectionPoint injectionPoint, CreationalCo
    {
       if (!injectionPoint.isDelegate())
       {
-         WeldAnnotated<?, ?> element = ResolvableWeldClass.of(injectionPoint.getType(), injectionPoint.getQualifiers().toArray(new Annotation[0]), this);
-         Bean<?> resolvedBean = getBean(element, element.getBindingsAsArray());
+         Bean<?> resolvedBean = getBean(new ResolvableBuilder().setInjectionPoint(injectionPoint).create());
          return getReference(injectionPoint, resolvedBean, creationalContext);
       }
       else
@@ -879,12 +807,12 @@ public Object getInjectableReference(InjectionPoint injectionPoint, CreationalCo
       }
    }
 
-   public <T> Bean<T> getBean(WeldAnnotated<T, ?> element, Annotation... qualifiers)
+   public <T> Bean<T> getBean(Resolvable resolvable)
    {
-      Bean<T> bean = (Bean<T>) resolve(getBeans(element, qualifiers));
+      Bean<T> bean = (Bean<T>) resolve(beanResolver.resolve(resolvable));
       if (bean == null)
       {
-         throw new UnsatisfiedResolutionException(UNRESOLVABLE_ELEMENT, element);
+         throw new UnsatisfiedResolutionException(UNRESOLVABLE_ELEMENT, resolvable);
       }
 
       boolean normalScoped = getServices().get(MetaAnnotationStore.class).getScopeModel(bean.getScope()).isNormal();
@@ -902,25 +830,24 @@ public Set<Bean<?>> getBeans(String name)
 
    public List<Decorator<?>> resolveDecorators(Set<Type> types, Annotation... qualifiers)
    {
-      checkResolveDecoratorsArguments(types, Arrays.asList(qualifiers));
+      checkResolveDecoratorsArguments(types);
       // TODO Fix this cast and make the resolver return a list
-      return new ArrayList<Decorator<?>>(decoratorResolver.resolve(ResolvableFactory.of(types, qualifiers, null)));
+      return new ArrayList<Decorator<?>>(decoratorResolver.resolve(new ResolvableBuilder().addTypes(types).addQualifiers(qualifiers).create()));
    }
 
    public List<Decorator<?>> resolveDecorators(Set<Type> types, Set<Annotation> qualifiers)
    {
-      checkResolveDecoratorsArguments(types, qualifiers);
+      checkResolveDecoratorsArguments(types);
       // TODO Fix this cast and make the resolver return a list
-      return new ArrayList<Decorator<?>>(decoratorResolver.resolve(ResolvableFactory.of(types, qualifiers, null)));
+      return new ArrayList<Decorator<?>>(decoratorResolver.resolve(new ResolvableBuilder().addTypes(types).addQualifiers(qualifiers).create()));
    }
 
-   private void checkResolveDecoratorsArguments(Set<Type> types, Collection<Annotation> qualifiers)
+   private void checkResolveDecoratorsArguments(Set<Type> types)
    {
       if (types.isEmpty())
       {
          throw new ForbiddenArgumentException(NO_DECORATOR_TYPES);
       }
-      checkQualifiers(qualifiers);
    }
 
    /**
@@ -936,18 +863,7 @@ private void checkResolveDecoratorsArguments(Set<Type> types, Collection<Annotat
     */
    public List<Interceptor<?>> resolveInterceptors(InterceptionType type, Annotation... interceptorBindings)
    {
-      if (interceptorBindings.length == 0)
-         throw new ForbiddenArgumentException(INTERCEPTOR_BINDINGS_EMPTY);
-      Set<Class<?>> uniqueInterceptorBindings = new HashSet<Class<?>>();
-      for (Annotation interceptorBinding: interceptorBindings)
-      {
-         if (uniqueInterceptorBindings.contains(interceptorBinding.annotationType()))
-            throw new ForbiddenArgumentException(DUPLICATE_INTERCEPTOR_BINDING, interceptorBinding.annotationType());
-         if (!isInterceptorBinding(interceptorBinding.annotationType()))
-            throw new ForbiddenArgumentException(INTERCEPTOR_RESOLUTION_WITH_NONBINDING_TYPE, interceptorBinding.annotationType());
-         uniqueInterceptorBindings.add(interceptorBinding.annotationType());
-      }
-      return new ArrayList<Interceptor<?>>(interceptorResolver.resolve(ResolvableFactory.of(type,interceptorBindings)));
+      return new ArrayList<Interceptor<?>>(interceptorResolver.resolve(new InterceptorResolvableBuilder().setInterceptionType(type).setType(Object.class).addQualifiers(interceptorBindings).create()));
    }
 
    /**

impl/src/main/java/org/jboss/weld/resolution/ForwardingInterceptorResolvable.java

@@ -57,7 +57,7 @@ public Set<Annotation> getQualifiers()
       return null;
    }
 
-   public Set<Type> getTypeClosure()
+   public Set<Type> getTypes()
    {
       // TODO Auto-generated method stub
       return null;

impl/src/main/java/org/jboss/weld/resolution/ForwardingResolvable.java

@@ -20,7 +20,7 @@
 import java.lang.reflect.Type;
 import java.util.Set;
 
-import org.jboss.weld.bean.AbstractClassBean;
+import javax.enterprise.inject.spi.Bean;
 
 public abstract class ForwardingResolvable implements Resolvable
 {
@@ -37,9 +37,9 @@ public boolean isAnnotationPresent(Class<? extends Annotation> annotationType)
       return delegate().isAnnotationPresent(annotationType);
    }
 
-   public Set<Type> getTypeClosure()
+   public Set<Type> getTypes()
    {
-      return delegate().getTypeClosure();
+      return delegate().getTypes();
    }
 
    public boolean isAssignableTo(Class<?> clazz)
@@ -57,7 +57,7 @@ public Class<?> getJavaClass()
       return delegate().getJavaClass();
    }
 
-   public AbstractClassBean<?> getDeclaringBean()
+   public Bean<?> getDeclaringBean()
    {
       return delegate().getDeclaringBean();
    }