Return rendering instead of Unit

Author: steve-the-edwards

benchmarks/performance-poetry/complex-poetry/src/androidTest/java/com/squareup/benchmarks/performance/complex/poetry/ComposeInheritanceTest.kt

@@ -0,0 +1,59 @@
+package com.squareup.benchmarks.performance.complex.poetry
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import app.cash.molecule.AndroidUiDispatcher
+import app.cash.molecule.launchMolecule
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class ComposeInheritanceTest {
+
+  abstract class Parent<T> {
+    @Composable
+    open fun AComposable(
+      hoistToggleState: @Composable (s: T) -> Unit
+    ): Unit = throw IllegalStateException("I don't want to be a parent.")
+  }
+
+  class Child<T>(
+    private val payload: T
+  ): Parent<T>() {
+    @Composable
+    override fun AComposable(
+      hoistToggleState: @Composable (s: T) -> Unit
+    ) {
+      println("Can you hear me now? $payload")
+      hoistToggleState(payload)
+    }
+  }
+
+  @Composable
+  fun <T> Emitter(someObject: Parent<T>): T? {
+    val payload: MutableState<T?> = remember { mutableStateOf(null) }
+    someObject.AComposable {
+      payload.value = it
+    }
+    return payload.value
+  }
+
+  @OptIn(ExperimentalCoroutinesApi::class)
+  @Test fun testComposableOverloading() {
+    val child: Parent<String> = Child<String>("a test")
+    val testScope = CoroutineScope(AndroidUiDispatcher.Main)
+
+    val testFlow = testScope.launchMolecule {
+      Emitter(child)
+    }
+
+    assertThat(testFlow.value).isEqualTo("a test")
+  }
+
+}

benchmarks/performance-poetry/complex-poetry/src/main/java/com/squareup/benchmarks/performance/complex/poetry/MaybeLoadingGatekeeperWorkflow.kt

