fields) {
return Maps.toMap(
dependencies,
dep -> frameworkTypeUsageStatement(CodeBlock.of("$N", fields.get(dep)), dep.kind()));
}
/** Returns the generated factory or members injector name for a binding. */
public static ClassName generatedClassNameForBinding(Binding binding) {
switch (binding.bindingType()) {
case PROVISION:
case PRODUCTION:
ContributionBinding contribution = (ContributionBinding) binding;
switch (contribution.kind()) {
case ASSISTED_INJECTION:
case INJECTION:
case PROVISION:
case PRODUCTION:
return elementBasedClassName(
MoreElements.asExecutable(binding.bindingElement().get()), "Factory");
case ASSISTED_FACTORY:
return siblingClassName(MoreElements.asType(binding.bindingElement().get()), "_Impl");
default:
throw new AssertionError();
}
case MEMBERS_INJECTION:
return membersInjectorNameForType(
((MembersInjectionBinding) binding).membersInjectedType());
}
throw new AssertionError();
}
/**
* Calculates an appropriate {@link ClassName} for a generated class that is based on {@code
* element}, appending {@code suffix} at the end.
*
* This will always return a {@linkplain ClassName#topLevelClassName() top level class name},
* even if {@code element}'s enclosing class is a nested type.
*/
public static ClassName elementBasedClassName(ExecutableElement element, String suffix) {
ClassName enclosingClassName =
ClassName.get(MoreElements.asType(element.getEnclosingElement()));
String methodName =
element.getKind().equals(ElementKind.CONSTRUCTOR)
? ""
: LOWER_CAMEL.to(UPPER_CAMEL, element.getSimpleName().toString());
return ClassName.get(
enclosingClassName.packageName(),
classFileName(enclosingClassName) + "_" + methodName + suffix);
}
public static TypeName parameterizedGeneratedTypeNameForBinding(Binding binding) {
ClassName className = generatedClassNameForBinding(binding);
ImmutableList typeParameters = bindingTypeElementTypeVariableNames(binding);
return typeParameters.isEmpty()
? className
: ParameterizedTypeName.get(className, Iterables.toArray(typeParameters, TypeName.class));
}
public static ClassName membersInjectorNameForType(TypeElement typeElement) {
return siblingClassName(typeElement, "_MembersInjector");
}
public static String memberInjectedFieldSignatureForVariable(VariableElement variableElement) {
return MoreElements.asType(variableElement.getEnclosingElement()).getQualifiedName()
+ "."
+ variableElement.getSimpleName();
}
public static String classFileName(ClassName className) {
return CLASS_FILE_NAME_JOINER.join(className.simpleNames());
}
public static ClassName generatedMonitoringModuleName(TypeElement componentElement) {
return siblingClassName(componentElement, "_MonitoringModule");
}
// TODO(ronshapiro): when JavaPoet migration is complete, replace the duplicated code
// which could use this.
private static ClassName siblingClassName(TypeElement typeElement, String suffix) {
ClassName className = ClassName.get(typeElement);
return className.topLevelClassName().peerClass(classFileName(className) + suffix);
}
/**
* The {@link java.util.Set} factory class name appropriate for set bindings.
*
*
* - {@link SetFactory} for provision bindings.
*
- {@link SetProducer} for production bindings for {@code Set}.
*
- {@link SetOfProducedProducer} for production bindings for {@code Set>}.
*
*/
public static ClassName setFactoryClassName(ContributionBinding binding) {
checkArgument(binding.kind().equals(MULTIBOUND_SET));
if (binding.bindingType().equals(BindingType.PROVISION)) {
return SET_FACTORY;
} else {
SetType setType = SetType.from(binding.key());
return setType.elementsAreTypeOf(Produced.class) ? SET_OF_PRODUCED_PRODUCER : SET_PRODUCER;
}
}
/** The {@link java.util.Map} factory class name appropriate for map bindings. */
public static ClassName mapFactoryClassName(ContributionBinding binding) {
checkState(binding.kind().equals(MULTIBOUND_MAP), binding.kind());
MapType mapType = MapType.from(binding.key());
switch (binding.bindingType()) {
case PROVISION:
return mapType.valuesAreTypeOf(Provider.class) ? MAP_PROVIDER_FACTORY : MAP_FACTORY;
case PRODUCTION:
return mapType.valuesAreFrameworkType()
? mapType.valuesAreTypeOf(Producer.class)
? MAP_OF_PRODUCER_PRODUCER
: MAP_OF_PRODUCED_PRODUCER
: 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();
}
}
List typeParameters =
binding.bindingTypeElement().get().getTypeParameters();
return typeParameters.stream().map(TypeVariableName::get).collect(toImmutableList());
}
/**
* Returns a name to be used for variables of the given {@linkplain TypeElement 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(TypeElement typeElement) {
String candidateName = UPPER_CAMEL.to(LOWER_CAMEL, typeElement.getSimpleName().toString());
String variableName = protectAgainstKeywords(candidateName);
verify(isName(variableName), "'%s' was expected to be a valid variable name");
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;
}
}
private SourceFiles() {}
}