*BREAKING* Introduces BaseRenderContext.remember and stable eventHandlers.

Workflow makes it very convenient to render view models with anonymous lambdas as their event handler functions. Compose hates that.

To address that mismatch without forcing everyone to retrofit their apps to use event objects instead of lambdas (it's a little late for that!) we introduce support for stable event handlers: anonymous lambdas whose identity looks the same to Compose across updates.

In order to do this we're breaking the existing `eventHandler` and `safeEventHandler` functions a bit.

- We introduce a new optional `remember: Boolean? = null` parameter. Set that true to get the new stability. If you leave it to the default `null` we look for a new `STABLE_EVENT_HANDLER : RuntimeConfigOption` to decide what to do. If you set that config option on an existing app and make no other changes, all of your existing `eventHandler` functions will be stable.

- When `remember` is true, the existing `name` parameter becomes weight bearing. It's no longer just a logging aid, it's part of a key identifying your stable lambda. The other parts of the key are its return type, and the types of any of its parameters. Duplicating a key within a particular `render()` call is a runtime error, similar to the rules for `renderChild`, `runningWorker`, and `runningSideEffect`.

- To make it easier to find fix and prevent those new runtime errors `testRender` and `WorkflowTestParams` now accept optional `RuntimeConfig` parameters, and throw appropriate errors if `STABLE_EVENT_HANDLER` is set. `testRender` also now honors `JvmTestRuntimeConfigTools.getTestRuntimeConfig()`.

- Most of the `eventHandler` functions have also been changed to `inline` -- necessary so that we can reify their parameter types for the key scheme described above

All of this is built on a new `BaseRenderContext.remember` primitive, which provides a light weight mechanism to save a bit of state across a workflow session without having to find room for it in `StateT`.

`BaseRenderContext` also now provides `val runtimeConfig: RuntimeConfig` in support of all of the above.

Author: rjrjr

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

@@ -12,12 +12,12 @@ import com.squareup.workflow1.WorkflowInterceptor.WorkflowSession
  * particular events.
  *
  * If you want to trace how long Workflow takes to process a UI event, then
- * annotate the [RenderContext.eventHandler] name argument with [keyForTrace]. That will cause
+ * annotate the `RenderContext.eventHandler` name argument with [keyForTrace]. That will cause
  * this interceptor to pick it up when the action is sent into the sink and trace that main thread
  * message.
  *
- * If you want to trace how long Workflow takes to process the result of a [Worker], then
- * annotate the [Worker] using [TraceableWorker] which will set it up with a key such that when
+ * If you want to trace how long Workflow takes to process the result of a `Worker`, then
+ * annotate the `Worker` using [TraceableWorker] which will set it up with a key such that when
  * the action for the result is sent to the sink the main thread message will be traced.
  */
 class ActionHandlingTracingInterceptor : WorkflowInterceptor, Resettable {

samples/compose-samples/src/main/java/com/squareup/sample/compose/inlinerendering/InlineRenderingWorkflow.kt

@@ -3,7 +3,6 @@
 package com.squareup.sample.compose.inlinerendering
 
 import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.ExperimentalAnimationApi
 import androidx.compose.animation.SizeTransform
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
@@ -38,12 +37,15 @@ object InlineRenderingWorkflow : StatefulWorkflow<Unit, Int, Nothing, Screen>()
     renderProps: Unit,
     renderState: Int,
     context: RenderContext
-  ) = ComposeScreen {
-    Box {
-      Button(onClick = context.eventHandler("increment") { state += 1 }) {
-        Text("Counter: ")
-        AnimatedCounter(renderState) { counterValue ->
-          Text(counterValue.toString())
+  ): ComposeScreen {
+    val onClick = context.eventHandler("increment") { state += 1 }
+    return ComposeScreen {
+      Box {
+        Button(onClick = onClick) {
+          Text("Counter: ")
+          AnimatedCounter(renderState) { counterValue ->
+            Text(counterValue.toString())
+          }
         }
       }
     }
@@ -68,7 +70,6 @@ internal fun InlineRenderingWorkflowPreview() {
   InlineRenderingWorkflowRendering()
 }
 
-@OptIn(ExperimentalAnimationApi::class)
 @Composable
 private fun AnimatedCounter(
   counterValue: Int,
@@ -79,6 +80,7 @@ private fun AnimatedCounter(
     transitionSpec = {
       ((slideInVertically() + fadeIn()).togetherWith(slideOutVertically() + fadeOut()))
         .using(SizeTransform(clip = false))
-    }
+    },
+    label = ""
   ) { content(it) }
 }

samples/containers/poetry/src/main/java/com/squareup/sample/poetry/StanzaListWorkflow.kt

@@ -15,7 +15,7 @@ object StanzaListWorkflow : StatelessWorkflow<Props, SelectedStanza, StanzaListS
 
   data class Props(
     val poem: Poem,
-    val eventHandlerTag: (String) -> String = { "" }
+    val eventHandlerTag: (String) -> String = { it }
   )
 
   const val NO_SELECTED_STANZA = -1

samples/containers/poetry/src/main/java/com/squareup/sample/poetry/StanzaWorkflow.kt

@@ -12,7 +12,7 @@ object StanzaWorkflow : StatelessWorkflow<Props, Output, StanzaScreen>() {
   data class Props(
     val poem: Poem,
     val index: Int,
-    val eventHandlerTag: (String) -> String = { "" }
+    val eventHandlerTag: (String) -> String = { it }
   )
 
   enum class Output {

samples/dungeon/timemachine/src/test/java/com/squareup/sample/timemachine/TimeMachineWorkflowTest.kt

@@ -25,7 +25,10 @@ class TimeMachineWorkflowTest {
     val delegateWorkflow = Workflow.stateful<String, Nothing, DelegateRendering>(
       initialState = "initial",
       render = { renderState ->
-        DelegateRendering(renderState, setState = eventHandler("") { s -> state = s })
+        DelegateRendering(
+          renderState,
+          setState = eventHandler("setState") { s -> state = s }
+        )
       }
     )
     val clock = TestTimeSource()

samples/nested-overlays/src/main/java/com/squareup/sample/nestedoverlays/NestedOverlaysWorkflow.kt

@@ -62,7 +62,7 @@ object NestedOverlaysWorkflow : StatefulWorkflow<Unit, State, Nothing, Screen>()
               name = R.string.close,
               onClick = closeOuter
             ),
-            context.toggleInnerSheetButton(renderState),
+            context.toggleInnerSheetButton(name = "inner", renderState),
             color = android.R.color.holo_green_light,
             showEditText = true,
           ),
@@ -103,33 +103,59 @@ object NestedOverlaysWorkflow : StatefulWorkflow<Unit, State, Nothing, Screen>()
       name = "outer",
       overlays = listOfNotNull(outerSheet),
       body = TopAndBottomBarsScreen(
-        topBar = if (!renderState.showTopBar) null else context.topBottomBar(renderState),
+        topBar = if (!renderState.showTopBar) {
+          null
+        } else {
+          context.topBottomBar(
+            top = true,
+            renderState
+          )
+        },
         content = BodyAndOverlaysScreen(
           name = "inner",
           body = bodyBarButtons,
           overlays = listOfNotNull(innerSheet)
         ),
-        bottomBar = if (!renderState.showBottomBar) null else context.topBottomBar(renderState)
+        bottomBar = if (!renderState.showBottomBar) {
+          null
+        } else {
+          context.topBottomBar(
+            top = false,
+            renderState
+          )
+        }
       )
     )
   }
 
   override fun snapshotState(state: State) = null
 
   private fun RenderContext.topBottomBar(
+    top: Boolean,
     renderState: State
-  ) = ButtonBar(
-    toggleInnerSheetButton(renderState),
-    Button(
-      name = R.string.cover_all,
-      onClick = eventHandler("cover everything") { state = state.copy(showOuterSheet = true) }
+  ): ButtonBar {
+    val name = if (top) "top" else "bottom"
+    return ButtonBar(
+      toggleInnerSheetButton(
+        name = name,
+        renderState = renderState,
+      ),
+      Button(
+        name = R.string.cover_all,
+        onClick = eventHandler("$name cover everything") {
+          state = state.copy(showOuterSheet = true)
+        }
+      )
     )
-  )
+  }
 
-  private fun RenderContext.toggleInnerSheetButton(renderState: State) =
+  private fun RenderContext.toggleInnerSheetButton(
+    name: String,
+    renderState: State
+  ) =
     Button(
       name = if (renderState.showInnerSheet) R.string.reveal_body else R.string.cover_body,
-      onClick = eventHandler("reveal / cover body") {
+      onClick = eventHandler("$name: reveal / cover body") {
         state = state.copy(showInnerSheet = !state.showInnerSheet)
       }
     )