@@ -54,30 +54,25 @@ class MaybeLoadingGatekeeperWorkflow<T : Any>(
     renderProps: Unit,
     renderState: IsLoading,
     context: RenderContext,
-    hoistRendering: @Composable (rendering: MayBeLoadingScreen) -> Unit
-  ) {
+  ): MayBeLoadingScreen {
     context.runningWorker(isLoading.asTraceableWorker("GatekeeperLoading")) {
       action {
         state = it
       }
     }
-    context.ChildRendering(
+    val maybeLoadingChild = context.ChildRendering(
       childWithLoading, childProps, "",
-      hoistRendering = {
-        hoistRendering(
-          MayBeLoadingScreen(
-            baseScreen = it,
-            loaders = if (renderState) listOf(LoaderSpinner) else emptyList()
-          )
-        )
-      }
     ) {
       action(ActionHandlingTracingInterceptor.keyForTrace("GatekeeperChildFinished")) {
         setOutput(
           Unit
         )
       }
     }
+    return MayBeLoadingScreen(
+      baseScreen = maybeLoadingChild,
+      loaders = if (renderState) listOf(LoaderSpinner) else emptyList()
+    )
   }
 
   override fun snapshotState(state: IsLoading): Snapshot? = null

benchmarks/performance-poetry/complex-poetry/src/main/java/com/squareup/benchmarks/performance/complex/poetry/PerformancePoemWorkflow.kt

@@ -245,8 +245,7 @@ class PerformancePoemWorkflow(
     renderProps: Poem,
     renderState: State,
     context: RenderContext,
-    hoistRendering: @Composable (rendering: OverviewDetailScreen) -> Unit
-  ) {
+  ): OverviewDetailScreen {
     when (renderState) {
       Initializing -> {
         // Again, the entire `Initializing` state is a smell, which is most obvious from the
@@ -264,7 +263,7 @@ class PerformancePoemWorkflow(
             state = Selected(NO_SELECTED_STANZA)
           }
         }
-        hoistRendering(OverviewDetailScreen(overviewRendering = BackStackScreen(BlankScreen)))
+        return OverviewDetailScreen(overviewRendering = BackStackScreen(BlankScreen))
       }
       else -> {
         val (stanzaIndex, currentStateIsLoading, repeat) = when (renderState) {
@@ -314,16 +313,21 @@ class PerformancePoemWorkflow(
           }
         }
 
-        val previousStanzas: MutableState<List<StanzaScreen>> = remember {
-          mutableStateOf(emptyList())
-        }
-        val visibleStanza: MutableState<StanzaScreen?> = remember {
-          mutableStateOf(null)
+        val stanzaListOverview = context.ChildRendering(
+          StanzaListWorkflow,
+          StanzaListWorkflow.Props(
+            poem = renderProps,
+            eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
+          ),
+          key = "",
+        ) { selected ->
+          HandleStanzaListOutput(simulatedPerfConfig, selected)
         }
+          .copy(selection = stanzaIndex)
 
         if (stanzaIndex != NO_SELECTED_STANZA) {
-          renderProps.stanzas.subList(0, stanzaIndex)
-            .forEachIndexed { index, _ ->
+          val previousStanzas = renderProps.stanzas.subList(0, stanzaIndex)
+            .mapIndexed { index, _ ->
               context.ChildRendering(
                 StanzaWorkflow,
                 Props(
@@ -332,67 +336,42 @@ class PerformancePoemWorkflow(
                   eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
                 ),
                 key = "$index",
-                hoistRendering = @Composable {
-                  previousStanzas.value = previousStanzas.value + it
-                }
               ) {
                 noAction()
               }
             }
-          context.ChildRendering(
+          val visibleStanza = context.ChildRendering(
             StanzaWorkflow,
             Props(
               poem = renderProps,
               index = stanzaIndex,
               eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
             ),
             key = "$stanzaIndex",
-            hoistRendering = @Composable {
-              visibleStanza.value = it
-            }
           ) {
             when (it) {
               CloseStanzas -> ClearSelection(simulatedPerfConfig)
               ShowPreviousStanza -> SelectPrevious(simulatedPerfConfig)
               ShowNextStanza -> SelectNext(simulatedPerfConfig)
             }
           }
-        }
 
-        val stackedStanzas = visibleStanza.value?.let {
-          (previousStanzas.value + it).toBackStackScreen<Screen>()
-        }
-
-        val stanzaListOverview: MutableState<StanzaListScreen?> = remember {
-          mutableStateOf(null)
-        }
-        context.ChildRendering(
-          StanzaListWorkflow,
-          StanzaListWorkflow.Props(
-            poem = renderProps,
-            eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
-          ),
-          key = "",
-          hoistRendering = @Composable {
-            stanzaListOverview.value = it.copy(selection = stanzaIndex)
+          val stackedStanzas = visibleStanza.let {
+            (previousStanzas + it).toBackStackScreen<Screen>()
           }
-        ) { selected ->
-          HandleStanzaListOutput(simulatedPerfConfig, selected)
-        }
 
-        hoistRendering(
-          stackedStanzas
-            ?.let {
-              OverviewDetailScreen(
-                overviewRendering = BackStackScreen(stanzaListOverview.value!!),
-                detailRendering = it
-              )
-            } ?: OverviewDetailScreen(
-            overviewRendering = BackStackScreen(stanzaListOverview.value!!),
-            selectDefault = {
-              context.actionSink.send(HandleStanzaListOutput(simulatedPerfConfig, 0))
-            }
+          return OverviewDetailScreen(
+            overviewRendering = BackStackScreen(stanzaListOverview),
+            detailRendering = stackedStanzas
           )
+        }
+
+
+        return OverviewDetailScreen(
+          overviewRendering = BackStackScreen(stanzaListOverview),
+          selectDefault = {
+            context.actionSink.send(HandleStanzaListOutput(simulatedPerfConfig, 0))
+          }
         )
       }
     }

benchmarks/performance-poetry/complex-poetry/src/main/java/com/squareup/benchmarks/performance/complex/poetry/PerformancePoemsBrowserWorkflow.kt

@@ -160,99 +160,91 @@ class PerformancePoemsBrowserWorkflow(
     renderProps: List<Poem>,
     renderState: State,
     context: RenderContext,
-    hoistRendering: @Composable (rendering: OverviewDetailScreen) -> Unit
-  ) {
+  ): OverviewDetailScreen {
     val poemListProps = Props(
       poems = renderProps,
       eventHandlerTag = ActionHandlingTracingInterceptor::keyForTrace
     )
-    context.ChildRendering(
+
+    val poemListRendering = context.ChildRendering(
       child = PoemListWorkflow,
       props = poemListProps,
       key = "",
-      hoistRendering = { poemListRendering ->
-        when (renderState) {
-          // Again, then entire `Initializing` state is a smell, which is most obvious from the
-          // use of `Worker.from { Unit }`. A Worker doing no work and only shuttling the state
-          // along is usually the sign you have an extraneous state that can be collapsed!
-          // Don't try this at home.
-          is Initializing -> {
-            context.runningWorker(TraceableWorker.from("BrowserInitializing") { Unit }, "init") {
-            isLoading.value = true
-            action {
-              isLoading.value = false
-              state = NoSelection
-            }
-          }
-            hoistRendering(OverviewDetailScreen(overviewRendering = BackStackScreen(BlankScreen)))
-          }
-          is NoSelection -> {
-            hoistRendering(
-              OverviewDetailScreen(
-                overviewRendering = BackStackScreen(
-                  poemListRendering.copy(selection = NO_POEM_SELECTED)
-                )
-              )
+    ) { selected ->
+      choosePoem(selected)
+    }
+    when (renderState) {
+      // Again, then entire `Initializing` state is a smell, which is most obvious from the
+      // use of `Worker.from { Unit }`. A Worker doing no work and only shuttling the state
+      // along is usually the sign you have an extraneous state that can be collapsed!
+      // Don't try this at home.
+      is Initializing -> {
+        context.runningWorker(TraceableWorker.from("BrowserInitializing") { Unit }, "init") {
+        isLoading.value = true
+        action {
+          isLoading.value = false
+          state = NoSelection
+        }
+      }
+        return OverviewDetailScreen(overviewRendering = BackStackScreen(BlankScreen))
+      }
+      is NoSelection -> {
+        return OverviewDetailScreen(
+            overviewRendering = BackStackScreen(
+              poemListRendering.copy(selection = NO_POEM_SELECTED)
             )
+          )
+      }
+      is ComplexCall -> {
+        context.runningWorker(
+          TraceableWorker.from("ComplexCallBrowser(${renderState.payload})") {
+            isLoading.value = true
+            delay(simulatedPerfConfig.complexityDelay)
+            // No Output for Worker is necessary because the selected index
+            // is already in the state.
           }
-          is ComplexCall -> {
-            context.runningWorker(
-              TraceableWorker.from("ComplexCallBrowser(${renderState.payload})") {
-                isLoading.value = true
-                delay(simulatedPerfConfig.complexityDelay)
-                // No Output for Worker is necessary because the selected index
-                // is already in the state.
-              }
-            ) {
-              action {
-                isLoading.value = false
-                (state as? ComplexCall)?.let { currentState ->
-                  state = if (currentState.payload != NO_POEM_SELECTED) {
-                    Selected(currentState.payload)
-                  } else {
-                    NoSelection
-                  }
-                }
+        ) {
+          action {
+            isLoading.value = false
+            (state as? ComplexCall)?.let { currentState ->
+              state = if (currentState.payload != NO_POEM_SELECTED) {
+                Selected(currentState.payload)
+              } else {
+                NoSelection
               }
             }
-            val poemOverview = OverviewDetailScreen(
-              overviewRendering = BackStackScreen(
-                poemListRendering.copy(selection = renderState.payload)
-              )
-            )
-            if (renderState.payload != NO_POEM_SELECTED) {
-              context.ChildRendering(
-                poemWorkflow,
-                renderProps[renderState.payload],
-                key = "",
-                hoistRendering = { poem: OverviewDetailScreen ->
-                  hoistRendering(poemOverview + poem)
-                }
-              ) { clearSelection }
-            } else {
-              hoistRendering(poemOverview)
-            }
-          }
-          is Selected -> {
-            val poemOverview = OverviewDetailScreen(
-              overviewRendering = BackStackScreen(
-                poemListRendering.copy(selection = renderState.poemIndex)
-              )
-            )
-            context.ChildRendering(
-              poemWorkflow,
-              renderProps[renderState.poemIndex],
-              key = "",
-              hoistRendering = { poem: OverviewDetailScreen ->
-                hoistRendering(poemOverview + poem)
-              }
-            ) { clearSelection }
           }
         }
+        val poemOverview = OverviewDetailScreen(
+          overviewRendering = BackStackScreen(
+            poemListRendering.copy(selection = renderState.payload)
+          )
+        )
+        val poems = if (renderState.payload != NO_POEM_SELECTED) {
+          poemOverview + context.ChildRendering(
+            poemWorkflow,
+            renderProps[renderState.payload],
+            key = "",
+          ) { clearSelection }
+        } else {
+          poemOverview
+        }
+        return poems
+      }
+      is Selected -> {
+        val poemOverview = OverviewDetailScreen(
+          overviewRendering = BackStackScreen(
+            poemListRendering.copy(selection = renderState.poemIndex)
+          )
+        )
+        return poemOverview + context.ChildRendering(
+          poemWorkflow,
+          renderProps[renderState.poemIndex],
+          key = "",
+        ) { clearSelection }
       }
-    ) { selected ->
-      choosePoem(selected)
     }
+
   }
 
   override fun snapshotState(state: State): Snapshot? = null