Add ResourceContentHash annotation to generated resource accessors (#5357)

Used by Compose Hot Reload to mark a related accessor as dirty if the
hash is changed after reloading of new accessors.

Fixes [CMP-8513](https://youtrack.jetbrains.com/issue/CMP-8513)

## Release Notes
N/A

Author: pjBooms

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

@@ -0,0 +1,5 @@
+package org.jetbrains.compose.resources
+
+@Suppress("unused")
+@Retention(AnnotationRetention.BINARY)
+annotation class ResourceContentHash(val hash: Int)

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources/GenerateResourceAccessorsTask.kt

@@ -110,7 +110,15 @@ internal abstract class GenerateResourceAccessorsTask : IdeaImportTask() {
         }
 
         val type = ResourceType.fromString(typeString) ?: error("Unknown resource type: '$typeString'.")
-        return listOf(ResourceItem(type, qualifiers, file.nameWithoutExtension.asUnderscoredIdentifier(), path))
+        return listOf(
+            ResourceItem(
+                type,
+                qualifiers,
+                file.nameWithoutExtension.asUnderscoredIdentifier(),
+                path,
+                file.readBytes().contentHashCode()
+            )
+        )
     }
 
     private fun getValueResourceItems(dataFile: File, qualifiers: List<String>, path: Path): List<ResourceItem> {
@@ -141,7 +149,15 @@ internal abstract class GenerateResourceAccessorsTask : IdeaImportTask() {
         path: Path
     ): ResourceItem {
         val record = ValueResourceRecord.createFromString(recordString)
-        return ResourceItem(record.type, qualifiers, record.key.asUnderscoredIdentifier(), path, offset, size)
+        return ResourceItem(
+            record.type,
+            qualifiers,
+            record.key.asUnderscoredIdentifier(),
+            path,
+            record.content.hashCode(),
+            offset,
+            size
+        )
     }
 }
 

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/resources/GeneratedResClassSpec.kt

@@ -39,6 +39,7 @@ internal data class ResourceItem(
     val qualifiers: List<String>,
     val name: String,
     val path: Path,
+    val contentHash: Int,
     val offset: Long = -1,
     val size: Long = -1,
 )
@@ -58,6 +59,8 @@ private val resourceItemClass = ClassName("org.jetbrains.compose.resources", "Re
 private val internalAnnotationClass = ClassName("org.jetbrains.compose.resources", "InternalResourceApi")
 private val internalAnnotation = AnnotationSpec.builder(internalAnnotationClass).build()
 
+private val resourceContentHashAnnotationClass = ClassName("org.jetbrains.compose.resources", "ResourceContentHash")
+
 private fun CodeBlock.Builder.addQualifiers(resourceItem: ResourceItem): CodeBlock.Builder {
     val languageQualifier = ClassName("org.jetbrains.compose.resources", "LanguageQualifier")
     val regionQualifier = ClassName("org.jetbrains.compose.resources", "RegionQualifier")
@@ -283,11 +286,18 @@ private fun getChunkFileSpec(
                 .endControlFlow()
                 .build()
 
-            val accessor = PropertySpec.builder(resName, type.getClassName(), resModifier)
+            val accessorBuilder = PropertySpec.builder(resName, type.getClassName(), resModifier)
                 .receiver(ClassName(packageName, resClassName, type.accessorName))
                 .delegate(initializer)
-                .build()
-            chunkFile.addProperty(accessor)
+            if (System.getProperty("compose.resources.generate.ResourceContentHash.annotation") == "true") {
+                accessorBuilder.addAnnotation(
+                    AnnotationSpec.builder(resourceContentHashAnnotationClass)
+                        .useSiteTarget(AnnotationSpec.UseSiteTarget.DELEGATE)
+                        .addMember("%L", items.fold(0) { acc, item -> ((acc * 31) + item.contentHash) })
+                        .build()
+                )
+            }
+            chunkFile.addProperty(accessorBuilder.build())
         }
 
         //__collect${chunkClassName}Resources function

gradle-plugins/compose/src/test/kotlin/org/jetbrains/compose/test/tests/integration/ResourcesTest.kt

@@ -578,6 +578,26 @@ class ResourcesTest : GradlePluginTestBase() {
         }
     }
 
+    @Test
+    fun testGeneratedAccessorsAnnotatedWithResourceContentHash(): Unit = with(testProject("misc/commonResources")) {
+        //check generated resource's accessors
+        gradle("prepareKotlinIdeaImport", "-Dcompose.resources.generate.ResourceContentHash.annotation=true").checks {
+            val expected = if (System.getProperty("os.name").lowercase().contains("windows")) {
+                // Windows has different line endings in comparison with Unixes,
+                // thus the XML resource files differ and produce different content hashes,
+                // so we have different test data for it.
+                file("expected-with-hash-windows")
+            } else {
+                file("expected-with-hash")
+            }
+
+            assertDirectoriesContentEquals(
+                file("build/generated/compose/resourceGenerator/kotlin"),
+                expected
+            )
+        }
+    }
+
     @Test
     fun testJvmOnlyProject(): Unit = with(testProject("misc/jvmOnlyResources")) {
         gradle("jar").checks {

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected-with-hash-windows/androidMainResourceAccessors/app/group/resources_test/generated/resources/String0.androidMain.kt

@@ -0,0 +1,25 @@
+@file:OptIn(InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.MutableMap
+import org.jetbrains.compose.resources.InternalResourceApi
+import org.jetbrains.compose.resources.ResourceContentHash
+import org.jetbrains.compose.resources.ResourceItem
+import org.jetbrains.compose.resources.StringResource
+
+private const val MD: String = "composeResources/app.group.resources_test.generated.resources/"
+
+@delegate:ResourceContentHash(50_967_853)
+internal val Res.string.android_str: StringResource by lazy {
+      StringResource("string:android_str", "android_str", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.androidMain.cvr", 10, 39),
+      ))
+    }
+
+@InternalResourceApi
+internal fun _collectAndroidMainString0Resources(map: MutableMap<String, StringResource>) {
+  map.put("android_str", Res.string.android_str)
+}

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected-with-hash-windows/androidMainResourceCollectors/app/group/resources_test/generated/resources/ActualResourceCollectors.kt

@@ -0,0 +1,42 @@
+@file:OptIn(org.jetbrains.compose.resources.InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.Map
+import org.jetbrains.compose.resources.DrawableResource
+import org.jetbrains.compose.resources.FontResource
+import org.jetbrains.compose.resources.PluralStringResource
+import org.jetbrains.compose.resources.StringArrayResource
+import org.jetbrains.compose.resources.StringResource
+
+internal actual val Res.allDrawableResources: Map<String, DrawableResource> by lazy {
+  val map = mutableMapOf<String, DrawableResource>()
+  _collectCommonMainDrawable0Resources(map)
+  return@lazy map
+}
+
+internal actual val Res.allStringResources: Map<String, StringResource> by lazy {
+  val map = mutableMapOf<String, StringResource>()
+  _collectAndroidMainString0Resources(map)
+  _collectCommonMainString0Resources(map)
+  return@lazy map
+}
+
+internal actual val Res.allStringArrayResources: Map<String, StringArrayResource> by lazy {
+  val map = mutableMapOf<String, StringArrayResource>()
+  return@lazy map
+}
+
+internal actual val Res.allPluralStringResources: Map<String, PluralStringResource> by lazy {
+  val map = mutableMapOf<String, PluralStringResource>()
+  _collectCommonMainPlurals0Resources(map)
+  return@lazy map
+}
+
+internal actual val Res.allFontResources: Map<String, FontResource> by lazy {
+  val map = mutableMapOf<String, FontResource>()
+  _collectCommonMainFont0Resources(map)
+  return@lazy map
+}

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected-with-hash-windows/commonMainResourceAccessors/app/group/resources_test/generated/resources/Drawable0.commonMain.kt

@@ -0,0 +1,64 @@
+@file:OptIn(InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.MutableMap
+import org.jetbrains.compose.resources.DrawableResource
+import org.jetbrains.compose.resources.InternalResourceApi
+import org.jetbrains.compose.resources.LanguageQualifier
+import org.jetbrains.compose.resources.RegionQualifier
+import org.jetbrains.compose.resources.ResourceContentHash
+import org.jetbrains.compose.resources.ResourceItem
+import org.jetbrains.compose.resources.ThemeQualifier
+
+private const val MD: String = "composeResources/app.group.resources_test.generated.resources/"
+
+@delegate:ResourceContentHash(-1_453_679_588)
+internal val Res.drawable._3_strange_name: DrawableResource by lazy {
+      DrawableResource("drawable:_3_strange_name", setOf(
+        ResourceItem(setOf(), "${MD}drawable/3-strange-name.xml", -1, -1),
+      ))
+    }
+
+@delegate:ResourceContentHash(-1_453_679_588)
+internal val Res.drawable.camelCaseName: DrawableResource by lazy {
+      DrawableResource("drawable:camelCaseName", setOf(
+        ResourceItem(setOf(), "${MD}drawable/camelCaseName.xml", -1, -1),
+      ))
+    }
+
+@delegate:ResourceContentHash(-1_453_679_588)
+internal val Res.drawable.`is`: DrawableResource by lazy {
+      DrawableResource("drawable:is", setOf(
+        ResourceItem(setOf(), "${MD}drawable/is.xml", -1, -1),
+      ))
+    }
+
+@delegate:ResourceContentHash(-737_454_820)
+internal val Res.drawable.vector: DrawableResource by lazy {
+      DrawableResource("drawable:vector", setOf(
+        ResourceItem(setOf(LanguageQualifier("ast"), ), "${MD}drawable-ast/vector.xml", -1, -1),
+        ResourceItem(setOf(LanguageQualifier("au"), RegionQualifier("US"), ), "${MD}drawable-au-rUS/vector.xml", -1, -1),
+        ResourceItem(setOf(ThemeQualifier.DARK, LanguageQualifier("ge"), ), "${MD}drawable-dark-ge/vector.xml", -1, -1),
+        ResourceItem(setOf(LanguageQualifier("en"), ), "${MD}drawable-en/vector.xml", -1, -1),
+        ResourceItem(setOf(), "${MD}drawable/vector.xml", -1, -1),
+      ))
+    }
+
+@delegate:ResourceContentHash(-1_453_679_588)
+internal val Res.drawable.vector_2: DrawableResource by lazy {
+      DrawableResource("drawable:vector_2", setOf(
+        ResourceItem(setOf(), "${MD}drawable/vector_2.xml", -1, -1),
+      ))
+    }
+
+@InternalResourceApi
+internal fun _collectCommonMainDrawable0Resources(map: MutableMap<String, DrawableResource>) {
+  map.put("_3_strange_name", Res.drawable._3_strange_name)
+  map.put("camelCaseName", Res.drawable.camelCaseName)
+  map.put("is", Res.drawable.`is`)
+  map.put("vector", Res.drawable.vector)
+  map.put("vector_2", Res.drawable.vector_2)
+}

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected-with-hash-windows/commonMainResourceAccessors/app/group/resources_test/generated/resources/Font0.commonMain.kt

@@ -0,0 +1,27 @@
+@file:OptIn(InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.MutableMap
+import org.jetbrains.compose.resources.FontResource
+import org.jetbrains.compose.resources.InternalResourceApi
+import org.jetbrains.compose.resources.LanguageQualifier
+import org.jetbrains.compose.resources.ResourceContentHash
+import org.jetbrains.compose.resources.ResourceItem
+
+private const val MD: String = "composeResources/app.group.resources_test.generated.resources/"
+
+@delegate:ResourceContentHash(1_893_715_104)
+internal val Res.font.emptyFont: FontResource by lazy {
+      FontResource("font:emptyFont", setOf(
+        ResourceItem(setOf(LanguageQualifier("en"), ), "${MD}font-en/emptyFont.otf", -1, -1),
+        ResourceItem(setOf(), "${MD}font/emptyFont.otf", -1, -1),
+      ))
+    }
+
+@InternalResourceApi
+internal fun _collectCommonMainFont0Resources(map: MutableMap<String, FontResource>) {
+  map.put("emptyFont", Res.font.emptyFont)
+}

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected-with-hash-windows/commonMainResourceAccessors/app/group/resources_test/generated/resources/Plurals0.commonMain.kt

@@ -0,0 +1,25 @@
+@file:OptIn(InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.MutableMap
+import org.jetbrains.compose.resources.InternalResourceApi
+import org.jetbrains.compose.resources.PluralStringResource
+import org.jetbrains.compose.resources.ResourceContentHash
+import org.jetbrains.compose.resources.ResourceItem
+
+private const val MD: String = "composeResources/app.group.resources_test.generated.resources/"
+
+@delegate:ResourceContentHash(-199_361_196)
+internal val Res.plurals.numberOfSongsAvailable: PluralStringResource by lazy {
+      PluralStringResource("plurals:numberOfSongsAvailable", "numberOfSongsAvailable", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 10, 124),
+      ))
+    }
+
+@InternalResourceApi
+internal fun _collectCommonMainPlurals0Resources(map: MutableMap<String, PluralStringResource>) {
+  map.put("numberOfSongsAvailable", Res.plurals.numberOfSongsAvailable)
+}

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected-with-hash-windows/commonMainResourceAccessors/app/group/resources_test/generated/resources/String0.commonMain.kt

@@ -0,0 +1,81 @@
+@file:OptIn(InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import kotlin.String
+import kotlin.collections.MutableMap
+import org.jetbrains.compose.resources.InternalResourceApi
+import org.jetbrains.compose.resources.ResourceContentHash
+import org.jetbrains.compose.resources.ResourceItem
+import org.jetbrains.compose.resources.StringResource
+
+private const val MD: String = "composeResources/app.group.resources_test.generated.resources/"
+
+@delegate:ResourceContentHash(405_464_824)
+internal val Res.string.PascalCase: StringResource by lazy {
+      StringResource("string:PascalCase", "PascalCase", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 172, 34),
+      ))
+    }
+
+@delegate:ResourceContentHash(-1_118_290_776)
+internal val Res.string._1_kebab_case: StringResource by lazy {
+      StringResource("string:_1_kebab_case", "_1_kebab_case", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 135, 36),
+      ))
+    }
+
+@delegate:ResourceContentHash(64_828_505)
+internal val Res.string.app_name: StringResource by lazy {
+      StringResource("string:app_name", "app_name", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 207, 44),
+      ))
+    }
+
+@delegate:ResourceContentHash(211_426_861)
+internal val Res.string.camelCase: StringResource by lazy {
+      StringResource("string:camelCase", "camelCase", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 252, 29),
+      ))
+    }
+
+@delegate:ResourceContentHash(466_457_346)
+internal val Res.string.hello: StringResource by lazy {
+      StringResource("string:hello", "hello", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 282, 37),
+      ))
+    }
+
+@delegate:ResourceContentHash(-1_288_591_563)
+internal val Res.string.`info_using_release_$x`: StringResource by lazy {
+      StringResource("string:info_using_release_${'$'}x", "info_using_release_${'$'}x", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 320, 57),
+      ))
+    }
+
+@delegate:ResourceContentHash(-624_025_575)
+internal val Res.string.multi_line: StringResource by lazy {
+      StringResource("string:multi_line", "multi_line", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 378, 178),
+      ))
+    }
+
+@delegate:ResourceContentHash(-1_332_636_786)
+internal val Res.string.str_template: StringResource by lazy {
+      StringResource("string:str_template", "str_template", setOf(
+        ResourceItem(setOf(), "${MD}values/strings.commonMain.cvr", 557, 76),
+      ))
+    }
+
+@InternalResourceApi
+internal fun _collectCommonMainString0Resources(map: MutableMap<String, StringResource>) {
+  map.put("PascalCase", Res.string.PascalCase)
+  map.put("_1_kebab_case", Res.string._1_kebab_case)
+  map.put("app_name", Res.string.app_name)
+  map.put("camelCase", Res.string.camelCase)
+  map.put("hello", Res.string.hello)
+  map.put("info_using_release_${'$'}x", Res.string.`info_using_release_$x`)
+  map.put("multi_line", Res.string.multi_line)
+  map.put("str_template", Res.string.str_template)
+}