@Override public Void visitExecutableAsMethod(ExecutableElement methodElement, Void aVoid) { injectBindingRegistry.tryRegisterMembersInjectedType( MoreElements.asType(methodElement.getEnclosingElement())); return null; } };
/** * Returns {@code true} if {@code overrider} overrides {@code overridden} considered from within * the type that declares {@code overrider}. */ // TODO(dpb): Does this break for ECJ? private boolean overridesAsDeclared(ExecutableElement overridder, ExecutableElement overridden) { return elements.overrides(overridder, overridden, asType(overridder.getEnclosingElement())); }
@Override protected void process( TypeElement element, ImmutableSet<Class<? extends Annotation>> annotations) { monitoringModuleGenerator.generate(MoreElements.asType(element), messager); } }
@Override public Optional<OptionalKind> visitDeclared(DeclaredType t, Void p) { for (OptionalKind optionalKind : OptionalKind.values()) { Name qualifiedName = MoreElements.asType(t.asElement()).getQualifiedName(); if (qualifiedName.contentEquals(optionalKind.clazz.getCanonicalName())) { return Optional.of(optionalKind); } } return Optional.empty(); } };
private TypeMirror unwrapTypeOrDefault(TypeMirror type, TypeMirror defaultType) { DeclaredType declaredType = MoreTypes.asDeclared(type); TypeElement typeElement = MoreElements.asType(declaredType.asElement()); checkArgument( !typeElement.getTypeParameters().isEmpty(), "%s does not have a type parameter", typeElement.getQualifiedName()); return getOnlyElement(declaredType.getTypeArguments(), defaultType); }
private String implicitlyIncludedModuleName(ExecutableElement method) { return getPackage(method).getQualifiedName() + "." + classFileName(ClassName.get(MoreElements.asType(method.getEnclosingElement()))) + "_" + LOWER_CAMEL.to(UPPER_CAMEL, method.getSimpleName().toString()); } }
private ImmutableList<TypeMirror> methodParameterTypes(DeclaredType type, String methodName) { ImmutableList.Builder<ExecutableElement> methodsForName = ImmutableList.builder(); for (ExecutableElement method : methodsIn(MoreElements.asType(type.asElement()).getEnclosedElements())) { if (method.getSimpleName().contentEquals(methodName)) { methodsForName.add(method); } } ExecutableElement method = getOnlyElement(methodsForName.build()); return ImmutableList.copyOf( MoreTypes.asExecutable(types.asMemberOf(type, method)).getParameterTypes()); }
TypeElement typeDeclaringEntryPoint(DependencyEdge entryPoint) { return MoreElements.asType( entryPoint.dependencyRequest().requestElement().get().getEnclosingElement()); }
private static String moduleSubcomponentsIncludesBuilder( TypeElement moduleSubcomponentsAttribute) { TypeElement subcomponentType = MoreElements.asType(moduleSubcomponentsAttribute.getEnclosingElement()); return String.format( "%s is a @%s.Builder. Did you mean to use %s?", moduleSubcomponentsAttribute.getQualifiedName(), simpleName(getSubcomponentAnnotation(subcomponentType).get()), subcomponentType.getQualifiedName()); }
private ImmutableMap<Element, ValidationReport<TypeElement>> processBuilders( Set<? extends Element> builderElements, ImmutableSet.Builder<Element> rejectedElements) { // Can't use an ImmutableMap.Builder here because a component may have (invalidly) more than one // builder type, and that would make ImmutableMap.Builder throw. Map<Element, ValidationReport<TypeElement>> reports = new HashMap<>(); for (Element element : builderElements) { try { ValidationReport<TypeElement> report = creatorValidator.validate(MoreElements.asType(element)); report.printMessagesTo(messager); reports.put(element.getEnclosingElement(), report); } catch (TypeNotPresentException e) { rejectedElements.add(element); } } return ImmutableMap.copyOf(reports); }
/** * Formats an ExecutableElement as if it were contained within the container, if the container is * present. */ public String format(ExecutableElement method, Optional<DeclaredType> container) { TypeElement type = MoreElements.asType(method.getEnclosingElement()); ExecutableType executableType = MoreTypes.asExecutable(method.asType()); if (container.isPresent()) { executableType = MoreTypes.asExecutable(types.asMemberOf(container.get(), method)); type = MoreElements.asType(container.get().asElement()); } return format(method, executableType, type); }
private CodeBlock getAnnotationInstanceExpression(AnnotationMirror annotation) { return CodeBlock.of( "$T.$L($L)", creatorClass, createMethodName( MoreElements.asType(annotation.getAnnotationType().asElement())), makeParametersCodeBlock( getAnnotationValuesWithDefaults(annotation) .entrySet() .stream() .map(entry -> getValueExpression(entry.getKey().getReturnType(), entry.getValue())) .collect(toList()))); }
@Override public Void visitVariableAsField(VariableElement fieldElement, Void aVoid) { injectBindingRegistry.tryRegisterMembersInjectedType( MoreElements.asType(fieldElement.getEnclosingElement())); return null; }
/** * Calculates an appropriate {@link ClassName} for a generated class that is based on {@code * element}, appending {@code suffix} at the end. * * <p>This will always return a {@linkplain ClassName#topLevelClassName() top level class name}, * even if {@code element}'s enclosing class is a nested type. */ 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); }
@Override public String format(ExecutableElement method) { return MethodSignatureFormatter.this.format( method, MoreTypes.asExecutable(types.asMemberOf(declaredType, method)), MoreElements.asType(method.getEnclosingElement())); } };
private ImmutableMap<Element, ValidationReport<TypeElement>> processSubcomponents( Set<? extends Element> subcomponentElements, Set<? extends Element> subcomponentBuilderElements, ImmutableSet.Builder<Element> rejectedElements) { ImmutableMap.Builder<Element, ValidationReport<TypeElement>> reports = ImmutableMap.builder(); for (Element element : subcomponentElements) { try { ComponentValidationReport report = componentValidator.validate( MoreElements.asType(element), subcomponentElements, subcomponentBuilderElements); report.report().printMessagesTo(messager); reports.put(element, report.report()); } catch (TypeNotPresentException e) { rejectedElements.add(element); } } return reports.build(); }
private void reportConflictingEntryPoints( Collection<ExecutableElement> methods, ValidationReport.Builder<TypeElement> report) { verify( methods.stream().map(ExecutableElement::getEnclosingElement).distinct().count() == methods.size(), "expected each method to be declared on a different type: %s", methods); StringBuilder message = new StringBuilder("conflicting entry point declarations:"); methodSignatureFormatter .typedFormatter(asDeclared(report.getSubject().asType())) .formatIndentedList( message, ImmutableList.sortedCopyOf( comparing( method -> asType(method.getEnclosingElement()).getQualifiedName().toString()), methods), 1); report.addError(message.toString()); }
/** Traverses includes from superclasses and adds them into the builder. */ private static void addIncludesFromSuperclasses( DaggerTypes types, TypeElement element, ImmutableSet.Builder<TypeElement> builder, TypeMirror objectType) { // Also add the superclass to the queue, in case any @Module definitions were on that. TypeMirror superclass = element.getSuperclass(); while (!types.isSameType(objectType, superclass) && superclass.getKind().equals(TypeKind.DECLARED)) { element = MoreElements.asType(types.asElement(superclass)); getModuleAnnotation(element) .ifPresent( moduleMirror -> { builder.addAll(MoreTypes.asTypeElements(getModuleIncludes(moduleMirror))); }); superclass = element.getSuperclass(); } }
@Override protected void checkKeyType( ValidationReport.Builder<ExecutableElement> builder, TypeMirror keyType) { super.checkKeyType(builder, keyType); if (isValidImplicitProvisionKey( getQualifiers(builder.getSubject()).stream().findFirst(), keyType, types) && !injectedConstructors(MoreElements.asType(MoreTypes.asDeclared(keyType).asElement())) .isEmpty()) { builder.addError( "@BindsOptionalOf methods cannot return unqualified types that have an @Inject-" + "annotated constructor because those are always present"); } }
private static InjectionMethod constructorProxy( ClassName proxyEnclosingClass, ExecutableElement constructor, DaggerElements elements) { TypeElement enclosingType = MoreElements.asType(constructor.getEnclosingElement()); InjectionMethod.Builder injectionMethod = InjectionMethod.builder(elements) .name(methodName(constructor)) .returnType(enclosingType.asType()) .enclosingClass(proxyEnclosingClass); injectionMethod .copyTypeParameters(enclosingType) .copyThrows(constructor); CodeBlock arguments = injectionMethod.copyParameters(constructor); injectionMethod .methodBodyBuilder() .addStatement("return new $T($L)", enclosingType, arguments); return injectionMethod.build(); }