[With nonSkippingGroupOptimization feature enabled]

The following code,

@Composable
fun Test(level: Int) {
    Wrap {
        if (level > 0) {
            used(remember { "Before" })
            Wrap {
                used(remember { "Middle" })
            }
            used(remember { "End" })
        }
    }
}

does not produce a group around the if statement.

This code produces,

@Composable
fun Test(level: Int, %composer: Composer?, %changed: Int) {
  %composer = %composer.startRestartGroup(<>)
  val %dirty = %changed
  if (%changed and 0b0110 == 0) {
    %dirty = %dirty or if (%composer.changed(level)) 0b0100 else 0b0010
  }
  if (%dirty and 0b0011 != 0b0010 || !%composer.skipping) {
    Wrap(rememberComposableLambda(<>, true, { %composer: Composer?, %changed: Int ->
      if (%changed and 0b0011 != 0b0010 || !%composer.skipping) {
        if (level > 0) {
          used(<block>{
            %composer.cache(false) {
              "Before"
            }
          })
          Wrap(ComposableSingletons%TestKt.lambda-1, %composer, 0b0110)
          used(<block>{
            %composer.cache(false) {
              "End"
            }
          })
        }
      } else {
        %composer.skipToGroupEnd()
      }
    }, %composer, 0b00110110), %composer, 0b0110)
  } else {
    %composer.skipToGroupEnd()
  }
  %composer.endRestartGroup()?.updateScope { %composer: Composer?, %force: Int ->
    Test(level, %composer, updateChangedFlags(%changed or 0b0001))
  }
}

but should produce,

@Composable
fun Test(level: Int, %composer: Composer?, %changed: Int) {
  %composer = %composer.startRestartGroup(<>)
  val %dirty = %changed
  if (%changed and 0b0110 == 0) {
    %dirty = %dirty or if (%composer.changed(level)) 0b0100 else 0b0010
  }
  if (%dirty and 0b0011 != 0b0010 || !%composer.skipping) {
    Wrap(rememberComposableLambda(<>, true, { %composer: Composer?, %changed: Int ->
      if (%changed and 0b0011 != 0b0010 || !%composer.skipping) {
        if (level > 0) {
          %composer.startReplaceGroup(<>)
          used(<block>{
            %composer.cache(false) {
              "Before"
            }
          })
          Wrap(ComposableSingletons%TestKt.lambda-1, %composer, 0b0110)
          used(<block>{
            %composer.cache(false) {
              "End"
            }
          })
          %composer.endReplaceGroup()
        } else {
          %composer.startReplaceGroup(<>)
          %composer.endReplaceGroup()
        }
      } else {
        %composer.skipToGroupEnd()
      }
    }, %composer, 0b00110110), %composer, 0b0110)
  } else {
    %composer.skipToGroupEnd()
  }
  %composer.endRestartGroup()?.updateScope { %composer: Composer?, %force: Int ->
    Test(level, %composer, updateChangedFlags(%changed or 0b0001))
  }
}

A non-unit returning function, like remember cannot be conditionally called in a group. That is, if the group executes, it must execute in a group that always exists if it is called and is removed when it isn't.

Without this group, the runtime will only detect that new content is being inserted into composition when the Wrap function is called. It currently will record the new remember calls but gets confused about what order to send the onRemember and onForgotten calls.