| /* |
| * Copyright (C) 2014 The Dagger Authors. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package dagger.internal.codegen.validation; |
| |
| import static com.google.auto.common.AnnotationMirrors.getAnnotatedAnnotations; |
| import static com.google.auto.common.MoreElements.isAnnotationPresent; |
| import static com.google.auto.common.MoreTypes.asTypeElement; |
| import static com.google.auto.common.Visibility.PRIVATE; |
| import static com.google.auto.common.Visibility.PUBLIC; |
| import static com.google.auto.common.Visibility.effectiveVisibilityOfElement; |
| import static com.google.common.base.Preconditions.checkArgument; |
| import static com.google.common.collect.Iterables.getOnlyElement; |
| import static dagger.internal.codegen.base.ComponentAnnotation.componentAnnotation; |
| import static dagger.internal.codegen.base.ComponentAnnotation.isComponentAnnotation; |
| import static dagger.internal.codegen.base.ComponentAnnotation.subcomponentAnnotation; |
| import static dagger.internal.codegen.base.ModuleAnnotation.isModuleAnnotation; |
| import static dagger.internal.codegen.base.ModuleAnnotation.moduleAnnotation; |
| import static dagger.internal.codegen.base.MoreAnnotationMirrors.simpleName; |
| import static dagger.internal.codegen.base.MoreAnnotationValues.asType; |
| import static dagger.internal.codegen.base.Util.reentrantComputeIfAbsent; |
| import static dagger.internal.codegen.binding.ComponentCreatorAnnotation.getCreatorAnnotations; |
| import static dagger.internal.codegen.binding.ConfigurationAnnotations.getSubcomponentCreator; |
| import static dagger.internal.codegen.extension.DaggerStreams.toImmutableSet; |
| import static dagger.internal.codegen.langmodel.DaggerElements.getAnnotationMirror; |
| import static dagger.internal.codegen.langmodel.DaggerElements.isAnyAnnotationPresent; |
| import static java.util.stream.Collectors.joining; |
| import static javax.lang.model.element.Modifier.ABSTRACT; |
| import static javax.lang.model.element.Modifier.STATIC; |
| import static javax.lang.model.util.ElementFilter.methodsIn; |
| |
| import com.google.auto.common.MoreElements; |
| import com.google.auto.common.MoreTypes; |
| import com.google.auto.common.Visibility; |
| import com.google.common.base.Joiner; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableListMultimap; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.ListMultimap; |
| import com.google.common.collect.MultimapBuilder; |
| import com.google.common.collect.Multimaps; |
| import com.google.common.collect.Sets; |
| import com.google.errorprone.annotations.FormatMethod; |
| import dagger.Module; |
| import dagger.Subcomponent; |
| import dagger.internal.codegen.base.ModuleAnnotation; |
| import dagger.internal.codegen.binding.BindingGraphFactory; |
| import dagger.internal.codegen.binding.ComponentCreatorAnnotation; |
| import dagger.internal.codegen.binding.ComponentDescriptorFactory; |
| import dagger.internal.codegen.binding.MethodSignatureFormatter; |
| import dagger.internal.codegen.binding.ModuleKind; |
| import dagger.internal.codegen.kotlin.KotlinMetadataUtil; |
| import dagger.internal.codegen.langmodel.DaggerElements; |
| import dagger.internal.codegen.langmodel.DaggerTypes; |
| import dagger.model.BindingGraph; |
| import dagger.producers.ProducerModule; |
| import dagger.producers.ProductionSubcomponent; |
| import java.lang.annotation.Annotation; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Optional; |
| import java.util.Set; |
| import javax.inject.Inject; |
| import javax.inject.Scope; |
| import javax.inject.Singleton; |
| import javax.lang.model.element.AnnotationMirror; |
| import javax.lang.model.element.AnnotationValue; |
| import javax.lang.model.element.ElementKind; |
| import javax.lang.model.element.ExecutableElement; |
| import javax.lang.model.element.Name; |
| import javax.lang.model.element.TypeElement; |
| import javax.lang.model.type.DeclaredType; |
| import javax.lang.model.type.TypeMirror; |
| import javax.lang.model.util.SimpleAnnotationValueVisitor8; |
| import javax.lang.model.util.SimpleTypeVisitor8; |
| |
| /** A {@linkplain ValidationReport validator} for {@link Module}s or {@link ProducerModule}s. */ |
| @Singleton |
| public final class ModuleValidator { |
| private static final ImmutableSet<Class<? extends Annotation>> SUBCOMPONENT_TYPES = |
| ImmutableSet.of(Subcomponent.class, ProductionSubcomponent.class); |
| private static final ImmutableSet<Class<? extends Annotation>> SUBCOMPONENT_CREATOR_TYPES = |
| ImmutableSet.of( |
| Subcomponent.Builder.class, |
| Subcomponent.Factory.class, |
| ProductionSubcomponent.Builder.class, |
| ProductionSubcomponent.Factory.class); |
| private static final Optional<Class<?>> ANDROID_PROCESSOR; |
| private static final String CONTRIBUTES_ANDROID_INJECTOR_NAME = |
| "dagger.android.ContributesAndroidInjector"; |
| private static final String ANDROID_PROCESSOR_NAME = "dagger.android.processor.AndroidProcessor"; |
| |
| static { |
| Class<?> clazz; |
| try { |
| clazz = Class.forName(ANDROID_PROCESSOR_NAME, false, ModuleValidator.class.getClassLoader()); |
| } catch (ClassNotFoundException ignored) { |
| clazz = null; |
| } |
| ANDROID_PROCESSOR = Optional.ofNullable(clazz); |
| } |
| |
| private final DaggerTypes types; |
| private final DaggerElements elements; |
| private final AnyBindingMethodValidator anyBindingMethodValidator; |
| private final MethodSignatureFormatter methodSignatureFormatter; |
| private final ComponentDescriptorFactory componentDescriptorFactory; |
| private final BindingGraphFactory bindingGraphFactory; |
| private final BindingGraphValidator bindingGraphValidator; |
| private final KotlinMetadataUtil metadataUtil; |
| private final Map<TypeElement, ValidationReport<TypeElement>> cache = new HashMap<>(); |
| private final Set<TypeElement> knownModules = new HashSet<>(); |
| |
| @Inject |
| ModuleValidator( |
| DaggerTypes types, |
| DaggerElements elements, |
| AnyBindingMethodValidator anyBindingMethodValidator, |
| MethodSignatureFormatter methodSignatureFormatter, |
| ComponentDescriptorFactory componentDescriptorFactory, |
| BindingGraphFactory bindingGraphFactory, |
| BindingGraphValidator bindingGraphValidator, |
| KotlinMetadataUtil metadataUtil) { |
| this.types = types; |
| this.elements = elements; |
| this.anyBindingMethodValidator = anyBindingMethodValidator; |
| this.methodSignatureFormatter = methodSignatureFormatter; |
| this.componentDescriptorFactory = componentDescriptorFactory; |
| this.bindingGraphFactory = bindingGraphFactory; |
| this.bindingGraphValidator = bindingGraphValidator; |
| this.metadataUtil = metadataUtil; |
| } |
| |
| /** |
| * Adds {@code modules} to the set of module types that will be validated during this compilation |
| * step. If a component or module includes a module that is not in this set, that included module |
| * is assumed to be valid because it was processed in a previous compilation step. If it were |
| * invalid, that previous compilation step would have failed and blocked this one. |
| * |
| * <p>This logic depends on this method being called before {@linkplain #validate(TypeElement) |
| * validating} any module or {@linkplain #validateReferencedModules(TypeElement, AnnotationMirror, |
| * ImmutableSet, Set) component}. |
| */ |
| public void addKnownModules(Collection<TypeElement> modules) { |
| knownModules.addAll(modules); |
| } |
| |
| /** Returns a validation report for a module type. */ |
| public ValidationReport<TypeElement> validate(TypeElement module) { |
| return validate(module, new HashSet<>()); |
| } |
| |
| private ValidationReport<TypeElement> validate( |
| TypeElement module, Set<TypeElement> visitedModules) { |
| if (visitedModules.add(module)) { |
| return reentrantComputeIfAbsent(cache, module, m -> validateUncached(module, visitedModules)); |
| } |
| return ValidationReport.about(module).build(); |
| } |
| |
| private ValidationReport<TypeElement> validateUncached( |
| TypeElement module, Set<TypeElement> visitedModules) { |
| ValidationReport.Builder<TypeElement> builder = ValidationReport.about(module); |
| ModuleKind moduleKind = ModuleKind.forAnnotatedElement(module).get(); |
| TypeElement contributesAndroidInjectorElement = |
| elements.getTypeElement(CONTRIBUTES_ANDROID_INJECTOR_NAME); |
| TypeMirror contributesAndroidInjector = |
| contributesAndroidInjectorElement != null |
| ? contributesAndroidInjectorElement.asType() |
| : null; |
| List<ExecutableElement> moduleMethods = methodsIn(module.getEnclosedElements()); |
| List<ExecutableElement> bindingMethods = new ArrayList<>(); |
| for (ExecutableElement moduleMethod : moduleMethods) { |
| if (anyBindingMethodValidator.isBindingMethod(moduleMethod)) { |
| builder.addSubreport(anyBindingMethodValidator.validate(moduleMethod)); |
| bindingMethods.add(moduleMethod); |
| } |
| |
| for (AnnotationMirror annotation : moduleMethod.getAnnotationMirrors()) { |
| if (!ANDROID_PROCESSOR.isPresent() |
| && MoreTypes.equivalence() |
| .equivalent(contributesAndroidInjector, annotation.getAnnotationType())) { |
| builder.addSubreport( |
| ValidationReport.about(moduleMethod) |
| .addError( |
| String.format( |
| "@%s was used, but %s was not found on the processor path", |
| CONTRIBUTES_ANDROID_INJECTOR_NAME, ANDROID_PROCESSOR_NAME)) |
| .build()); |
| break; |
| } |
| } |
| } |
| |
| if (bindingMethods.stream() |
| .map(ModuleMethodKind::ofMethod) |
| .collect(toImmutableSet()) |
| .containsAll( |
| EnumSet.of(ModuleMethodKind.ABSTRACT_DECLARATION, ModuleMethodKind.INSTANCE_BINDING))) { |
| builder.addError( |
| String.format( |
| "A @%s may not contain both non-static and abstract binding methods", |
| moduleKind.annotation().getSimpleName())); |
| } |
| |
| validateModuleVisibility(module, moduleKind, builder); |
| |
| ImmutableListMultimap<Name, ExecutableElement> bindingMethodsByName = |
| Multimaps.index(bindingMethods, ExecutableElement::getSimpleName); |
| |
| validateMethodsWithSameName(builder, bindingMethodsByName); |
| if (module.getKind() != ElementKind.INTERFACE) { |
| validateBindingMethodOverrides( |
| module, |
| builder, |
| Multimaps.index(moduleMethods, ExecutableElement::getSimpleName), |
| bindingMethodsByName); |
| } |
| validateModifiers(module, builder); |
| validateReferencedModules(module, moduleKind, visitedModules, builder); |
| validateReferencedSubcomponents(module, moduleKind, builder); |
| validateNoScopeAnnotationsOnModuleElement(module, moduleKind, builder); |
| validateSelfCycles(module, builder); |
| if (metadataUtil.hasEnclosedCompanionObject(module)) { |
| validateCompanionModule(module, builder); |
| } |
| |
| if (builder.build().isClean() |
| && bindingGraphValidator.shouldDoFullBindingGraphValidation(module)) { |
| validateModuleBindings(module, builder); |
| } |
| |
| return builder.build(); |
| } |
| |
| private void validateReferencedSubcomponents( |
| final TypeElement subject, |
| ModuleKind moduleKind, |
| final ValidationReport.Builder<TypeElement> builder) { |
| // TODO(ronshapiro): use validateTypesAreDeclared when it is checked in |
| ModuleAnnotation moduleAnnotation = moduleAnnotation(moduleKind.getModuleAnnotation(subject)); |
| for (AnnotationValue subcomponentAttribute : |
| moduleAnnotation.subcomponentsAsAnnotationValues()) { |
| asType(subcomponentAttribute) |
| .accept( |
| new SimpleTypeVisitor8<Void, Void>() { |
| @Override |
| protected Void defaultAction(TypeMirror e, Void aVoid) { |
| builder.addError( |
| e + " is not a valid subcomponent type", |
| subject, |
| moduleAnnotation.annotation(), |
| subcomponentAttribute); |
| return null; |
| } |
| |
| @Override |
| public Void visitDeclared(DeclaredType declaredType, Void aVoid) { |
| TypeElement attributeType = asTypeElement(declaredType); |
| if (isAnyAnnotationPresent(attributeType, SUBCOMPONENT_TYPES)) { |
| validateSubcomponentHasBuilder( |
| attributeType, moduleAnnotation.annotation(), builder); |
| } else { |
| builder.addError( |
| isAnyAnnotationPresent(attributeType, SUBCOMPONENT_CREATOR_TYPES) |
| ? moduleSubcomponentsIncludesCreator(attributeType) |
| : moduleSubcomponentsIncludesNonSubcomponent(attributeType), |
| subject, |
| moduleAnnotation.annotation(), |
| subcomponentAttribute); |
| } |
| |
| return null; |
| } |
| }, |
| null); |
| } |
| } |
| |
| private static String moduleSubcomponentsIncludesNonSubcomponent(TypeElement notSubcomponent) { |
| return notSubcomponent.getQualifiedName() |
| + " is not a @Subcomponent or @ProductionSubcomponent"; |
| } |
| |
| private static String moduleSubcomponentsIncludesCreator( |
| TypeElement moduleSubcomponentsAttribute) { |
| TypeElement subcomponentType = |
| MoreElements.asType(moduleSubcomponentsAttribute.getEnclosingElement()); |
| ComponentCreatorAnnotation creatorAnnotation = |
| getOnlyElement(getCreatorAnnotations(moduleSubcomponentsAttribute)); |
| return String.format( |
| "%s is a @%s.%s. Did you mean to use %s?", |
| moduleSubcomponentsAttribute.getQualifiedName(), |
| subcomponentAnnotation(subcomponentType).get().simpleName(), |
| creatorAnnotation.creatorKind().typeName(), |
| subcomponentType.getQualifiedName()); |
| } |
| |
| private static void validateSubcomponentHasBuilder( |
| TypeElement subcomponentAttribute, |
| AnnotationMirror moduleAnnotation, |
| ValidationReport.Builder<TypeElement> builder) { |
| if (getSubcomponentCreator(subcomponentAttribute).isPresent()) { |
| return; |
| } |
| builder.addError( |
| moduleSubcomponentsDoesntHaveCreator(subcomponentAttribute, moduleAnnotation), |
| builder.getSubject(), |
| moduleAnnotation); |
| } |
| |
| private static String moduleSubcomponentsDoesntHaveCreator( |
| TypeElement subcomponent, AnnotationMirror moduleAnnotation) { |
| return String.format( |
| "%1$s doesn't have a @%2$s.Builder or @%2$s.Factory, which is required when used with " |
| + "@%3$s.subcomponents", |
| subcomponent.getQualifiedName(), |
| subcomponentAnnotation(subcomponent).get().simpleName(), |
| simpleName(moduleAnnotation)); |
| } |
| |
| enum ModuleMethodKind { |
| ABSTRACT_DECLARATION, |
| INSTANCE_BINDING, |
| STATIC_BINDING, |
| ; |
| |
| static ModuleMethodKind ofMethod(ExecutableElement moduleMethod) { |
| if (moduleMethod.getModifiers().contains(STATIC)) { |
| return STATIC_BINDING; |
| } else if (moduleMethod.getModifiers().contains(ABSTRACT)) { |
| return ABSTRACT_DECLARATION; |
| } else { |
| return INSTANCE_BINDING; |
| } |
| } |
| } |
| |
| private void validateModifiers( |
| TypeElement subject, ValidationReport.Builder<TypeElement> builder) { |
| // This coupled with the check for abstract modules in ComponentValidator guarantees that |
| // only modules without type parameters are referenced from @Component(modules={...}). |
| if (!subject.getTypeParameters().isEmpty() && !subject.getModifiers().contains(ABSTRACT)) { |
| builder.addError("Modules with type parameters must be abstract", subject); |
| } |
| } |
| |
| private void validateMethodsWithSameName( |
| ValidationReport.Builder<TypeElement> builder, |
| ListMultimap<Name, ExecutableElement> bindingMethodsByName) { |
| for (Entry<Name, Collection<ExecutableElement>> entry : |
| bindingMethodsByName.asMap().entrySet()) { |
| if (entry.getValue().size() > 1) { |
| for (ExecutableElement offendingMethod : entry.getValue()) { |
| builder.addError( |
| String.format( |
| "Cannot have more than one binding method with the same name in a single module"), |
| offendingMethod); |
| } |
| } |
| } |
| } |
| |
| private void validateReferencedModules( |
| TypeElement subject, |
| ModuleKind moduleKind, |
| Set<TypeElement> visitedModules, |
| ValidationReport.Builder<TypeElement> builder) { |
| // Validate that all the modules we include are valid for inclusion. |
| AnnotationMirror mirror = moduleKind.getModuleAnnotation(subject); |
| builder.addSubreport( |
| validateReferencedModules( |
| subject, mirror, moduleKind.legalIncludedModuleKinds(), visitedModules)); |
| } |
| |
| /** |
| * Validates modules included in a given module or installed in a given component. |
| * |
| * <p>Checks that the referenced modules are non-generic types annotated with {@code @Module} or |
| * {@code @ProducerModule}. |
| * |
| * <p>If the referenced module is in the {@linkplain #addKnownModules(Collection) known modules |
| * set} and has errors, reports an error at that module's inclusion. |
| * |
| * @param annotatedType the annotated module or component |
| * @param annotation the annotation specifying the referenced modules ({@code @Component}, |
| * {@code @ProductionComponent}, {@code @Subcomponent}, {@code @ProductionSubcomponent}, |
| * {@code @Module}, or {@code @ProducerModule}) |
| * @param validModuleKinds the module kinds that the annotated type is permitted to include |
| */ |
| ValidationReport<TypeElement> validateReferencedModules( |
| TypeElement annotatedType, |
| AnnotationMirror annotation, |
| ImmutableSet<ModuleKind> validModuleKinds, |
| Set<TypeElement> visitedModules) { |
| ValidationReport.Builder<TypeElement> subreport = ValidationReport.about(annotatedType); |
| ImmutableSet<? extends Class<? extends Annotation>> validModuleAnnotations = |
| validModuleKinds.stream().map(ModuleKind::annotation).collect(toImmutableSet()); |
| |
| for (AnnotationValue includedModule : getModules(annotation)) { |
| asType(includedModule) |
| .accept( |
| new SimpleTypeVisitor8<Void, Void>() { |
| @Override |
| protected Void defaultAction(TypeMirror mirror, Void p) { |
| reportError("%s is not a valid module type.", mirror); |
| return null; |
| } |
| |
| @Override |
| public Void visitDeclared(DeclaredType t, Void p) { |
| TypeElement module = MoreElements.asType(t.asElement()); |
| if (!t.getTypeArguments().isEmpty()) { |
| reportError( |
| "%s is listed as a module, but has type parameters", |
| module.getQualifiedName()); |
| } |
| if (!isAnyAnnotationPresent(module, validModuleAnnotations)) { |
| reportError( |
| "%s is listed as a module, but is not annotated with %s", |
| module.getQualifiedName(), |
| (validModuleAnnotations.size() > 1 ? "one of " : "") |
| + validModuleAnnotations.stream() |
| .map(otherClass -> "@" + otherClass.getSimpleName()) |
| .collect(joining(", "))); |
| } else if (knownModules.contains(module) |
| && !validate(module, visitedModules).isClean()) { |
| reportError("%s has errors", module.getQualifiedName()); |
| } |
| if (metadataUtil.isCompanionObjectClass(module)) { |
| reportError( |
| "%s is listed as a module, but it is a companion object class. " |
| + "Add @Module to the enclosing class and reference that instead.", |
| module.getQualifiedName()); |
| } |
| return null; |
| } |
| |
| @FormatMethod |
| private void reportError(String format, Object... args) { |
| subreport.addError( |
| String.format(format, args), annotatedType, annotation, includedModule); |
| } |
| }, |
| null); |
| } |
| return subreport.build(); |
| } |
| |
| private static ImmutableList<AnnotationValue> getModules(AnnotationMirror annotation) { |
| if (isModuleAnnotation(annotation)) { |
| return moduleAnnotation(annotation).includesAsAnnotationValues(); |
| } |
| if (isComponentAnnotation(annotation)) { |
| return componentAnnotation(annotation).moduleValues(); |
| } |
| throw new IllegalArgumentException(String.format("unsupported annotation: %s", annotation)); |
| } |
| |
| private void validateBindingMethodOverrides( |
| TypeElement subject, |
| ValidationReport.Builder<TypeElement> builder, |
| ImmutableListMultimap<Name, ExecutableElement> moduleMethodsByName, |
| ImmutableListMultimap<Name, ExecutableElement> bindingMethodsByName) { |
| // For every binding method, confirm it overrides nothing *and* nothing overrides it. |
| // Consider the following hierarchy: |
| // class Parent { |
| // @Provides Foo a() {} |
| // @Provides Foo b() {} |
| // Foo c() {} |
| // } |
| // class Child extends Parent { |
| // @Provides Foo a() {} |
| // Foo b() {} |
| // @Provides Foo c() {} |
| // } |
| // In each of those cases, we want to fail. "a" is clear, "b" because Child is overriding |
| // a binding method in Parent, and "c" because Child is defining a binding method that overrides |
| // Parent. |
| TypeElement currentClass = subject; |
| TypeMirror objectType = elements.getTypeElement(Object.class).asType(); |
| // We keep track of methods that failed so we don't spam with multiple failures. |
| Set<ExecutableElement> failedMethods = Sets.newHashSet(); |
| ListMultimap<Name, ExecutableElement> allMethodsByName = |
| MultimapBuilder.hashKeys().arrayListValues().build(moduleMethodsByName); |
| |
| while (!types.isSameType(currentClass.getSuperclass(), objectType)) { |
| currentClass = MoreElements.asType(types.asElement(currentClass.getSuperclass())); |
| List<ExecutableElement> superclassMethods = methodsIn(currentClass.getEnclosedElements()); |
| for (ExecutableElement superclassMethod : superclassMethods) { |
| Name name = superclassMethod.getSimpleName(); |
| // For each method in the superclass, confirm our binding methods don't override it |
| for (ExecutableElement bindingMethod : bindingMethodsByName.get(name)) { |
| if (failedMethods.add(bindingMethod) |
| && elements.overrides(bindingMethod, superclassMethod, subject)) { |
| builder.addError( |
| String.format( |
| "Binding methods may not override another method. Overrides: %s", |
| methodSignatureFormatter.format(superclassMethod)), |
| bindingMethod); |
| } |
| } |
| // For each binding method in superclass, confirm our methods don't override it. |
| if (anyBindingMethodValidator.isBindingMethod(superclassMethod)) { |
| for (ExecutableElement method : allMethodsByName.get(name)) { |
| if (failedMethods.add(method) |
| && elements.overrides(method, superclassMethod, subject)) { |
| builder.addError( |
| String.format( |
| "Binding methods may not be overridden in modules. Overrides: %s", |
| methodSignatureFormatter.format(superclassMethod)), |
| method); |
| } |
| } |
| } |
| allMethodsByName.put(superclassMethod.getSimpleName(), superclassMethod); |
| } |
| } |
| } |
| |
| private void validateModuleVisibility( |
| final TypeElement moduleElement, |
| ModuleKind moduleKind, |
| final ValidationReport.Builder<?> reportBuilder) { |
| ModuleAnnotation moduleAnnotation = |
| moduleAnnotation(getAnnotationMirror(moduleElement, moduleKind.annotation()).get()); |
| Visibility moduleVisibility = Visibility.ofElement(moduleElement); |
| Visibility moduleEffectiveVisibility = effectiveVisibilityOfElement(moduleElement); |
| if (moduleVisibility.equals(PRIVATE)) { |
| reportBuilder.addError("Modules cannot be private.", moduleElement); |
| } else if (moduleEffectiveVisibility.equals(PRIVATE)) { |
| reportBuilder.addError("Modules cannot be enclosed in private types.", moduleElement); |
| } |
| |
| switch (moduleElement.getNestingKind()) { |
| case ANONYMOUS: |
| throw new IllegalStateException("Can't apply @Module to an anonymous class"); |
| case LOCAL: |
| throw new IllegalStateException("Local classes shouldn't show up in the processor"); |
| case MEMBER: |
| case TOP_LEVEL: |
| if (moduleEffectiveVisibility.equals(PUBLIC)) { |
| ImmutableSet<TypeElement> invalidVisibilityIncludes = |
| getModuleIncludesWithInvalidVisibility(moduleAnnotation); |
| if (!invalidVisibilityIncludes.isEmpty()) { |
| reportBuilder.addError( |
| String.format( |
| "This module is public, but it includes non-public (or effectively non-public) " |
| + "modules (%s) that have non-static, non-abstract binding methods. Either " |
| + "reduce the visibility of this module, make the included modules " |
| + "public, or make all of the binding methods on the included modules " |
| + "abstract or static.", |
| formatListForErrorMessage(invalidVisibilityIncludes.asList())), |
| moduleElement); |
| } |
| } |
| } |
| } |
| |
| private ImmutableSet<TypeElement> getModuleIncludesWithInvalidVisibility( |
| ModuleAnnotation moduleAnnotation) { |
| return moduleAnnotation.includes().stream() |
| .filter(include -> !effectiveVisibilityOfElement(include).equals(PUBLIC)) |
| .filter(this::requiresModuleInstance) |
| .collect(toImmutableSet()); |
| } |
| |
| /** |
| * Returns {@code true} if a module instance is needed for any of the binding methods on the given |
| * {@code module}. This is the case when the module has any binding methods that are neither |
| * {@code abstract} nor {@code static}. Alternatively, if the module is a Kotlin Object then the |
| * binding methods are considered {@code static}, requiring no module instance. |
| */ |
| private boolean requiresModuleInstance(TypeElement module) { |
| // Note elements.getAllMembers(module) rather than module.getEnclosedElements() here: we need to |
| // include binding methods declared in supertypes because unlike most other validations being |
| // done in this class, which assume that supertype binding methods will be validated in a |
| // separate call to the validator since the supertype itself must be a @Module, we need to look |
| // at all the binding methods in the module's type hierarchy here. |
| boolean isKotlinObject = |
| metadataUtil.isObjectClass(module) || metadataUtil.isCompanionObjectClass(module); |
| if (isKotlinObject) { |
| return false; |
| } |
| return methodsIn(elements.getAllMembers(module)).stream() |
| .filter(anyBindingMethodValidator::isBindingMethod) |
| .map(ExecutableElement::getModifiers) |
| .anyMatch(modifiers -> !modifiers.contains(ABSTRACT) && !modifiers.contains(STATIC)); |
| } |
| |
| private void validateNoScopeAnnotationsOnModuleElement( |
| TypeElement module, ModuleKind moduleKind, ValidationReport.Builder<TypeElement> report) { |
| for (AnnotationMirror scope : getAnnotatedAnnotations(module, Scope.class)) { |
| report.addError( |
| String.format( |
| "@%ss cannot be scoped. Did you mean to scope a method instead?", |
| moduleKind.annotation().getSimpleName()), |
| module, |
| scope); |
| } |
| } |
| |
| private void validateSelfCycles( |
| TypeElement module, ValidationReport.Builder<TypeElement> builder) { |
| ModuleAnnotation moduleAnnotation = moduleAnnotation(module).get(); |
| moduleAnnotation |
| .includesAsAnnotationValues() |
| .forEach( |
| value -> |
| value.accept( |
| new SimpleAnnotationValueVisitor8<Void, Void>() { |
| @Override |
| public Void visitType(TypeMirror includedModule, Void aVoid) { |
| if (MoreTypes.equivalence().equivalent(module.asType(), includedModule)) { |
| String moduleKind = moduleAnnotation.annotationName(); |
| builder.addError( |
| String.format("@%s cannot include themselves.", moduleKind), |
| module, |
| moduleAnnotation.annotation(), |
| value); |
| } |
| return null; |
| } |
| }, |
| null)); |
| } |
| |
| private void validateCompanionModule( |
| TypeElement module, ValidationReport.Builder<TypeElement> builder) { |
| checkArgument(metadataUtil.hasEnclosedCompanionObject(module)); |
| TypeElement companionModule = metadataUtil.getEnclosedCompanionObject(module); |
| List<ExecutableElement> companionModuleMethods = |
| methodsIn(companionModule.getEnclosedElements()); |
| List<ExecutableElement> companionBindingMethods = new ArrayList<>(); |
| for (ExecutableElement companionModuleMethod : companionModuleMethods) { |
| if (anyBindingMethodValidator.isBindingMethod(companionModuleMethod)) { |
| builder.addSubreport(anyBindingMethodValidator.validate(companionModuleMethod)); |
| companionBindingMethods.add(companionModuleMethod); |
| } |
| |
| // On normal modules only overriding other binding methods is disallowed, but for companion |
| // objects we are prohibiting any override. For this can rely on checking the @Override |
| // annotation since the Kotlin compiler will always produce them for overriding methods. |
| if (isAnnotationPresent(companionModuleMethod, Override.class)) { |
| builder.addError( |
| "Binding method in companion object may not override another method.", |
| companionModuleMethod); |
| } |
| |
| // TODO(danysantiago): Be strict about the usage of @JvmStatic, i.e. tell user to remove it. |
| } |
| |
| ImmutableListMultimap<Name, ExecutableElement> bindingMethodsByName = |
| Multimaps.index(companionBindingMethods, ExecutableElement::getSimpleName); |
| validateMethodsWithSameName(builder, bindingMethodsByName); |
| |
| // If there are provision methods, then check the visibility. Companion objects are composed by |
| // an inner class and a static field, it is not enough to check the visibility on the type |
| // element or the field, therefore we check the metadata. |
| if (!companionBindingMethods.isEmpty() && metadataUtil.isVisibilityPrivate(companionModule)) { |
| builder.addError( |
| "A Companion Module with binding methods cannot be private.", companionModule); |
| } |
| } |
| |
| private void validateModuleBindings( |
| TypeElement module, ValidationReport.Builder<TypeElement> report) { |
| BindingGraph bindingGraph = |
| bindingGraphFactory.create( |
| componentDescriptorFactory.moduleComponentDescriptor(module), true) |
| .topLevelBindingGraph(); |
| if (!bindingGraphValidator.isValid(bindingGraph)) { |
| // Since the validator uses a DiagnosticReporter to report errors, the ValdiationReport won't |
| // have any Items for them. We have to tell the ValidationReport that some errors were |
| // reported for the subject. |
| report.markDirty(); |
| } |
| } |
| |
| private static String formatListForErrorMessage(List<?> things) { |
| switch (things.size()) { |
| case 0: |
| return ""; |
| case 1: |
| return things.get(0).toString(); |
| default: |
| StringBuilder output = new StringBuilder(); |
| Joiner.on(", ").appendTo(output, things.subList(0, things.size() - 1)); |
| output.append(" and ").append(things.get(things.size() - 1)); |
| return output.toString(); |
| } |
| } |
| } |
