Add exemptions for androidx.lifecycle.compose effects (#449)

Author: mrmans0n

rules/common/src/main/kotlin/io/nlopez/compose/core/util/Composables.kt

@@ -344,6 +344,9 @@ private val RestartableEffects by lazy {
         "LaunchedEffect",
         "produceState",
         "DisposableEffect",
+        "LifecycleEventEffect", // androidx.lifecycle.compose
+        "LifecycleResumeEffect",
+        "LifecycleStartEffect",
         "produceRetainedState", // Circuit
     )
 }

rules/common/src/main/kotlin/io/nlopez/compose/rules/LambdaParameterInRestartableEffect.kt

@@ -52,15 +52,24 @@ class LambdaParameterInRestartableEffect : ComposeKtVisitor {
                         // Filter out dot receivers e.g. `something.myLambda()`
                         .filterNot { it.isDotSelector() }
 
-                    val isDisposableEffect = effect.calleeExpression?.text == "DisposableEffect"
+                    val effectCallee = effect.calleeExpression?.text
+                    val isDisposableEffect = effectCallee == "DisposableEffect"
+                    val isLifecycleEffect = effectCallee == "LifecycleStartEffect" ||
+                        effectCallee == "LifecycleResumeEffect"
 
                     // Lambdas used directly: myLambda()
                     val invoked = callExpressions
                         .let { expressions ->
-                            if (isDisposableEffect) {
-                                expressions.filter { it.calleeExpression?.text != "onDispose" }
-                            } else {
-                                expressions
+                            when {
+                                isDisposableEffect -> {
+                                    expressions.filter { it.calleeExpression?.text != "onDispose" }
+                                }
+                                isLifecycleEffect -> {
+                                    expressions.filter { it.calleeExpression?.text !in LifecycleEffectScopeFunctions }
+                                }
+                                else -> {
+                                    expressions
+                                }
                             }
                         }
                         .mapNotNull { it.calleeExpression?.text }
@@ -120,5 +129,7 @@ class LambdaParameterInRestartableEffect : ComposeKtVisitor {
             However, if the effect is not to be restarted, you will need to use `rememberUpdatedState` on the parameter and use its result in the effect.
             See https://mrmans0n.github.io/compose-rules/rules/#be-mindful-of-the-arguments-you-use-inside-of-a-restarting-effect for more information.
         """.trimIndent()
+
+        private val LifecycleEffectScopeFunctions = setOf("onStopOrDispose", "onPauseOrDispose")
     }
 }

rules/detekt/src/test/kotlin/io/nlopez/compose/rules/detekt/LambdaParameterInRestartableEffectCheckTest.kt

@@ -136,6 +136,18 @@ class LambdaParameterInRestartableEffectCheckTest {
                         onDispose(onDispose)
                     }
                 }
+                @Composable
+                fun Something(onDispose: () -> Unit) {
+                    LifecycleStartEffect(Unit) {
+                        onStopOrDispose(onDispose)
+                    }
+                }
+                @Composable
+                fun Something(onDispose: () -> Unit) {
+                    LifecycleResumeEffect(Unit) {
+                        onPauseOrDispose(onDispose)
+                    }
+                }
 
                 // TODO ideally these would also be caught, but may require type resolution
                 @Composable
@@ -157,6 +169,8 @@ class LambdaParameterInRestartableEffectCheckTest {
             .hasStartSourceLocations(
                 SourceLocation(2, 15),
                 SourceLocation(8, 15),
+                SourceLocation(14, 15),
+                SourceLocation(20, 15),
             )
         for (error in errors) {
             assertThat(error).hasMessage(LambdaParameterInRestartableEffect.LambdaUsedInRestartableEffect)
@@ -179,4 +193,38 @@ class LambdaParameterInRestartableEffectCheckTest {
         val errors = rule.lint(code)
         assertThat(errors).isEmpty()
     }
+
+    @Test
+    fun `passes when a lambda named onStopOrDispose is present but unused in LifecycleStartEffect`() {
+        @Language("kotlin")
+        val code =
+            """
+                @Composable
+                fun Something(onDispose: () -> Unit) {
+                    val latestOnDispose by rememberUpdatedState(onDispose)
+                    LifecycleStartEffect(Unit) {
+                        onStopOrDispose(latestOnDispose)
+                    }
+                }
+            """.trimIndent()
+        val errors = rule.lint(code)
+        assertThat(errors).isEmpty()
+    }
+
+    @Test
+    fun `passes when a lambda named onPauseOrDispose is present but unused in LifecycleResumeEffect`() {
+        @Language("kotlin")
+        val code =
+            """
+                @Composable
+                fun Something(onDispose: () -> Unit) {
+                    val latestOnDispose by rememberUpdatedState(onDispose)
+                    LifecycleResumeEffect(Unit) {
+                        onPauseOrDispose(latestOnDispose)
+                    }
+                }
+            """.trimIndent()
+        val errors = rule.lint(code)
+        assertThat(errors).isEmpty()
+    }
 }

rules/ktlint/src/test/kotlin/io/nlopez/compose/rules/ktlint/LambdaParameterInRestartableEffectCheckTest.kt

@@ -142,6 +142,18 @@ class LambdaParameterInRestartableEffectCheckTest {
                         onDispose(onDispose)
                     }
                 }
+                @Composable
+                fun Something(onDispose: () -> Unit) {
+                    LifecycleStartEffect(Unit) {
+                        onStopOrDispose(onDispose)
+                    }
+                }
+                @Composable
+                fun Something(onDispose: () -> Unit) {
+                    LifecycleResumeEffect(Unit) {
+                        onPauseOrDispose(onDispose)
+                    }
+                }
 
                 // TODO ideally these would also be caught, but may require type resolution
                 @Composable
@@ -170,6 +182,16 @@ class LambdaParameterInRestartableEffectCheckTest {
                     col = 15,
                     detail = LambdaParameterInRestartableEffect.LambdaUsedInRestartableEffect,
                 ),
+                LintViolation(
+                    line = 14,
+                    col = 15,
+                    detail = LambdaParameterInRestartableEffect.LambdaUsedInRestartableEffect,
+                ),
+                LintViolation(
+                    line = 20,
+                    col = 15,
+                    detail = LambdaParameterInRestartableEffect.LambdaUsedInRestartableEffect,
+                ),
             )
     }
 
@@ -188,4 +210,36 @@ class LambdaParameterInRestartableEffectCheckTest {
             """.trimIndent()
         ruleAssertThat(code).hasNoLintViolations()
     }
+
+    @Test
+    fun `passes when a lambda named onStopOrDispose is present but unused in LifecycleStartEffect`() {
+        @Language("kotlin")
+        val code =
+            """
+                @Composable
+                fun Something(onDispose: () -> Unit) {
+                    val latestOnDispose by rememberUpdatedState(onDispose)
+                    LifecycleStartEffect(Unit) {
+                        onStopOrDispose(latestOnDispose)
+                    }
+                }
+            """.trimIndent()
+        ruleAssertThat(code).hasNoLintViolations()
+    }
+
+    @Test
+    fun `passes when a lambda named onPauseOrDispose is present but unused in LifecycleResumeEffect`() {
+        @Language("kotlin")
+        val code =
+            """
+                @Composable
+                fun Something(onDispose: () -> Unit) {
+                    val latestOnDispose by rememberUpdatedState(onDispose)
+                    LifecycleResumeEffect(Unit) {
+                        onPauseOrDispose(latestOnDispose)
+                    }
+                }
+            """.trimIndent()
+        ruleAssertThat(code).hasNoLintViolations()
+    }
 }