When there are multiple focus modifiers (e.g. onFocusChanged) on a focus target, and all the modifiers are removed along with the target, only the lowest (closest to the target) modifier gets the event. I believe this is a regression introduced with the migration of the focus system to modifier locals, for a case that it seems we never had tests for.

The situation is when there are multiple focus event modifiers listening to a single focus target, and all the event modifiers as well as the target are removed/detached at the same time. What should happen, I think, and based on talking to @Ralston Da Silva, is that all the event modifiers should get the final "focus=Inactive" event. But what is happening is:

The focus event modifiers all get the onModifierLocalsUpdated call first, in which they all remove themselves from the listener chain.
The focus target modifier gets the onModifierLocalUpdated, in which it asks the focus manager to clear focus.
The focus=Inactive event is delivered to the first focus event modifier, which in many cases is the one internal to focusable().
The event is not propagated to any other listeners since they've all been removed from the listener chain. More specifically, when the first focus event modifier tries to propagate to its parent, its parent is null, so it doesn't propagate.

I believe this regression caused a text field bug, b/225541817, in which the focus event modifiers applied by CoreTextField no longer receive that final "focus=Inactive" event and so don't hide the keyboard.

Reproducing test:

// Arrange.
var focusableContentPresent by mutableStateOf(true)
val focusRequester = FocusRequester()
var parentHasFocus = false
var childHasFocus = false
rule.setFocusableContent {
    if (focusableContentPresent) {
        Box(
            modifier = Modifier
                .onFocusChanged { parentHasFocus = it.hasFocus }
                .onFocusChanged { childHasFocus = it.hasFocus }
                .focusRequester(focusRequester)
                .focusTarget()
        )
    }
}
rule.runOnIdle {
    focusRequester.requestFocus()
    assertThat(parentHasFocus).isTrue()
    assertThat(childHasFocus).isTrue()
}

// Act.
focusableContentPresent = false

// Assert.
rule.runOnIdle {
    assertThat(parentHasFocus).isFalse()
    assertThat(childHasFocus).isFalse()
}