IssueTracker

I have find a sample code to reproduce that

        setContent {
            val dialogState = remember { DialogState() }
            dialogState.Intercept()
            LaunchedEffect(Unit) {
                delay(1000)
                dialogState.bgWork {
                    delay(5000)
                }
                dialogState.showSelectActions {
                    onSelect("a") {

                    }
                    onSelect("b") {

                    }
                }
            }
        }

You can find implementation of DialogState here https://github.com/FooIbar/EhViewer/blob/ef16bdeb755ae888c74eaa4a337bd5b708fcc97e/app/src/main/kotlin/com/hippo/ehviewer/ui/tools/Dialog.kt#L92
https://github.com/FooIbar/EhViewer/blob/main/app/src/main/kotlin/com/hippo/ehviewer/util/Progress.kt Launch that Activity, wait 6 seconds and it will crash

Let me sort it out

The first crash
Reproduce: navigate to a gallery and navigate back
The reason is we have some code assume the forget order of RememberObserver(DisposableEffect), and 52835066c9044647a65dfb566f03131aab46e793 changed the order. Seems this is a intended behaviour.
I will fix it from my side. My bad

The second crash
Reproduce: #4 comment
StackTrace: https://bin.kv2.dev/~65d5c6175de7ed6bfdbdf1bd
We got a wrong object from SlotTable during recompose

And interestingly, if we insert delay(1000) between two dialog suspend usage

                dialogState.bgWork {
                    delay(5000)
                }
                delay(1000)
                dialogState.showSelectActions {
                    onSelect("a") {

                    }
                    onSelect("b") {

                    }
                }

It will not crash

I tried cutting down the example myself and was not able to reproduce this.

The primary dependency chagnes I made were:

compose-material3 = { module = "androidx.compose.material3:material3", version = "1.3.0-SNAPSHOT" }
compose-foundation = { module = "androidx.compose.foundation:foundation-android", version = "1.7.0-SNAPSHOT" }

I only included the part of the Dialog.kt that was needed by the above,

class DialogState {
    var content: (@Composable () -> Unit)? by mutableStateOf(null)

    @Composable
    fun Intercept() = content?.invoke()

    fun dismiss() {
        content = null
    }

    suspend inline fun <R> dialog(crossinline block: @Composable (CancellableContinuation<R>) -> Unit) = suspendCancellableCoroutine<R> { cont ->
        cont.invokeOnCancellation { dismiss() }
        val realContinuation = object : CancellableContinuation<R> by cont {
            override fun resumeWith(result: Result<R>) {
                dismiss()
                cont.resumeWith(result)
            }
        }
        content = { block(realContinuation) }
    }

    suspend inline fun showSelectActions(
        title: String? = null,
        builder: ActionScope.() -> Unit,
    ) {
        val (items, actions) = buildList { builder(ActionScope { action, that -> add(action to that) }) }.unzip()
        val selected = showSelectItem(items, title)
        actions[selected].invoke()
    }

    suspend fun showSelectItem(
        items: List<String>,
        title: String?,
        respectDefaultWidth: Boolean = true,
    ): Int = showNoButton(respectDefaultWidth) {
        Column(modifier = Modifier.padding(vertical = 8.dp)) {
            if (title != null) {
                Text(
                    text = title,
                    modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
                    style = MaterialTheme.typography.headlineSmall,
                )
            }
            LazyColumn {
                itemsIndexed(items) { index, text ->
                    CompositionLocalProvider(LocalContentColor provides MaterialTheme.colorScheme.tertiary) {
                        Text(
                            text = text,
                            modifier = Modifier.clickable { dismissWith(index) }.fillMaxWidth()
                                .padding(horizontal = 24.dp, vertical = 16.dp),
                            style = MaterialTheme.typography.titleMedium,
                        )
                    }
                }
            }
        }
    }

    @OptIn(ExperimentalMaterial3Api::class)
    suspend fun <R> showNoButton(respectDefaultWidth: Boolean = true, block: @Composable DismissDialogScope<R>.() -> Unit): R {
        return dialog { cont ->
            val impl = remember(cont) {
                DismissDialogScope<R> {
                    cont.resume(it)
                }
            }
            BasicAlertDialog(
                onDismissRequest = { cont.cancel() },
                properties = DialogProperties(usePlatformDefaultWidth = respectDefaultWidth),
                content = {
                    Surface(
                        modifier = with(Modifier) { if (!respectDefaultWidth) defaultMinSize(280.dp) else width(280.dp) },
                        shape = AlertDialogDefaults.shape,
                        color = AlertDialogDefaults.containerColor,
                        tonalElevation = AlertDialogDefaults.TonalElevation,
                        content = { block(impl) },
                    )
                },
            )
        }
    }
}

fun interface ActionScope {
    fun onSelect(action: String, that: suspend () -> Unit)
}

fun interface DismissDialogScope<R> {
    fun dismissWith(value: R)
}

This shows the "Please wait" and then selection between "a" and "b" as I expected.

This requires compose compiler 1.5.11-dev-k2.0.0-Beta4-21f5e479a96
I will upload a sample project soon

https://github.com/VDostoyevskiy/Sample
Downgrade snapshot to build-11461852 or downgrade compiler to stable will fix it
StackTrace below: https://bin.kv2.dev/~65d6da925de7ed6bfdbdfe3e

Any update on this?
Have you reproduced this with https://github.com/VDostoyevskiy/Sample ?

Sorry! I didn't see you updated this. I must have missed the notification. Trying now.

I have the exception reproducing locally, investigating.

The issue is in the call to dialog when it inlines the crossinline lambda. This lambda instances are getting the same key at both call sights and, when the second dialog shows, it believes it is recomposing the first and then throws as it didn't create the state in this slot table.

The simple work-around now is to change dialog's parameter to noinline instead of crossinline. This ensures that the keys produced for the lambdas are different.

I am investigating what change caused this.

The code generation for crossinline lambda seems to have always been wrong but the extra groups the compiler create that the change removes prevented crashes in most cases. By removing otherwise unnecessary groups, the missing group around a crossinline lambda now causes a crash.

The work-around above, changing the lambda to noinline, is valid because it avoids crossinline and, therefore, avoids the crash.

The key symptom is that currentComposer.inserting is never true for the crossinline lambda passed into the second dialog which indicates it is recomposing over state it didn't produce.

A group is required because a crossinline lambda can be inlined into a lambda instance. The instance created gets the same key but its content has effectively changed as the crossinline lambda acts as a branch point. The runtime assumes that when a different branch of code is executed, it executes in a block with a different key than the previous branch taken. As there is no branch group, the code is recomposed over state it didn't create, which is never valid. Recomposing over state it didn't create will not always create an exception and this was the case for the code generated prior to enabling the optimization to remove otherwise unnecessary groups.

The following release(s) address this bug.It is possible this bug has only been partially addressed:

• androidx.compose.compiler:compiler-hosted:1.5.11