NoCallbacksInFunctions rule

Author: hbmartin

README.md

@@ -38,6 +38,9 @@ HbmartinRuleSet:
     active: true
   MutableTypeShouldBePrivate:
     active: true
+  NoCallbacksInFunctions:
+    active: true
+    ignoreAnnotated: ['Composable']
   NoNotNullOperator:
     active: true
   NoVarsInConstructor:
@@ -68,6 +71,9 @@ Finds uses of `as` to force cast. These are likely to lead to crashes, especiall
 
 Finds publicly exposed mutable types e.g. `MutableStateFlow<>`. These are likely to lead to bugs, prefer to expose a non-mutable `Flow` (e.g. with `_mutableStateFlow.asStateFlow()`) or other non-mutable type. [See here](https://github.com/hbmartin/hbmartin-detekt-rules/blob/main/src/test/kotlin/me/haroldmartin/detektrules/MutableTypeShouldBePrivateTest.kt) for triggering and non-triggering examples.
 
+### NoCallbacksInFunctions
+Finds uses of callbacks in functions. This can lead to a mixed concurrency paradigm and are likely to lead to bugs or stalled threads, prefer to use a suspend function instead. Use the `ignoreAnnotated` configuration to allow callbacks in `@Composable` functions.
+
 ### NoNotNullOperator
 
 Finds uses of `!!` to force unwrap. These are likely to lead to crashes, prefer to safely unwrap with `?.` or `?:` instead. Otherwise the Kotlin docs will make fun of you for being an [NPE lover](https://kotlinlang.org/docs/null-safety.html#the-operator). [See here](https://github.com/hbmartin/hbmartin-detekt-rules/blob/main/src/test/kotlin/me/haroldmartin/detektrules/NoNotNullOperatorTest.kt) for triggering and non-triggering examples.

config/detekt/detekt.yml

@@ -662,8 +662,6 @@ style:
     active: true
   OptionalUnit:
     active: true
-  OptionalWhenBraces:
-    active: true
   PreferToOverPairSyntax:
     active: true
   ProtectedMemberInFinalClass:

src/main/kotlin/me/haroldmartin/detektrules/HbmartinRuleSetProvider.kt

@@ -16,6 +16,7 @@ class HbmartinRuleSetProvider : RuleSetProvider {
                 AvoidVarsExceptWithDelegate(config),
                 DontForceCast(config),
                 MutableTypeShouldBePrivate(config),
+                NoCallbacksInFunctions(config),
                 NoNotNullOperator(config),
                 NoVarsInConstructor(config),
                 WhenBranchSingleLineOrBraces(config),

src/main/kotlin/me/haroldmartin/detektrules/NoCallbacksInFunctions.kt

@@ -0,0 +1,41 @@
+package me.haroldmartin.detektrules
+
+import io.gitlab.arturbosch.detekt.api.CodeSmell
+import io.gitlab.arturbosch.detekt.api.Config
+import io.gitlab.arturbosch.detekt.api.Debt
+import io.gitlab.arturbosch.detekt.api.Entity
+import io.gitlab.arturbosch.detekt.api.Issue
+import io.gitlab.arturbosch.detekt.api.Rule
+import io.gitlab.arturbosch.detekt.api.Severity
+import org.jetbrains.kotlin.psi.KtFunctionType
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtParameter
+
+class NoCallbacksInFunctions(config: Config) : Rule(config) {
+    override val issue = Issue(
+        id = javaClass.simpleName,
+        severity = Severity.Defect,
+        description = "Use coroutines instead of callbacks.",
+        debt = Debt.TWENTY_MINS,
+    )
+
+    override fun visitNamedFunction(function: KtNamedFunction) {
+        super.visitNamedFunction(function)
+        function.functionTypeParameters?.takeIf { it.isNotEmpty() }?.let {
+            report(
+                CodeSmell(
+                    issue = issue,
+                    entity = Entity.from(function),
+                    message = "${function.name} should not have callbacks: ${it.joinToString()}",
+                ),
+            )
+        }
+    }
+}
+
+@Suppress("AvoidMutableCollections")
+private val KtNamedFunction.functionTypeParameters: List<String>?
+    get() = valueParameterList?.run { parameters.flatMap { it.functionTypeParameters } }
+
+private val KtParameter.functionTypeParameters: List<String>
+    get() = typeReference?.run { children.mapNotNull { if (it is KtFunctionType) this.text else null } }.orEmpty()

src/main/resources/config/config.yml

@@ -16,5 +16,8 @@ HbmartinRuleSet:
     active: true
   NoVarsInConstructor:
     active: true
+  NoCallbacksInFunctions:
+    active: true
+    ignoreAnnotated: ['Composable']
   WhenBranchSingleLineOrBraces:
     active: true

src/test/kotlin/me/haroldmartin/detektrules/NoCallbacksInFunctionsTest.kt

@@ -0,0 +1,34 @@
+package me.haroldmartin.detektrules
+
+import io.gitlab.arturbosch.detekt.api.Config
+import io.gitlab.arturbosch.detekt.rules.KotlinCoreEnvironmentTest
+import io.gitlab.arturbosch.detekt.test.TestConfig
+import io.gitlab.arturbosch.detekt.test.compileAndLintWithContext
+import io.kotest.matchers.collections.shouldHaveSize
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.junit.jupiter.api.Test
+
+@KotlinCoreEnvironmentTest
+internal class NoCallbacksInFunctionsTest(private val env: KotlinCoreEnvironment) {
+    @Test
+    fun `reports callbacks`() {
+        val code = """
+        fun doNothing(s: String) {
+            println(s)
+        }
+        fun doSomething(callback1: (Float) -> Unit) {
+            callback1(1f)
+        }
+        private fun doSomethingElse(
+            parameter: List<Int>,
+            callback4: (Boolean) -> Unit,
+            anotherCallback5: (Any) -> Unit,
+            anotherParameter: List<Int>,
+        ) {
+            callback(true)
+        }
+        """
+        val findings = NoCallbacksInFunctions(Config.empty).compileAndLintWithContext(env, code)
+        findings shouldHaveSize 2
+    }
+}