Resources. Don't return a cached value when pass new args.

The issue was because we cache the value in the current composition, and the next composition returns the cached value.

There weren't an issue if we just call one `stringResource` after another because those are different compositions.

Fixes https://github.com/JetBrains/compose-multiplatform/issues/4325

components/resources/library/src/blockingMain/kotlin/org/jetbrains/compose/resources/ResourceState.blocking.kt

@@ -5,12 +5,43 @@ import kotlinx.coroutines.runBlocking
 
 @Composable
 internal actual fun <T> rememberResourceState(
-    key: Any,
+    key1: Any,
     getDefault: () -> T,
     block: suspend (ResourceEnvironment) -> T
 ): State<T> {
     val environment = LocalComposeEnvironment.current.rememberEnvironment()
-    return remember(key, environment) {
+    return remember(key1, environment) {
+        mutableStateOf(
+            runBlocking { block(environment) }
+        )
+    }
+}
+
+@Composable
+internal actual fun <T> rememberResourceState(
+    key1: Any,
+    key2: Any,
+    getDefault: () -> T,
+    block: suspend (ResourceEnvironment) -> T
+): State<T> {
+    val environment = LocalComposeEnvironment.current.rememberEnvironment()
+    return remember(key1, key2, environment) {
+        mutableStateOf(
+            runBlocking { block(environment) }
+        )
+    }
+}
+
+@Composable
+internal actual fun <T> rememberResourceState(
+    key1: Any,
+    key2: Any,
+    key3: Any,
+    getDefault: () -> T,
+    block: suspend (ResourceEnvironment) -> T
+): State<T> {
+    val environment = LocalComposeEnvironment.current.rememberEnvironment()
+    return remember(key1, key2, key3, environment) {
         mutableStateOf(
             runBlocking { block(environment) }
         )

components/resources/library/src/commonMain/kotlin/org/jetbrains/compose/resources/ResourceState.kt

@@ -10,7 +10,34 @@ import androidx.compose.runtime.State
  */
 @Composable
 internal expect fun <T> rememberResourceState(
-    key: Any,
+    key1: Any,
+    getDefault: () -> T,
+    block: suspend (ResourceEnvironment) -> T
+): State<T>
+
+/**
+ * This is a platform-specific function that calculates and remembers a state.
+ * For all platforms except a JS it is a blocking function.
+ * On the JS platform it loads the state asynchronously and uses `getDefault` as an initial state value.
+ */
+@Composable
+internal expect fun <T> rememberResourceState(
+    key1: Any,
+    key2: Any,
+    getDefault: () -> T,
+    block: suspend (ResourceEnvironment) -> T
+): State<T>
+
+/**
+ * This is a platform-specific function that calculates and remembers a state.
+ * For all platforms except a JS it is a blocking function.
+ * On the JS platform it loads the state asynchronously and uses `getDefault` as an initial state value.
+ */
+@Composable
+internal expect fun <T> rememberResourceState(
+    key1: Any,
+    key2: Any,
+    key3: Any,
     getDefault: () -> T,
     block: suspend (ResourceEnvironment) -> T
 ): State<T>

components/resources/library/src/commonMain/kotlin/org/jetbrains/compose/resources/StringResources.kt

@@ -123,7 +123,7 @@ private suspend fun loadString(
 fun stringResource(resource: StringResource, vararg formatArgs: Any): String {
     val resourceReader = LocalResourceReader.current
     val args = formatArgs.map { it.toString() }
-    val str by rememberResourceState(resource, { "" }) { env ->
+    val str by rememberResourceState(resource, args, { "" }) { env ->
         loadString(resource, args, resourceReader, env)
     }
     return str

components/resources/library/src/commonTest/kotlin/org/jetbrains/compose/resources/ComposeResourceTest.kt

@@ -111,6 +111,29 @@ class ComposeResourceTest {
         assertEquals(listOf("item 1", "item 2", "item 3"), str_arr)
     }
 
+    // https://github.com/JetBrains/compose-multiplatform/issues/4325
+    @Test
+    fun testReadStringFromDifferentArgs() = runComposeUiTest {
+        var arg by mutableStateOf(42)
+        var str1 = ""
+        var str2 = ""
+        setContent {
+            CompositionLocalProvider(LocalComposeEnvironment provides TestComposeEnvironment) {
+                str1 = stringResource(TestStringResource("str_template"), "test1", arg)
+                str2 = stringResource(TestStringResource("str_template"), "test2", arg)
+            }
+        }
+
+        waitForIdle()
+        assertEquals("Hello, test1! You have 42 new messages.", str1)
+        assertEquals("Hello, test2! You have 42 new messages.", str2)
+
+        arg = 31415
+        waitForIdle()
+        assertEquals("Hello, test1! You have 31415 new messages.", str1)
+        assertEquals("Hello, test2! You have 31415 new messages.", str2)
+    }
+
     @Test
     fun testLoadStringResource() = runTest {
         assertEquals("Compose Resources App", getString(TestStringResource("app_name")))

components/resources/library/src/skikoMain/kotlin/org/jetbrains/compose/resources/FontResources.skiko.kt

@@ -33,7 +33,7 @@ private val defaultEmptyFont by lazy { Font("org.jetbrains.compose.emptyFont", B
 @Composable
 actual fun Font(resource: FontResource, weight: FontWeight, style: FontStyle): Font {
     val resourceReader = LocalResourceReader.current
-    val fontFile by rememberResourceState(resource, { defaultEmptyFont }) { env ->
+    val fontFile by rememberResourceState(resource, weight, style, { defaultEmptyFont }) { env ->
         val path = resource.getPathByEnvironment(env)
         val fontBytes = resourceReader.read(path)
         Font(path, fontBytes, weight, style)

components/resources/library/src/webMain/kotlin/org/jetbrains/compose/resources/ResourceState.web.kt

@@ -8,13 +8,44 @@ import androidx.compose.runtime.remember
 
 @Composable
 internal actual fun <T> rememberResourceState(
-    key: Any,
+    key1: Any,
     getDefault: () -> T,
     block: suspend (ResourceEnvironment) -> T
 ): State<T> {
     val environment = LocalComposeEnvironment.current.rememberEnvironment()
-    val state = remember(key) { mutableStateOf(getDefault()) }
-    LaunchedEffect(key) {
+    val state = remember(key1) { mutableStateOf(getDefault()) }
+    LaunchedEffect(key1) {
+        state.value = block(environment)
+    }
+    return state
+}
+
+@Composable
+internal actual fun <T> rememberResourceState(
+    key1: Any,
+    key2: Any,
+    getDefault: () -> T,
+    block: suspend (ResourceEnvironment) -> T
+): State<T> {
+    val environment = LocalComposeEnvironment.current.rememberEnvironment()
+    val state = remember(key1, key2) { mutableStateOf(getDefault()) }
+    LaunchedEffect(key1, key2) {
+        state.value = block(environment)
+    }
+    return state
+}
+
+@Composable
+internal actual fun <T> rememberResourceState(
+    key1: Any,
+    key2: Any,
+    key3: Any,
+    getDefault: () -> T,
+    block: suspend (ResourceEnvironment) -> T
+): State<T> {
+    val environment = LocalComposeEnvironment.current.rememberEnvironment()
+    val state = remember(key1, key2, key3) { mutableStateOf(getDefault()) }
+    LaunchedEffect(key1, key2, key3) {
         state.value = block(environment)
     }
     return state