Merge pull request #158 from jreehuis/feature/lint_checks

Feature: Lint Checks

Author: StefMa

build.gradle

@@ -7,7 +7,7 @@ buildscript {
         google()
     }
     dependencies {
-        classpath "com.android.tools.build:gradle:3.1.3"
+        classpath "com.android.tools.build:gradle:3.1.3" // if you update this, also update the lintVersion below
         classpath "com.vanniktech:gradle-android-junit-jacoco-plugin:0.10.0"
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
@@ -45,4 +45,9 @@ ext {
     assertjVersion = '2.8.0'
     supportTestVersion = '1.0.1'
     espressoVersion = '3.0.1'
+
+    // According to https://github.com/googlesamples/android-custom-lint-rules/tree/master/android-studio-3
+    // the lint version should match to the used Android Gradle Plugin by the formula "AGP Version X.Y.Z + 23.0.0"
+    // E.g. "AGP Version 3.1.3 + 23.0.0 = Lint Version 26.1.3"
+    lintVersion = '26.1.3'
 }

settings.gradle

@@ -6,6 +6,7 @@ include(
         ":thirtyinch-rx2",
         ":thirtyinch-test",
         ":thirtyinch-kotlin",
+        ":thirtyinch-lint",
         ":sample",
         ":plugin-test"
-)
+)

thirtyinch-lint/.gitignore

@@ -0,0 +1,7 @@
+.idea
+build/
+.gradle
+gradle
+gradlew
+gradlew.bat
+.idea/workspace.xml

thirtyinch-lint/build.gradle

@@ -0,0 +1,48 @@
+plugins {
+    id "org.jetbrains.kotlin.jvm"
+    id "jacoco"
+}
+
+repositories {
+    jcenter()
+}
+
+configurations {
+    lintChecks
+}
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+
+    compileOnly "com.android.tools.lint:lint-api:$lintVersion"
+    compileOnly "com.android.tools.lint:lint-checks:$lintVersion"
+
+    testImplementation 'junit:junit:4.12'
+    testImplementation "org.assertj:assertj-core:$assertjVersion"
+
+    testImplementation "com.android.tools.lint:lint:$lintVersion"
+    testImplementation "com.android.tools.lint:lint-tests:$lintVersion"
+
+    lintChecks files(jar)
+}
+
+jar {
+    manifest {
+        attributes("Manifest-Version": 1.0)
+        attributes("Lint-Registry": "net.grandcentrix.thirtyinch.lint.TiLintRegistry")
+        // The TI checks are build with the new 3.0 APIs (including UAST) so we should also register the v2 lint registry.
+        attributes("Lint-Registry-v2": "net.grandcentrix.thirtyinch.lint.TiLintRegistry")
+    }
+}
+
+compileKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+compileTestKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}

thirtyinch-lint/src/main/kotlin/net/grandcentrix/thirtyinch/lint/TiIssue.kt

@@ -0,0 +1,41 @@
+package net.grandcentrix.thirtyinch.lint
+
+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.Scope
+import com.android.tools.lint.detector.api.Severity
+
+private val CATEGORY_TI = Category.create("ThirtyInch", 90)
+
+sealed class TiIssue(
+        val id: String,
+        val briefDescription: String,
+        val category: Category,
+        val priority: Int,
+        val severity: Severity
+) {
+
+    object MissingView : TiIssue(
+            id = "MissingTiViewImplementation",
+            briefDescription = "TiView Implementation missing in class",
+            category = CATEGORY_TI,
+            priority = 8,
+            severity = Severity.ERROR
+    )
+
+    fun asLintIssue(detectorCls: Class<out Detector>, description: String = briefDescription): Issue =
+            Issue.create(
+                    id,
+                    briefDescription,
+                    description,
+                    category,
+                    priority,
+                    severity,
+                    Implementation(
+                            detectorCls,
+                            Scope.JAVA_FILE_SCOPE
+                    )
+            )
+}

thirtyinch-lint/src/main/kotlin/net/grandcentrix/thirtyinch/lint/TiLintRegistry.kt

@@ -0,0 +1,20 @@
+package net.grandcentrix.thirtyinch.lint
+
+import com.android.tools.lint.client.api.IssueRegistry
+import com.android.tools.lint.detector.api.Issue
+import net.grandcentrix.thirtyinch.lint.detector.MissingViewInCompositeDetector
+import net.grandcentrix.thirtyinch.lint.detector.MissingViewInThirtyInchDetector
+
+class TiLintRegistry : IssueRegistry() {
+    override val issues: List<Issue>
+        get() = listOf(
+                MissingViewInThirtyInchDetector.ISSUE.apply {
+                    setEnabledByDefault(true)
+                },
+                MissingViewInCompositeDetector.ISSUE.apply {
+                    setEnabledByDefault(true)
+                }
+        )
+
+    override val api: Int = com.android.tools.lint.detector.api.CURRENT_API
+}

thirtyinch-lint/src/main/kotlin/net/grandcentrix/thirtyinch/lint/detector/BaseMissingViewDetector.kt

