| /* |
| * Copyright (C) 2020 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.lint |
| |
| import com.android.tools.lint.client.api.JavaEvaluator |
| import com.android.tools.lint.client.api.UElementHandler |
| import com.android.tools.lint.detector.api.Category |
| import com.android.tools.lint.detector.api.Detector |
| import com.android.tools.lint.detector.api.Implementation |
| import com.android.tools.lint.detector.api.Issue |
| import com.android.tools.lint.detector.api.JavaContext |
| import com.android.tools.lint.detector.api.LintFix |
| import com.android.tools.lint.detector.api.Scope |
| import com.android.tools.lint.detector.api.Severity |
| import com.android.tools.lint.detector.api.SourceCodeScanner |
| import com.android.tools.lint.detector.api.TextFormat |
| import com.android.tools.lint.detector.api.isKotlin |
| import dagger.lint.DaggerKotlinIssueDetector.Companion.ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION |
| import dagger.lint.DaggerKotlinIssueDetector.Companion.ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT |
| import dagger.lint.DaggerKotlinIssueDetector.Companion.ISSUE_MODULE_COMPANION_OBJECTS |
| import dagger.lint.DaggerKotlinIssueDetector.Companion.ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT |
| import java.util.EnumSet |
| import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget |
| import org.jetbrains.kotlin.lexer.KtTokens |
| import org.jetbrains.kotlin.psi.KtAnnotationEntry |
| import org.jetbrains.kotlin.psi.KtObjectDeclaration |
| import org.jetbrains.uast.UClass |
| import org.jetbrains.uast.UElement |
| import org.jetbrains.uast.UField |
| import org.jetbrains.uast.UMethod |
| import org.jetbrains.uast.getUastParentOfType |
| import org.jetbrains.uast.kotlin.KotlinUClass |
| import org.jetbrains.uast.toUElement |
| |
| /** |
| * This is a simple lint check to catch common Dagger+Kotlin usage issues. |
| * |
| * - [ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION] covers using `field:` site targets for member |
| * injections, which are redundant as of Dagger 2.25. |
| * - [ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT] covers using `@JvmStatic` for object |
| * `@Provides`-annotated functions, which are redundant as of Dagger 2.25. @JvmStatic on companion |
| * object functions are redundant as of Dagger 2.26. |
| * - [ISSUE_MODULE_COMPANION_OBJECTS] covers annotating companion objects with `@Module`, as they |
| * are now part of the enclosing module class's API in Dagger 2.26. This will also error if the |
| * enclosing class is _not_ in a `@Module`-annotated class, as this object just should be moved to a |
| * top-level object to avoid confusion. |
| * - [ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT] covers annotating companion objects with |
| * `@Module` when the parent class is _not_ also annotated with `@Module`. While technically legal, |
| * these should be moved up to top-level objects to avoid confusion. |
| */ |
| @Suppress("UnstableApiUsage") // Lots of Lint APIs are marked with @Beta. |
| class DaggerKotlinIssueDetector : Detector(), SourceCodeScanner { |
| |
| companion object { |
| // We use the overloaded constructor that takes a varargs of `Scope` as the last param. |
| // This is to enable on-the-fly IDE checks. We are telling lint to run on both |
| // JAVA and TEST_SOURCES in the `scope` parameter but by providing the `analysisScopes` |
| // params, we're indicating that this check can run on either JAVA or TEST_SOURCES and |
| // doesn't require both of them together. |
| // From discussion on lint-dev https://groups.google.com/d/msg/lint-dev/ULQMzW1ZlP0/1dG4Vj3-AQAJ |
| // This was supposed to be fixed in AS 3.4 but still required as recently as 3.6. |
| private val SCOPES = Implementation( |
| DaggerKotlinIssueDetector::class.java, |
| EnumSet.of(Scope.JAVA_FILE, Scope.TEST_SOURCES), |
| EnumSet.of(Scope.JAVA_FILE), |
| EnumSet.of(Scope.TEST_SOURCES) |
| ) |
| |
| private val ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT: Issue = Issue.create( |
| id = "JvmStaticProvidesInObjectDetector", |
| briefDescription = "@JvmStatic used for @Provides function in an object class", |
| explanation = |
| """ |
| It's redundant to annotate @Provides functions in object classes with @JvmStatic. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 5, |
| severity = Severity.WARNING, |
| implementation = SCOPES |
| ) |
| |
| private val ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION: Issue = Issue.create( |
| id = "FieldSiteTargetOnQualifierAnnotation", |
| briefDescription = "Redundant 'field:' used for Dagger qualifier annotation.", |
| explanation = |
| """ |
| It's redundant to use 'field:' site-targets for qualifier annotations. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 5, |
| severity = Severity.WARNING, |
| implementation = SCOPES |
| ) |
| |
| private val ISSUE_MODULE_COMPANION_OBJECTS: Issue = Issue.create( |
| id = "ModuleCompanionObjects", |
| briefDescription = "Module companion objects should not be annotated with @Module.", |
| explanation = |
| """ |
| Companion objects in @Module-annotated classes are considered part of the API. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 5, |
| severity = Severity.WARNING, |
| implementation = SCOPES |
| ) |
| |
| private val ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT: Issue = Issue.create( |
| id = "ModuleCompanionObjectsNotInModuleParent", |
| briefDescription = "Companion objects should not be annotated with @Module.", |
| explanation = |
| """ |
| Companion objects in @Module-annotated classes are considered part of the API. This |
| companion object is not a companion to an @Module-annotated class though, and should be |
| moved to a top-level object declaration instead otherwise Dagger will ignore companion |
| object. |
| """, |
| category = Category.CORRECTNESS, |
| priority = 5, |
| severity = Severity.WARNING, |
| implementation = SCOPES |
| ) |
| |
| private const val PROVIDES_ANNOTATION = "dagger.Provides" |
| private const val JVM_STATIC_ANNOTATION = "kotlin.jvm.JvmStatic" |
| private const val INJECT_ANNOTATION = "javax.inject.Inject" |
| private const val QUALIFIER_ANNOTATION = "javax.inject.Qualifier" |
| private const val MODULE_ANNOTATION = "dagger.Module" |
| |
| val issues: List<Issue> = listOf( |
| ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT, |
| ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION, |
| ISSUE_MODULE_COMPANION_OBJECTS, |
| ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT |
| ) |
| } |
| |
| override fun getApplicableUastTypes(): List<Class<out UElement>>? { |
| return listOf(UMethod::class.java, UField::class.java, UClass::class.java) |
| } |
| |
| override fun createUastHandler(context: JavaContext): UElementHandler? { |
| if (!isKotlin(context.psiFile)) { |
| // This is only relevant for Kotlin files. |
| return null |
| } |
| return object : UElementHandler() { |
| override fun visitField(node: UField) { |
| if (!context.evaluator.isLateInit(node)) { |
| return |
| } |
| // Can't use hasAnnotation because it doesn't capture all annotations! |
| val injectAnnotation = |
| node.annotations.find { it.qualifiedName == INJECT_ANNOTATION } ?: return |
| // Look for qualifier annotations |
| node.annotations.forEach { annotation -> |
| if (annotation === injectAnnotation) { |
| // Skip the inject annotation |
| return@forEach |
| } |
| // Check if it's a FIELD site target |
| val sourcePsi = annotation.sourcePsi |
| if (sourcePsi is KtAnnotationEntry && |
| sourcePsi.useSiteTarget?.getAnnotationUseSiteTarget() == AnnotationUseSiteTarget.FIELD |
| ) { |
| // Check if this annotation is a qualifier annotation |
| if (annotation.resolve()?.hasAnnotation(QUALIFIER_ANNOTATION) == true) { |
| context.report( |
| ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION, |
| context.getLocation(annotation), |
| ISSUE_FIELD_SITE_TARGET_ON_QUALIFIER_ANNOTATION |
| .getBriefDescription(TextFormat.TEXT), |
| LintFix.create() |
| .name("Remove 'field:'") |
| .replace() |
| .text("field:") |
| .with("") |
| .autoFix() |
| .build() |
| ) |
| } |
| } |
| } |
| } |
| |
| override fun visitMethod(node: UMethod) { |
| if (!node.isConstructor && |
| node.hasAnnotation(PROVIDES_ANNOTATION) && |
| node.hasAnnotation(JVM_STATIC_ANNOTATION) |
| ) { |
| val containingClass = node.containingClass?.toUElement(UClass::class.java) ?: return |
| if (containingClass.isObject()) { |
| val annotation = node.findAnnotation(JVM_STATIC_ANNOTATION)!! |
| context.report( |
| ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT, |
| context.getLocation(annotation), |
| ISSUE_JVM_STATIC_PROVIDES_IN_OBJECT.getBriefDescription(TextFormat.TEXT), |
| LintFix.create() |
| .name("Remove @JvmStatic") |
| .replace() |
| .pattern("(@(kotlin\\.jvm\\.)?JvmStatic)") |
| .with("") |
| .autoFix() |
| .build() |
| ) |
| } |
| } |
| } |
| |
| override fun visitClass(node: UClass) { |
| if (node.hasAnnotation(MODULE_ANNOTATION) && node.isCompanionObject(context.evaluator)) { |
| val parent = node.getUastParentOfType(UClass::class.java, false)!! |
| if (parent.hasAnnotation(MODULE_ANNOTATION)) { |
| context.report( |
| ISSUE_MODULE_COMPANION_OBJECTS, |
| context.getLocation(node as UElement), |
| ISSUE_MODULE_COMPANION_OBJECTS.getBriefDescription(TextFormat.TEXT), |
| LintFix.create() |
| .name("Remove @Module") |
| .replace() |
| .pattern("(@(dagger\\.)?Module)") |
| .with("") |
| .autoFix() |
| .build() |
| |
| ) |
| } else { |
| context.report( |
| ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT, |
| context.getLocation(node as UElement), |
| ISSUE_MODULE_COMPANION_OBJECTS_NOT_IN_MODULE_PARENT |
| .getBriefDescription(TextFormat.TEXT) |
| ) |
| } |
| } |
| } |
| } |
| } |
| |
| /** @return whether or not the [this] is a Kotlin `companion object` type. */ |
| private fun UClass.isCompanionObject(evaluator: JavaEvaluator): Boolean { |
| return isObject() && evaluator.hasModifier(this, KtTokens.COMPANION_KEYWORD) |
| } |
| |
| /** @return whether or not the [this] is a Kotlin `object` type. */ |
| private fun UClass.isObject(): Boolean { |
| return this is KotlinUClass && ktClass is KtObjectDeclaration |
| } |
| } |
