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);
}