@@ -0,0 +1,78 @@
+package net.grandcentrix.thirtyinch.lint.detector
+
+import com.android.tools.lint.detector.api.Detector
+import com.android.tools.lint.detector.api.Issue
+import com.android.tools.lint.detector.api.JavaContext
+import com.android.tools.lint.detector.api.TextFormat
+import com.intellij.psi.PsiType
+import com.intellij.psi.util.PsiUtil
+import org.jetbrains.uast.UClass
+import org.jetbrains.uast.getUastContext
+
+// Base class for Lint checks centered around the notion of "TiView not implemented"
+abstract class BaseMissingViewDetector : Detector(), Detector.UastScanner {
+
+    /**
+     * The Issue that the detector is connected to, reported on illegal state detection
+     */
+    abstract val issue: Issue
+
+    /**
+     * The list of super-classes to detect.
+     * We're forcing sub-classed Detectors to implement this by means of redeclaration
+     */
+    abstract override fun applicableSuperClasses(): List<String>
+
+    /**
+     * Whether or not to allow the absence of an "implements TiView" clause on the given declaration.
+     * The View interface is given as well to allow for further introspection into the setup of the class at hand.
+     * When false is returned here, Lint will report the Issue connected to this Detector on the given declaration.
+     */
+    abstract fun allowMissingViewInterface(context: JavaContext, declaration: UClass, viewInterface: PsiType): Boolean
+
+    /**
+     * Tries to extract the PsiType of the TiView sub-class that is relevant for the given declaration.
+     * The relevant super-class (from applicableSuperClasses()) & its resolved variant are given as well.
+     */
+    abstract fun findViewInterface(context: JavaContext, declaration: UClass): PsiType?
+
+    final override fun visitClass(context: JavaContext, declaration: UClass) {
+        if (!context.isEnabled(issue)) {
+            return
+        }
+        // Don't trigger on abstract classes
+        if (PsiUtil.isAbstractClass(declaration.psi)) {
+            return
+        }
+        // Extract the MVP View type from the declaration
+        findViewInterface(context, declaration)?.let { viewInterface ->
+            // Check if the class implements that interface as well
+            if (!tryFindViewImplementation(context, declaration, viewInterface)) {
+                // Interface not implemented; check if alternate condition applies
+                if (!allowMissingViewInterface(context, declaration, viewInterface)) {
+                    // Invalid state: Report issue for this class
+                    declaration.nameIdentifier?.run {
+                        context.report(
+                                issue,
+                                context.getLocation(this.originalElement),
+                                issue.getBriefDescription(TextFormat.TEXT))
+                    }
+                }
+            }
+        }
+    }
+
+    private fun tryFindViewImplementation(context: JavaContext, declaration: UClass,
+            viewInterface: PsiType): Boolean {
+        for (implementedType in declaration.implementsListTypes) {
+            if (implementedType == viewInterface) {
+                return true
+            }
+            implementedType.resolve()?.let { resolvedType ->
+                val uastContext = declaration.getUastContext()
+                return tryFindViewImplementation(context, uastContext.getClass(resolvedType), viewInterface)
+            }
+        }
+        return false
+    }
+}

thirtyinch-lint/src/main/kotlin/net/grandcentrix/thirtyinch/lint/detector/MissingViewInCompositeDetector.kt

