fields) {
return Maps.toMap(
dependencies,
dep -> frameworkTypeUsageStatement(CodeBlock.of("$N", fields.get(dep)), dep.kind()));
}
public static String generatedProxyMethodName(ContributionBinding binding) {
switch (binding.kind()) {
case INJECTION:
case ASSISTED_INJECTION:
return "newInstance";
case PROVISION:
XMethodElement method = asMethod(binding.bindingElement().get());
String simpleName = getSimpleName(method);
// If the simple name is already defined in the factory, prepend "proxy" to the name.
return simpleName.contentEquals("get") || simpleName.contentEquals("create")
? "proxy" + LOWER_CAMEL.to(UPPER_CAMEL, simpleName)
: simpleName;
default:
throw new AssertionError("Unexpected binding kind: " + binding);
}
}
/** Returns the generated factory or members injector name for a binding. */
public static XClassName generatedClassNameForBinding(Binding binding) {
switch (binding.kind()) {
case ASSISTED_INJECTION:
case INJECTION:
case PROVISION:
case PRODUCTION:
return factoryNameForElement(asExecutable(binding.bindingElement().get()));
case ASSISTED_FACTORY:
return siblingClassName(asTypeElement(binding.bindingElement().get()), "_Impl");
case MEMBERS_INJECTION:
return membersInjectorNameForType(
((MembersInjectionBinding) binding).membersInjectedType());
default:
throw new AssertionError();
}
}
/**
* Returns the generated factory name for the given element.
*
* This method is useful during validation before a {@link Binding} can be created. If a
* binding already exists for the given element, prefer to call {@link
* #generatedClassNameForBinding(Binding)} instead since this method does not validate that the
* given element is actually a binding element or not.
*/
public static XClassName factoryNameForElement(XExecutableElement element) {
return elementBasedClassName(element, "Factory");
}
/**
* Calculates an appropriate {@link XClassName} for a generated class that is based on {@code
* element}, appending {@code suffix} at the end.
*
*
This will always return a top level class name, even if {@code element}'s enclosing class is
* a nested type.
*/
public static XClassName elementBasedClassName(XExecutableElement element, String suffix) {
XClassName enclosingClassName = element.getEnclosingElement().asClassName();
String methodName =
isConstructor(element) ? "" : LOWER_CAMEL.to(UPPER_CAMEL, getSimpleName(element));
return XClassName.Companion.get(
enclosingClassName.getPackageName(),
classFileName(enclosingClassName) + "_" + methodName + suffix);
}
public static TypeName parameterizedGeneratedTypeNameForBinding(Binding binding) {
ClassName className = toJavaPoet(generatedClassNameForBinding(binding));
ImmutableList typeParameters = bindingTypeElementTypeVariableNames(binding);
return typeParameters.isEmpty()
? className
: ParameterizedTypeName.get(className, Iterables.toArray(typeParameters, TypeName.class));
}
public static XClassName membersInjectorNameForType(XTypeElement typeElement) {
return siblingClassName(typeElement, "_MembersInjector");
}
public static String memberInjectedFieldSignatureForVariable(XFieldElement field) {
return field.getEnclosingElement().getClassName().canonicalName() + "." + getSimpleName(field);
}
/*
* TODO(ronshapiro): this isn't perfect, as collisions could still exist. Some examples:
*
* - @Inject void members() {} will generate a method that conflicts with the instance
* method `injectMembers(T)`
* - Adding the index could conflict with another member:
* @Inject void a(Object o) {}
* @Inject void a(String s) {}
* @Inject void a1(String s) {}
*
* Here, Method a(String) will add the suffix "1", which will conflict with the method
* generated for a1(String)
* - Members named "members" or "methods" could also conflict with the {@code static} injection
* method.
*/
public static String membersInjectorMethodName(InjectionSite injectionSite) {
int index = injectionSite.indexAmongAtInjectMembersWithSameSimpleName();
String indexString = index == 0 ? "" : String.valueOf(index + 1);
return "inject"
+ LOWER_CAMEL.to(UPPER_CAMEL, getSimpleName(injectionSite.element()))
+ indexString;
}
public static String classFileName(XClassName className) {
return CLASS_FILE_NAME_JOINER.join(className.getSimpleNames());
}
public static XClassName generatedMonitoringModuleName(XTypeElement componentElement) {
return siblingClassName(componentElement, "_MonitoringModule");
}
// TODO(ronshapiro): when JavaPoet migration is complete, replace the duplicated code
// which could use this.
private static XClassName siblingClassName(XTypeElement typeElement, String suffix) {
XClassName className = typeElement.asClassName();
return XClassName.Companion.get(className.getPackageName(), classFileName(className) + suffix);
}
/**
* The {@link java.util.Set} factory class name appropriate for set bindings.
*
*
* - {@link dagger.producers.internal.SetFactory} for provision bindings.
*
- {@link dagger.producers.internal.SetProducer} for production bindings for {@code Set}.
*
- {@link dagger.producers.internal.SetOfProducedProducer} for production bindings for
* {@code Set>}.
*
*/
public static XClassName setFactoryClassName(MultiboundSetBinding binding) {
switch (binding.bindingType()) {
case PROVISION:
return XTypeNames.SET_FACTORY;
case PRODUCTION:
SetType setType = SetType.from(binding.key());
return setType.elementsAreTypeOf(TypeNames.PRODUCED)
? XTypeNames.SET_OF_PRODUCED_PRODUCER
: XTypeNames.SET_PRODUCER;
default:
throw new IllegalArgumentException(binding.bindingType().toString());
}
}
/** The {@link java.util.Map} factory class name appropriate for map bindings. */
public static XClassName mapFactoryClassName(MultiboundMapBinding binding) {
MapType mapType = MapType.from(binding.key());
switch (binding.bindingType()) {
case PROVISION:
return mapType.valuesAreTypeOf(PROVIDER)
? XTypeNames.MAP_PROVIDER_FACTORY : XTypeNames.MAP_FACTORY;
case PRODUCTION:
return mapType.valuesAreFrameworkType()
? mapType.valuesAreTypeOf(PRODUCER)
? XTypeNames.MAP_OF_PRODUCER_PRODUCER
: XTypeNames.MAP_OF_PRODUCED_PRODUCER
: XTypeNames.MAP_PRODUCER;
default:
throw new IllegalArgumentException(binding.bindingType().toString());
}
}
public static ImmutableList bindingTypeElementTypeVariableNames(
Binding binding) {
if (binding instanceof ContributionBinding) {
ContributionBinding contributionBinding = (ContributionBinding) binding;
if (!(contributionBinding.kind() == INJECTION
|| contributionBinding.kind() == ASSISTED_INJECTION)
&& !contributionBinding.requiresModuleInstance()) {
return ImmutableList.of();
}
}
return typeVariableNames(binding.bindingTypeElement().get());
}
/**
* Returns a name to be used for variables of the given {@linkplain XTypeElement type}. Prefer
* semantically meaningful variable names, but if none can be derived, this will produce something
* readable.
*/
// TODO(gak): maybe this should be a function of TypeMirrors instead of Elements?
public static String simpleVariableName(XTypeElement typeElement) {
return simpleVariableName(typeElement.asClassName());
}
/**
* Returns a name to be used for variables of the given {@link XClassName}. Prefer semantically
* meaningful variable names, but if none can be derived, this will produce something readable.
*/
public static String simpleVariableName(XClassName className) {
String candidateName = UPPER_CAMEL.to(LOWER_CAMEL, simpleName(className));
String variableName = protectAgainstKeywords(candidateName);
verify(isName(variableName), "'%s' was expected to be a valid variable name", variableName);
return variableName;
}
public static String protectAgainstKeywords(String candidateName) {
switch (candidateName) {
case "package":
return "pkg";
case "boolean":
return "b";
case "double":
return "d";
case "byte":
return "b";
case "int":
return "i";
case "short":
return "s";
case "char":
return "c";
case "void":
return "v";
case "class":
return "clazz";
case "float":
return "f";
case "long":
return "l";
default:
return SourceVersion.isKeyword(candidateName) ? candidateName + '_' : candidateName;
}
}
}