ComposeUnstableReceiver only for non-Unit returning functions (#468)

blipinsk · ZacSweers · web-flow · commit e5463a70deb9 · 2025-07-16T17:05:05.000Z
* ComposeUnstableReceiver detector updated

* Tests updated

* Rules warning

* Spotless

---------

Co-authored-by: Zac Sweers &lt;pandanomic@gmail.com&gt;
diff --git a/compose-lint-checks/src/main/java/slack/lint/compose/UnstableReceiverDetector.kt b/compose-lint-checks/src/main/java/slack/lint/compose/UnstableReceiverDetector.kt
@@ -18,6 +18,7 @@ import org.jetbrains.uast.UMethod
 import org.jetbrains.uast.getContainingUClass
 import slack.lint.compose.util.Priorities
 import slack.lint.compose.util.isStable
+import slack.lint.compose.util.returnsUnitOrVoid
 import slack.lint.compose.util.sourceImplementation
 
 class UnstableReceiverDetector : ComposableFunctionDetector(), SourceCodeScanner {
@@ -65,30 +66,34 @@ class UnstableReceiverDetector : ComposableFunctionDetector(), SourceCodeScanner
         else -> null
       }
 
-    if (receiverType?.isStable(context.evaluator) == false) {
-      context.report(
-        ISSUE,
-        nodeToReport,
-        context.getLocation(nodeToReport),
-        ISSUE.getExplanation(TextFormat.TEXT),
-      )
-    } else if (!method.isTopLevelKtOrJavaMember() && !method.isStatic) {
-      // We check both the receiver and the containing class, as classes could have
-      // extension functions in their declarations too.
-      val containingClass = method.getContainingUClass()
-      val containingClassType =
-        containingClass
-          // If the containing class is an object, it will never be passed as a receiver arg
-          ?.takeUnless { it.sourcePsi is KtObjectDeclaration }
-          ?.let(context.evaluator::getClassType) ?: return
-
-      if (!containingClassType.isStable(context.evaluator, resolveUClass = { containingClass })) {
+    // Only non-Unit returning functions can be skippable.
+    // Non-skippable functions will always be recomposed regardless of the receiver type.
+    if (method.returnsUnitOrVoid(context.evaluator)) {
+      if (receiverType?.isStable(context.evaluator) == false) {
         context.report(
           ISSUE,
-          method,
-          context.getNameLocation(method),
+          nodeToReport,
+          context.getLocation(nodeToReport),
           ISSUE.getExplanation(TextFormat.TEXT),
         )
+      } else if (!method.isTopLevelKtOrJavaMember() && !method.isStatic) {
+        // We check both the receiver and the containing class, as classes could have
+        // extension functions in their declarations too.
+        val containingClass = method.getContainingUClass()
+        val containingClassType =
+          containingClass
+            // If the containing class is an object, it will never be passed as a receiver arg
+            ?.takeUnless { it.sourcePsi is KtObjectDeclaration }
+            ?.let(context.evaluator::getClassType) ?: return
+
+        if (!containingClassType.isStable(context.evaluator, resolveUClass = { containingClass })) {
+          context.report(
+            ISSUE,
+            method,
+            context.getNameLocation(method),
+            ISSUE.getExplanation(TextFormat.TEXT),
+          )
+        }
       }
     }
   }
diff --git a/compose-lint-checks/src/test/java/slack/lint/compose/UnstableReceiverDetectorTest.kt b/compose-lint-checks/src/test/java/slack/lint/compose/UnstableReceiverDetectorTest.kt
@@ -43,9 +43,6 @@ class UnstableReceiverDetectorTest : BaseComposeLintTest() {
         @Composable
         fun Example.OtherContent() {}
 
-        @get:Composable
-        val Example.OtherContentProperty get() {}
-
         @Stable
         enum class EnumExample {
           TEST;
@@ -108,16 +105,13 @@ class UnstableReceiverDetectorTest : BaseComposeLintTest() {
         @Composable
         fun Example.OtherContent() {}
 
-        @get:Composable
-        val Example.OtherContentProperty get() {}
-
         // Supertypes
-        interface Presenter<T> {
-          @Composable fun present(): T
+        interface Presenter {
+          @Composable fun present()
         }
 
-        class HomePresenter : Presenter<String> {
-          @Composable override fun present(): String { return "hi" }
+        class HomePresenter : Presenter {
+          @Composable override fun present() { println("hi") }
         }
       """
         .trimIndent()
@@ -135,18 +129,49 @@ class UnstableReceiverDetectorTest : BaseComposeLintTest() {
           src/ExampleInterface.kt:12: Warning: Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information. [ComposeUnstableReceiver]
           fun Example.OtherContent() {}
               ~~~~~~~
-          src/ExampleInterface.kt:15: Warning: Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information. [ComposeUnstableReceiver]
-          val Example.OtherContentProperty get() {}
-              ~~~~~~~
-          src/ExampleInterface.kt:19: Warning: Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information. [ComposeUnstableReceiver]
-            @Composable fun present(): T
+          src/ExampleInterface.kt:16: Warning: Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information. [ComposeUnstableReceiver]
+            @Composable fun present()
                             ~~~~~~~
-          src/ExampleInterface.kt:23: Warning: Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information. [ComposeUnstableReceiver]
-            @Composable override fun present(): String { return "hi" }
+          src/ExampleInterface.kt:20: Warning: Instance composable functions on non-stable classes will always be recomposed. If possible, make the receiver type stable or refactor this function if that isn't possible. See https://slackhq.github.io/compose-lints/rules/#unstable-receivers for more information. [ComposeUnstableReceiver]
+            @Composable override fun present() { println("hi") }
                                      ~~~~~~~
-          0 errors, 6 warnings
+          0 errors, 5 warnings
         """
           .trimIndent()
       )
   }
+
+  @Test
+  fun `unstable receiver types with non-Unit return type report no errors`() {
+    @Language("kotlin")
+    val code =
+      """
+        import androidx.compose.runtime.Composable
+
+        interface ExampleInterface {
+          @Composable fun Content(): String
+        }
+
+        class Example {
+          @Composable fun Content(): String { return "hi" }
+        }
+
+        @Composable
+        fun Example.OtherContent(): String { return "hi" }
+
+        @get:Composable
+        val Example.OtherContentProperty get() {}
+
+        // Supertypes
+        interface Presenter<T> {
+          @Composable fun present(): T
+        }
+
+        class HomePresenter : Presenter<String> {
+          @Composable override fun present(): String { return "hi" }
+        }
+      """
+        .trimIndent()
+    lint().files(*commonStubs, kotlin(code)).run().expectClean()
+  }
 }
diff --git a/docs/rules.md b/docs/rules.md
@@ -71,6 +71,9 @@ Related rule: [`ComposeMutableParameters`](https://github.com/slackhq/compose-li
 In compose, all parameters must be stable or immutable in order for a composable function to be
 _restartable_ or _skippable_. This _includes_ the containing class or receiver, which the compose-compiler will treat as the 0th argument. Using an unstable receiver is usually a bug, so this lint offers a warning to raise this issue.
 
+!!! warning "Use with Strong Skipping"
+If you have Strong Skipping enabled, we recommend disabling this rule to avoid potential false negatives.
+
 More info: [Compose API Stability](https://developer.android.com/jetpack/compose/performance/stability)
 
 Related rule: [`ComposeUnstableReceiver`](https://github.com/slackhq/compose-lints/blob/main/compose-lint-checks/src/main/java/slack/lint/compose/UnstableReceiverDetector.kt)