@@ -0,0 +1,86 @@
+package net.grandcentrix.thirtyinch.lint.detector
+
+import com.android.tools.lint.detector.api.Issue
+import com.android.tools.lint.detector.api.JavaContext
+import com.intellij.psi.PsiJavaCodeReferenceElement
+import com.intellij.psi.PsiType
+import net.grandcentrix.thirtyinch.lint.TiIssue.MissingView
+import org.jetbrains.uast.UBlockExpression
+import org.jetbrains.uast.UCallExpression
+import org.jetbrains.uast.UClass
+import org.jetbrains.uast.UExpression
+import org.jetbrains.uast.getUastContext
+
+private const val ADD_PLUGIN_METHOD = "addPlugin"
+private const val TI_ACTIVITY_PLUGIN_NAME = "TiActivityPlugin"
+private const val TI_FRAGMENT_PLUGIN_NAME = "TiFragmentPlugin"
+private val CA_CLASS_NAMES = listOf(
+        "com.pascalwelsch.compositeandroid.activity.CompositeActivity",
+        "com.pascalwelsch.compositeandroid.fragment.CompositeFragment"
+)
+
+class MissingViewInCompositeDetector : BaseMissingViewDetector() {
+    companion object {
+        val ISSUE = MissingView.asLintIssue(
+                MissingViewInCompositeDetector::class.java,
+                "When using ThirtyInch, a class extending CompositeActivity or CompositeFragment " +
+                        "has to implement the TiView interface associated with it in its signature, " +
+                        "if it applies the respective plugin as well."
+        )
+    }
+
+    override fun applicableSuperClasses() = CA_CLASS_NAMES
+
+    override val issue: Issue = MissingViewInThirtyInchDetector.ISSUE
+
+    override fun findViewInterface(context: JavaContext, declaration: UClass): PsiType? {
+        // Expect TiPlugin to be applied in the extended CA class
+        // Found default constructor
+        val defaultConstructor = declaration.constructors.firstOrNull { it.typeParameters.isEmpty() }
+
+        defaultConstructor?.let {
+            val uastContext = declaration.getUastContext()
+            val body = uastContext.getMethodBody(defaultConstructor)
+            return tryFindViewFromCompositeConstructor(context, declaration, body)
+        }
+        return null
+    }
+
+    private fun tryFindViewFromCompositeConstructor(context: JavaContext, declaration: UClass,
+            expression: UExpression?): PsiType? {
+        if (expression == null) {
+            return null
+        }
+        when (expression) {
+            is UBlockExpression -> {
+                // Unwrap block statements; the first resolvable result is returned
+                expression.expressions
+                        .mapNotNull { tryFindViewFromCompositeConstructor(context, declaration, it) }
+                        .forEach { return it }
+            }
+            is UCallExpression -> {
+                // Inspect call sites
+                if (ADD_PLUGIN_METHOD == expression.methodName && expression.valueArgumentCount == 1) {
+                    // Expect a plugin to be used as the only argument to this method
+                    val argument = expression.valueArguments[0]
+                    if (argument is UCallExpression) {
+                        val argReference = argument.classReference ?: return null
+                        val resolvedName = argReference.resolvedName
+                        if (TI_ACTIVITY_PLUGIN_NAME == resolvedName || TI_FRAGMENT_PLUGIN_NAME == resolvedName) {
+                            // Matching names. Finally, find the type parameters passed to the plugin
+                            val psiReference = argReference.psi as PsiJavaCodeReferenceElement? ?: return null
+                            val parameterTypes = psiReference.typeParameters
+                            if (parameterTypes.size != 2) {
+                                return null
+                            }
+                            return parameterTypes[1]
+                        }
+                    }
+                }
+            }
+        }
+        return null
+    }
+
+    override fun allowMissingViewInterface(context: JavaContext, declaration: UClass, viewInterface: PsiType) = false
+}

thirtyinch-lint/src/main/kotlin/net/grandcentrix/thirtyinch/lint/detector/MissingViewInThirtyInchDetector.kt

@@ -0,0 +1,64 @@
+package net.grandcentrix.thirtyinch.lint.detector
+
+import com.android.tools.lint.detector.api.Issue
+import com.android.tools.lint.detector.api.JavaContext
+import com.intellij.psi.PsiClassType
+import com.intellij.psi.PsiType
+import net.grandcentrix.thirtyinch.lint.TiIssue.MissingView
+import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
+import org.jetbrains.uast.UClass
+
+private const val TI_VIEW_FQ = "net.grandcentrix.thirtyinch.TiView"
+private const val PROVIDE_VIEW_METHOD = "provideView"
+private val TI_CLASS_NAMES = listOf(
+        "net.grandcentrix.thirtyinch.TiActivity",
+        "net.grandcentrix.thirtyinch.TiFragment",
+        "net.grandcentrix.thirtyinch.TiDialogFragment"
+)
+
+class MissingViewInThirtyInchDetector : BaseMissingViewDetector() {
+    companion object {
+        val ISSUE = MissingView.asLintIssue(
+                MissingViewInThirtyInchDetector::class.java,
+                "When using ThirtyInch, a class extending TiActivity or TiFragment " +
+                        "has to implement the TiView interface associated with it in its signature, " +
+                        "or implement `provideView()` instead to override this default behaviour."
+        )
+    }
+
+    override fun applicableSuperClasses() = TI_CLASS_NAMES
+
+    override val issue: Issue = ISSUE
+
+    override fun findViewInterface(context: JavaContext, declaration: UClass): PsiType? {
+        return declaration.extendsListTypes
+                .firstNotNullResult { extendedType -> tryFindViewInterface(extendedType) }
+    }
+
+    private fun tryFindViewInterface(extendedType: PsiClassType): PsiType? {
+        val resolvedType = extendedType.resolveGenerics().element ?: return null
+
+        val parameters = extendedType.parameters
+        val parameterTypes = resolvedType.typeParameters
+
+        check(parameters.size == parameterTypes.size) { "Got different Array Sizes" }
+
+        return parameters
+                .mapIndexed { i, psiType -> Pair(psiType, parameterTypes[i]) }
+                .firstNotNullResult { (type, typeParameter) ->
+                    typeParameter.extendsListTypes
+                            .map { it.resolveGenerics().element }
+                            .filter { TI_VIEW_FQ == it?.qualifiedName }
+                            .map { type }
+                            .firstOrNull()
+                            ?: (type as? PsiClassType)?.let { tryFindViewInterface(it) }
+                }
+    }
+
+    override fun allowMissingViewInterface(context: JavaContext, declaration: UClass,
+            viewInterface: PsiType): Boolean {
+        // Interface not implemented; check if provideView() is overridden instead
+        return declaration.findMethodsByName(PROVIDE_VIEW_METHOD, true)
+                .any { viewInterface == it.returnType }
+    }
+}