Add lint check support for kotlin extensions (#439)

Author: Rajin9601

docs/lint-check.md

@@ -61,6 +61,15 @@ autodispose.lenient=true
 
 The default value of this is `false`. 
 
+### Kotlin Extension
+
+By default, `subscribe` and `subscribeWith` methods are checked. To support other subscribe methods such as `subscribeBy` in RxKotlin, you can add your own subscribe extensions.
+In your **app-level** `gradle.properties` files, add kotlin extension functions in format of `{full package name for extension's scope}#{functionName}` and comma-separated-values like so:
+
+```properties
+autodispose.kotlinExtensionFunctions="io.reactivex.rxjava3.kotlin.subscribers#subscribeBy,com.sample.app.SubscribeExt#subscribe2"
+```
+
 #### Examples
 ```java
 // This is allowed in lenient mode
@@ -77,4 +86,7 @@ Observable.just(1).subscribe();
 
 // This is not allowed in lenient mode, because that subscribe() overload just returns void
 Observable.just(1).subscribe(new Observer...)
+
+// This is not allowed when kotlin extension functions option is used
+Observable.just(1).subscribeBy { }
 ```

static-analysis/autodispose-lint/src/main/kotlin/autodispose2/lint/AutoDisposeDetector.kt

@@ -26,6 +26,8 @@ import com.android.tools.lint.detector.api.JavaContext
 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.google.common.collect.HashMultimap
+import com.google.common.collect.Multimap
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiType
 import com.intellij.psi.util.PsiUtil
@@ -48,6 +50,7 @@ import org.jetbrains.uast.visitor.AbstractUastVisitor
 internal const val CUSTOM_SCOPE_KEY = "autodispose.typesWithScope"
 internal const val LENIENT = "autodispose.lenient"
 internal const val OVERRIDE_SCOPES = "autodispose.overrideScopes"
+internal const val KOTLIN_EXTENSION_FUNCTIONS = "autodispose.kotlinExtensionFunctions"
 
 /**
  * Detector which checks if your stream subscriptions are handled by AutoDispose.
@@ -98,19 +101,24 @@ class AutoDisposeDetector : Detector(), SourceCodeScanner {
     private val REACTIVE_TYPES = setOf(OBSERVABLE, FLOWABLE, PARALLEL_FLOWABLE, SINGLE, MAYBE,
         COMPLETABLE)
 
+    private val REACTIVE_SUBSCRIBE_METHOD_NAMES = setOf("subscribe", "subscribeWith")
+
     internal const val PROPERTY_FILE = "gradle.properties"
   }
 
   // The scopes that are applicable for the lint check.
   // This includes the DEFAULT_SCOPES as well as any custom scopes
   // defined by the consumer.
   private lateinit var appliedScopes: Set<String>
+  private lateinit var ktExtensionMethodToPackageMap: Multimap<String, String>
+  private lateinit var appliedMethodNames: List<String>
 
   private var lenient: Boolean = false
 
   override fun beforeCheckRootProject(context: Context) {
     var overrideScopes = false
     val scopes = mutableSetOf<String>()
+    val ktExtensionMethodToPackageMap = HashMultimap.create<String, String>()
 
     // Add the custom scopes defined in configuration.
     val props = Properties()
@@ -125,6 +133,16 @@ class AutoDisposeDetector : Detector(), SourceCodeScanner {
             .toList()
         scopes.addAll(customScopes)
       }
+      props.getProperty(KOTLIN_EXTENSION_FUNCTIONS)?.let { ktExtensionProperty ->
+        ktExtensionProperty.split(",")
+            .forEach {
+              val arr = it.split("#", limit = 2)
+              if (arr.size >= 2) {
+                val (packageName, methodName) = arr
+                ktExtensionMethodToPackageMap.put(methodName, packageName)
+              }
+            }
+      }
       props.getProperty(LENIENT)?.toBoolean()?.let {
         lenient = it
       }
@@ -136,10 +154,12 @@ class AutoDisposeDetector : Detector(), SourceCodeScanner {
     if (!overrideScopes) {
       scopes.addAll(DEFAULT_SCOPES)
     }
-    appliedScopes = scopes
+    this.appliedScopes = scopes
+    this.ktExtensionMethodToPackageMap = ktExtensionMethodToPackageMap
+    this.appliedMethodNames = (REACTIVE_SUBSCRIBE_METHOD_NAMES + ktExtensionMethodToPackageMap.keySet()).toList()
   }
 
-  override fun getApplicableMethodNames(): List<String> = listOf("subscribe", "subscribeWith")
+  override fun getApplicableMethodNames(): List<String> = appliedMethodNames
 
   override fun createUastHandler(context: JavaContext): UElementHandler? {
     return object : UElementHandler() {
@@ -257,7 +277,15 @@ class AutoDisposeDetector : Detector(), SourceCodeScanner {
   }
 
   private fun isReactiveType(evaluator: JavaEvaluator, method: PsiMethod): Boolean {
-    return REACTIVE_TYPES.any { evaluator.isMemberInClass(method, it) }
+    return REACTIVE_SUBSCRIBE_METHOD_NAMES.contains(method.name) && REACTIVE_TYPES.any {
+      evaluator.isMemberInClass(method, it)
+    }
+  }
+
+  private fun isKotlinExtension(evaluator: JavaEvaluator, method: PsiMethod): Boolean {
+    return ktExtensionMethodToPackageMap.get(method.name).any {
+      evaluator.isMemberInClass(method, it)
+    }
   }
 
   /**
@@ -295,7 +323,7 @@ class AutoDisposeDetector : Detector(), SourceCodeScanner {
     if (!getApplicableMethodNames().contains(method.name)) return
     val evaluator = context.evaluator
 
-    if (isReactiveType(evaluator, method) &&
+    if ((isReactiveType(evaluator, method) || isKotlinExtension(evaluator, method)) &&
         isInScope(evaluator, node)
     ) {
       if (!lenient) {

static-analysis/autodispose-lint/src/test/kotlin/autodispose2/lint/AutoDisposeDetectorTest.kt

@@ -99,12 +99,33 @@ class AutoDisposeDetectorTest {
           }
         """).indented().within("src/")
 
-    private fun lenientPropertiesFile(lenient: Boolean = true): TestFile.PropertyTestFile {
+    private val RX_KOTLIN = kotlin(
+        "io/reactivex/rxjava3/kotlin/subscribers.kt",
+        """
+          @file:JvmName("subscribers")
+          package io.reactivex.rxjava3.kotlin
+
+          import io.reactivex.rxjava3.core.*
+          import io.reactivex.rxjava3.disposables.Disposable
+
+          fun <G : Any> Observable<G>.subscribeBy(
+                  onNext: (G) -> Unit
+          ): Disposable = subscribe()
+        """).indented().within("src/")
+
+    private fun propertiesFile(lenient: Boolean = true, kotlinExtensionFunctions: String? = null): TestFile.PropertyTestFile {
       val properties = projectProperties()
       properties.property(LENIENT, lenient.toString())
+      kotlinExtensionFunctions?.also {
+        properties.property(KOTLIN_EXTENSION_FUNCTIONS, it)
+      }
       properties.to(AutoDisposeDetector.PROPERTY_FILE)
       return properties
     }
+
+    private fun lenientPropertiesFile(lenient: Boolean = true): TestFile.PropertyTestFile {
+      return propertiesFile(lenient)
+    }
   }
 
   @Test fun observableErrorsOutOnOmittingAutoDispose() {
@@ -1002,6 +1023,62 @@ class AutoDisposeDetectorTest {
         .expectClean()
   }
 
+  @Test fun kotlinExtensionFunctionNotConfigured() {
+    lint()
+        .files(rxJava3(),
+            LIFECYCLE_OWNER,
+            RX_KOTLIN,
+            FRAGMENT,
+            kotlin("""
+          package foo
+          import io.reactivex.rxjava3.core.Observable
+          import io.reactivex.rxjava3.observers.DisposableObserver
+          import io.reactivex.rxjava3.kotlin.subscribeBy
+          import androidx.fragment.app.Fragment
+
+          class ExampleClass : Fragment() {
+            fun names() {
+              val obs = Observable.just(1, 2, 3, 4)
+              obs.subscribeBy { }
+            }
+          }
+        """).indented())
+        .allowCompilationErrors(false)
+        .issues(AutoDisposeDetector.ISSUE)
+        .run()
+        .expectClean()
+  }
+
+  @Test fun kotlinExtensionFunctionNotHandled() {
+    lint()
+        .files(rxJava3(),
+            propertiesFile(kotlinExtensionFunctions = "io.reactivex.rxjava3.kotlin.subscribers#subscribeBy"),
+            LIFECYCLE_OWNER,
+            RX_KOTLIN,
+            FRAGMENT,
+            kotlin("""
+          package foo
+          import io.reactivex.rxjava3.core.Observable
+          import io.reactivex.rxjava3.observers.DisposableObserver
+          import io.reactivex.rxjava3.kotlin.subscribeBy
+          import androidx.fragment.app.Fragment
+
+          class ExampleClass : Fragment() {
+            fun names() {
+              val obs = Observable.just(1, 2, 3, 4)
+              obs.subscribeBy { }
+            }
+          }
+        """).indented())
+        .allowCompilationErrors(false)
+        .issues(AutoDisposeDetector.ISSUE)
+        .run()
+        .expect("""src/foo/ExampleClass.kt:10: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
+          |    obs.subscribeBy { }
+          |    ~~~~~~~~~~~~~~~~~~~
+          |1 errors, 0 warnings""".trimMargin())
+  }
+
   @Test fun subscribeWithCapturedNonDisposableType() {
     lint()
         .files(rxJava3(),