private <T> ProviderMethod<T> createProviderMethod( Binder binder, Method method, Annotation annotation) { binder = binder.withSource(method); Errors errors = new Errors(method); // prepare the parameter providers InjectionPoint point = InjectionPoint.forMethod(method, typeLiteral); List<Dependency<?>> dependencies = point.getDependencies(); List<Provider<?>> parameterProviders = Lists.newArrayList(); for (Dependency<?> dependency : point.getDependencies()) { parameterProviders.add(binder.getProvider(dependency)); } @SuppressWarnings("unchecked") // Define T as the method's return type. TypeLiteral<T> returnType = (TypeLiteral<T>) typeLiteral.getReturnType(method); Key<T> key = getKey(errors, returnType, method, method.getAnnotations()); try { key = scanner.prepareMethod(binder, annotation, key, point); } catch (Throwable t) { binder.addError(t); } Class<? extends Annotation> scopeAnnotation = Annotations.findScopeAnnotation(errors, method.getAnnotations()); for (Message message : errors.getMessages()) { binder.addError(message); } return ProviderMethod.create( key, method, delegate, ImmutableSet.copyOf(dependencies), parameterProviders, scopeAnnotation, skipFastClassGeneration, annotation); }
public void applyTo(Binder binder) { getScoping() .applyTo( binder.withSource(getSource()).bind(getKey()).toProvider(getUserSuppliedProvider())); }
public void applyTo(Binder binder) { binder.withSource(getSource()).bindScope(annotationType, scope); }
@Override public void applyTo(Binder binder) { getScoping().applyTo(binder.withSource(getSource()).bind(getKey())); }
@Override public Binder withSource(Object source) { return binder.withSource(source); }
@Override public void bindListener(Matcher<? super TypeLiteral<?>> typeMatcher, TypeListener listener) { binder.withSource(getBindingLocation()).bindListener(typeMatcher, listener); }
@Override public void install(Module module) { binder.withSource(getBindingLocation()).install(module); }
@Override public void requestStaticInjection(Class<?>... types) { binder.withSource(getBindingLocation()).requestStaticInjection(types); }
@Override public void requestInjection(Object instance) { binder.withSource(getBindingLocation()).requestInjection(instance); }
@Override public <T> void requestInjection(TypeLiteral<T> type, T instance) { binder.withSource(getBindingLocation()).requestInjection(type, instance); }
@Override public AnnotatedConstantBindingBuilder bindConstant() { return binder.withSource(getBindingLocation()).bindConstant(); }
@Override public <T> AnnotatedBindingBuilder<T> bind(Class<T> type) { warnOnSpecialized(type); return binder.withSource(getBindingLocation()).bind(type); }
@Override public <T> AnnotatedBindingBuilder<T> bind(TypeLiteral<T> typeLiteral) { warnOnSpecialized(typeLiteral.getRawType()); return binder.withSource(getBindingLocation()).bind(typeLiteral); }
@Override public <T> LinkedBindingBuilder<T> bind(Key<T> key) { warnOnSpecialized(key.getTypeLiteral().getRawType()); return binder.withSource(getBindingLocation()).bind(key); }