Fix resource accessors compilation when there are huge number of resource files. (#4294)

Instead of object properties there are being generated extension
properties in different files.

fixes https://github.com/JetBrains/compose-multiplatform/issues/4285

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

@@ -56,7 +56,7 @@ internal abstract class GenerateResClassTask : DefaultTask() {
                     }
                     .groupBy { it.type }
                     .mapValues { (_, items) -> items.groupBy { it.name } }
-                getResFileSpec(resources, packageName.get()).writeTo(kotlinDir)
+                getResFileSpecs(resources, packageName.get()).forEach { it.writeTo(kotlinDir) }
             } else {
                 logger.info("Generation Res class is disabled")
             }

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

@@ -1,9 +1,9 @@
 package org.jetbrains.compose.resources
 
 import com.squareup.kotlinpoet.*
+import org.jetbrains.compose.internal.utils.uppercaseFirstChar
 import java.nio.file.Path
-import java.util.SortedMap
-import java.util.TreeMap
+import java.util.*
 import kotlin.io.path.invariantSeparatorsPathString
 
 internal enum class ResourceType(val typeName: String) {
@@ -35,6 +35,9 @@ private fun ResourceType.getClassName(): ClassName = when (this) {
 }
 
 private val resourceItemClass = ClassName("org.jetbrains.compose.resources", "ResourceItem")
+private val experimentalAnnotation = AnnotationSpec.builder(
+    ClassName("org.jetbrains.compose.resources", "ExperimentalResourceApi")
+).build()
 
 private fun CodeBlock.Builder.addQualifiers(resourceItem: ResourceItem): CodeBlock.Builder {
     val languageQualifier = ClassName("org.jetbrains.compose.resources", "LanguageQualifier")
@@ -101,33 +104,35 @@ private fun CodeBlock.Builder.addQualifiers(resourceItem: ResourceItem): CodeBlo
     return this
 }
 
-internal fun getResFileSpec(
+// We need to divide accessors by different files because
+//
+// if all accessors are generated in a single object
+// then a build may fail with: org.jetbrains.org.objectweb.asm.MethodTooLargeException: Method too large: Res$drawable.<clinit> ()V
+// e.g. https://github.com/JetBrains/compose-multiplatform/issues/4285
+//
+// if accessor initializers are extracted from the single object but located in the same file
+// then a build may fail with: org.jetbrains.org.objectweb.asm.ClassTooLargeException: Class too large: Res$drawable
+private const val ITEMS_PER_FILE_LIMIT = 500
+internal fun getResFileSpecs(
     //type -> id -> items
     resources: Map<ResourceType, Map<String, List<ResourceItem>>>,
     packageName: String
-): FileSpec =
-    FileSpec.builder(packageName, "Res").apply {
-        addAnnotation(
+): List<FileSpec> {
+    val files = mutableListOf<FileSpec>()
+    val resClass = FileSpec.builder(packageName, "Res").also { file ->
+        file.addAnnotation(
             AnnotationSpec.builder(ClassName("kotlin", "OptIn"))
                 .addMember("org.jetbrains.compose.resources.InternalResourceApi::class")
                 .addMember("org.jetbrains.compose.resources.ExperimentalResourceApi::class")
                 .build()
         )
-
-        //we need to sort it to generate the same code on different platforms
-        val sortedResources = sortResources(resources)
-
-        addType(TypeSpec.objectBuilder("Res").apply {
-            addModifiers(KModifier.INTERNAL)
-            addAnnotation(
-                AnnotationSpec.builder(
-                    ClassName("org.jetbrains.compose.resources", "ExperimentalResourceApi")
-                ).build()
-            )
+        file.addType(TypeSpec.objectBuilder("Res").also { resObject ->
+            resObject.addModifiers(KModifier.INTERNAL)
+            resObject.addAnnotation(experimentalAnnotation)
 
             //readFileBytes
             val readResourceBytes = MemberName("org.jetbrains.compose.resources", "readResourceBytes")
-            addFunction(
+            resObject.addFunction(
                 FunSpec.builder("readBytes")
                     .addKdoc(
                         """
@@ -145,48 +150,51 @@ internal fun getResFileSpec(
                     .addStatement("return %M(path)", readResourceBytes) //todo: add module ID here
                     .build()
             )
-            val types = sortedResources.map { (type, idToResources) ->
-                getResourceTypeObject(type, idToResources)
+            ResourceType.values().forEach { type ->
+                resObject.addType(TypeSpec.objectBuilder(type.typeName).build())
             }
-            addTypes(types)
         }.build())
+    }.build()
+    files.add(resClass)
+
+    //we need to sort it to generate the same code on different platforms
+    sortResources(resources).forEach { (type, idToResources) ->
+        val chunks = idToResources.keys.chunked(ITEMS_PER_FILE_LIMIT)
 
-        sortedResources
-            .flatMap { (type, idToResources) ->
-                idToResources.map { (name, items) ->
-                    getResourceInitializer(name, type, items)
+        chunks.forEachIndexed { index, ids ->
+            files.add(
+                getChunkFileSpec(type, index, packageName, idToResources.subMap(ids.first(), true, ids.last(), true))
+            )
         }
     }
-            .forEach { addFunction(it) }
-    }.build()
 
-private fun getterName(resourceType: ResourceType, resourceName: String): String =
-    "get_${resourceType.typeName}_$resourceName"
-
-private fun getResourceTypeObject(type: ResourceType, nameToResources: Map<String, List<ResourceItem>>) =
-    TypeSpec.objectBuilder(type.typeName).apply {
-        nameToResources.keys
-            .forEach { name ->
-                addProperty(
-                    PropertySpec
-                        .builder(name, type.getClassName())
-                        .initializer(getterName(type, name) + "()")
+    return files
+}
+
+private fun getChunkFileSpec(
+    type: ResourceType,
+    index: Int,
+    packageName: String,
+    idToResources: Map<String, List<ResourceItem>>
+): FileSpec {
+    val chunkClassName = type.typeName.uppercaseFirstChar() + index
+    return FileSpec.builder(packageName, chunkClassName).also { chunkFile ->
+        chunkFile.addAnnotation(
+            AnnotationSpec.builder(ClassName("kotlin", "OptIn"))
+                .addMember("org.jetbrains.compose.resources.InternalResourceApi::class")
                 .build()
         )
-            }
-    }.build()
 
-private fun getResourceInitializer(name: String, type: ResourceType, items: List<ResourceItem>): FunSpec {
-    val propertyTypeName = type.getClassName()
-    val resourceId = "${type}:${name}"
-    return FunSpec.builder(getterName(type, name))
-        .addModifiers(KModifier.PRIVATE)
-        .returns(propertyTypeName)
-        .addStatement(
+        val objectSpec = TypeSpec.objectBuilder(chunkClassName).also { typeObject ->
+            typeObject.addModifiers(KModifier.PRIVATE)
+            typeObject.addAnnotation(experimentalAnnotation)
+            val properties = idToResources.map { (resName, items) ->
+                PropertySpec.builder(resName, type.getClassName())
+                    .initializer(
                         CodeBlock.builder()
-                .add("return %T(\n", propertyTypeName).withIndent {
-                    add("\"$resourceId\",")
-                    if (type == ResourceType.STRING) add(" \"$name\",")
+                            .add("%T(\n", type.getClassName()).withIndent {
+                                add("\"${type}:${resName}\",")
+                                if (type == ResourceType.STRING) add(" \"$resName\",")
                                 withIndent {
                                     add("\nsetOf(\n").withIndent {
                                         items.forEach { item ->
@@ -204,6 +212,20 @@ private fun getResourceInitializer(name: String, type: ResourceType, items: List
                             .build().toString()
                     )
                     .build()
+            }
+            typeObject.addProperties(properties)
+        }.build()
+        chunkFile.addType(objectSpec)
+
+        idToResources.keys.forEach { resName ->
+            val accessor = PropertySpec.builder(resName, type.getClassName(), KModifier.INTERNAL)
+                .receiver(ClassName(packageName, "Res", type.typeName))
+                .addAnnotation(experimentalAnnotation)
+                .getter(FunSpec.getterBuilder().addStatement("return $chunkClassName.$resName").build())
+                .build()
+            chunkFile.addProperty(accessor)
+        }
+    }.build()
 }
 
 private fun sortResources(

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

@@ -4,6 +4,7 @@ import org.jetbrains.compose.test.utils.*
 import org.junit.jupiter.api.Test
 import java.io.File
 import java.util.zip.ZipFile
+import kotlin.io.path.relativeTo
 import kotlin.test.*
 
 class ResourcesTest : GradlePluginTestBase() {
@@ -11,9 +12,9 @@ class ResourcesTest : GradlePluginTestBase() {
     fun testGeneratedAccessors(): Unit = with(testProject("misc/commonResources")) {
         //check generated resource's accessors
         gradle("generateComposeResClass").checks {
-            assertEqualTextFiles(
-                file("build/generated/compose/resourceGenerator/kotlin/app/group/resources_test/generated/resources/Res.kt"),
-                file("expected/Res.kt")
+            assertDirectoriesContentEquals(
+                file("build/generated/compose/resourceGenerator/kotlin/app/group/resources_test/generated/resources"),
+                file("expected")
             )
         }
 
@@ -23,8 +24,8 @@ class ResourcesTest : GradlePluginTestBase() {
         )
         gradle("generateComposeResClass").checks {
             assertNotEqualTextFiles(
-                file("build/generated/compose/resourceGenerator/kotlin/app/group/resources_test/generated/resources/Res.kt"),
-                file("expected/Res.kt")
+                file("build/generated/compose/resourceGenerator/kotlin/app/group/resources_test/generated/resources/Drawable0.kt"),
+                file("expected/Drawable0.kt")
             )
         }
 
@@ -123,6 +124,12 @@ class ResourcesTest : GradlePluginTestBase() {
         file("src/commonMain/composeResources/drawable/vector_3.xml").renameTo(
             file("src/commonMain/composeResources/drawable/vector_2.xml")
         )
+        gradle("generateComposeResClass").checks {
+            assertDirectoriesContentEquals(
+                file("build/generated/compose/resourceGenerator/kotlin/app/group/resources_test/generated/resources"),
+                file("expected")
+            )
+        }
     }
 
     @Test
@@ -271,9 +278,9 @@ class ResourcesTest : GradlePluginTestBase() {
     @Test
     fun testEmptyResClass(): Unit = with(testProject("misc/emptyResources")) {
         gradle("generateComposeResClass").checks {
-            assertEqualTextFiles(
-                file("build/generated/compose/resourceGenerator/kotlin/app/group/empty_res/generated/resources/Res.kt"),
-                file("expected/Res.kt")
+            assertDirectoriesContentEquals(
+                file("build/generated/compose/resourceGenerator/kotlin/app/group/empty_res/generated/resources"),
+                file("expected")
             )
         }
     }
@@ -281,96 +288,30 @@ class ResourcesTest : GradlePluginTestBase() {
     @Test
     fun testJvmOnlyProject(): Unit = with(testProject("misc/jvmOnlyResources")) {
         gradle("generateComposeResClass").checks {
-            assertEqualTextFiles(
-                file("build/generated/compose/resourceGenerator/kotlin/me/app/jvmonlyresources/generated/resources/Res.kt"),
-                file("expected/Res.kt")
+            assertDirectoriesContentEquals(
+                file("build/generated/compose/resourceGenerator/kotlin/me/app/jvmonlyresources/generated/resources"),
+                file("expected")
             )
         }
         gradle("jar")
     }
 
     //https://github.com/JetBrains/compose-multiplatform/issues/4194
+    //https://github.com/JetBrains/compose-multiplatform/issues/4285
+    //
+    // 25_000 icons + 25_000 strings!!!
     @Test
-    fun testHugeNumberOfStrings(): Unit = with(
-        //disable cache for the test because the generateStringFiles task doesn't support it
-        testProject("misc/commonResources", defaultTestEnvironment.copy(useGradleConfigurationCache = false))
+    fun testHugeNumberOfResources(): Unit = with(
+        //disable cache for the test because the generateResourceFiles task doesn't support it
+        testProject("misc/hugeResources", defaultTestEnvironment.copy(useGradleConfigurationCache = false))
     ) {
-        file("build.gradle.kts").let { f ->
-            val originText = f.readText()
-            f.writeText(
-                buildString {
-                    appendLine("import java.util.Locale")
-                    append(originText)
-                    appendLine()
-                    append("""
-                        val template = ""${'"'}
-                            <resources>
-                                <string name="app_name">Compose Resources App</string>
-                                <string name="hello">😊 Hello world!</string>
-                                <string name="multi_line">Lorem ipsum dolor sit amet,
-                                    consectetur adipiscing elit.
-                                    Donec eget turpis ac sem ultricies consequat.</string>
-                                <string name="str_template">Hello, %1${'$'}{"$"}s! You have %2${'$'}{"$"}d new messages.</string>
-                                <string-array name="str_arr">
-                                    <item>item 1</item>
-                                    <item>item 2</item>
-                                    <item>item 3</item>
-                                </string-array>
-                                [ADDITIONAL_STRINGS]
-                            </resources>    
-                        ""${'"'}.trimIndent()
-
-                        val generateStringFiles = tasks.register("generateStringFiles") {
-                            val numberOfLanguages = 20
-                            val numberOfStrings = 500
-                            val langs = Locale.getAvailableLocales()
-                                .map { it.language }
-                                .filter { it.count() == 2 }
-                                .sorted()
-                                .distinct()
-                                .take(numberOfLanguages)
-                                .toList()
-
-                            val resourcesFolder = project.file("src/commonMain/composeResources")
-
-                            doLast {
-                                // THIS REMOVES THE `values` FOLDER IN `composeResources`
-                                // THIS REMOVES THE `values` FOLDER IN `composeResources`
-                                // Necessary when reducing the number of languages.
-                                resourcesFolder.listFiles()?.filter { it.name.startsWith("values") }?.forEach {
-                                    it.deleteRecursively()
-                                }
-
-                                langs.forEachIndexed { langIndex, lang ->
-                                    val additionalStrings =
-                                        (0 until numberOfStrings).joinToString(System.lineSeparator()) { index ->
-                                            ""${'"'}
-                                            <string name="string_${'$'}{index.toString().padStart(4, '0')}">String ${'$'}index in lang ${'$'}lang</string>
-                                            ""${'"'}.trimIndent()
-                                        }
-
-                                    val langFile = if (langIndex == 0) {
-                                        File(resourcesFolder, "values/strings.xml")
-                                    } else {
-                                        File(resourcesFolder, "values-${'$'}lang/strings.xml")
-                                    }
-                                    langFile.parentFile.mkdirs()
-                                    langFile.writeText(template.replace("[ADDITIONAL_STRINGS]", additionalStrings))
-                                }
-                            }
-                        }
-
-                        tasks.named("generateComposeResClass") {
-                            dependsOn(generateStringFiles)
-                        }
-                    """.trimIndent())
-                }
-            )
-        }
-        gradle("desktopJar").checks {
-            check.taskSuccessful(":generateStringFiles")
+        gradle("compileKotlinDesktop").checks {
+            check.taskSuccessful(":generateResourceFiles")
             check.taskSuccessful(":generateComposeResClass")
-            assertEquals(513, file("src/commonMain/composeResources/values/strings.xml").readLines().size)
+            assertDirectoriesContentEquals(
+                file("build/generated/compose/resourceGenerator/kotlin/app/group/huge/generated/resources"),
+                file("expected")
+            )
         }
     }
 
@@ -379,4 +320,25 @@ class ResourcesTest : GradlePluginTestBase() {
     fun testBundledKotlinPoet(): Unit = with(testProject("misc/bundledKotlinPoet")) {
         gradle("generateBuildConfig")
     }
+
+    private fun assertDirectoriesContentEquals(actual: File, expected: File) {
+        require(expected.isDirectory)
+        require(actual.isDirectory)
+        assertEquals(expected.exists(), actual.exists())
+
+        val expectedPath = expected.toPath()
+        val actualPath = actual.toPath()
+        expected.walkTopDown().forEach { expectedFile ->
+            if (!expectedFile.isDirectory) {
+                val actualFile = actualPath.resolve(expectedFile.toPath().relativeTo(expectedPath)).toFile()
+                assertEqualTextFiles(actualFile, expectedFile)
+            }
+        }
+
+        val expectedFilesCount = expected.walkTopDown()
+            .map { it.toPath().relativeTo(expectedPath) }.sorted().joinToString("\n")
+        val actualFilesCount = actual.walkTopDown()
+            .map { it.toPath().relativeTo(actualPath) }.sorted().joinToString("\n")
+        assertEquals(expectedFilesCount, actualFilesCount)
+    }
 }

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected/Drawable0.kt

@@ -0,0 +1,64 @@
+@file:OptIn(org.jetbrains.compose.resources.InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import org.jetbrains.compose.resources.DrawableResource
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+
+@ExperimentalResourceApi
+private object Drawable0 {
+  public val _3_strange_name: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+        "drawable:_3_strange_name",
+          setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/3-strange-name.xml"),
+          )
+      )
+
+  public val camelCaseName: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+        "drawable:camelCaseName",
+          setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/camelCaseName.xml"),
+          )
+      )
+
+  public val vector: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+        "drawable:vector",
+          setOf(
+           
+          org.jetbrains.compose.resources.ResourceItem(setOf(org.jetbrains.compose.resources.LanguageQualifier("au"),
+          org.jetbrains.compose.resources.RegionQualifier("US"), ), "drawable-au-rUS/vector.xml"),
+           
+          org.jetbrains.compose.resources.ResourceItem(setOf(org.jetbrains.compose.resources.ThemeQualifier.DARK,
+          org.jetbrains.compose.resources.LanguageQualifier("ge"), ),
+          "drawable-dark-ge/vector.xml"),
+           
+          org.jetbrains.compose.resources.ResourceItem(setOf(org.jetbrains.compose.resources.LanguageQualifier("en"),
+          ), "drawable-en/vector.xml"),
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/vector.xml"),
+          )
+      )
+
+  public val vector_2: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+        "drawable:vector_2",
+          setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/vector_2.xml"),
+          )
+      )
+}
+
+@ExperimentalResourceApi
+internal val Res.drawable._3_strange_name: DrawableResource
+  get() = Drawable0._3_strange_name
+
+@ExperimentalResourceApi
+internal val Res.drawable.camelCaseName: DrawableResource
+  get() = Drawable0.camelCaseName
+
+@ExperimentalResourceApi
+internal val Res.drawable.vector: DrawableResource
+  get() = Drawable0.vector
+
+@ExperimentalResourceApi
+internal val Res.drawable.vector_2: DrawableResource
+  get() = Drawable0.vector_2

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected/Font0.kt

@@ -0,0 +1,21 @@
+@file:OptIn(org.jetbrains.compose.resources.InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.FontResource
+
+@ExperimentalResourceApi
+private object Font0 {
+  public val emptyFont: FontResource = org.jetbrains.compose.resources.FontResource(
+        "font:emptyFont",
+          setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "font/emptyFont.otf"),
+          )
+      )
+}
+
+@ExperimentalResourceApi
+internal val Res.font.emptyFont: FontResource
+  get() = Font0.emptyFont

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected/Res.kt

@@ -8,10 +8,7 @@ package app.group.resources_test.generated.resources
 import kotlin.ByteArray
 import kotlin.OptIn
 import kotlin.String
-import org.jetbrains.compose.resources.DrawableResource
 import org.jetbrains.compose.resources.ExperimentalResourceApi
-import org.jetbrains.compose.resources.FontResource
-import org.jetbrains.compose.resources.StringResource
 import org.jetbrains.compose.resources.readResourceBytes
 
 @ExperimentalResourceApi
@@ -26,143 +23,9 @@ internal object Res {
    */
   public suspend fun readBytes(path: String): ByteArray = readResourceBytes(path)
 
-    public object drawable {
-        public val _3_strange_name: DrawableResource = get_drawable__3_strange_name()
+  public object drawable
 
-        public val camelCaseName: DrawableResource = get_drawable_camelCaseName()
+  public object string
 
-        public val vector: DrawableResource = get_drawable_vector()
-
-        public val vector_2: DrawableResource = get_drawable_vector_2()
-    }
-
-    public object string {
-        public val PascalCase: StringResource = get_string_PascalCase()
-
-        public val _1_kebab_case: StringResource = get_string__1_kebab_case()
-
-        public val app_name: StringResource = get_string_app_name()
-
-        public val camelCase: StringResource = get_string_camelCase()
-
-        public val hello: StringResource = get_string_hello()
-
-        public val multi_line: StringResource = get_string_multi_line()
-
-        public val str_arr: StringResource = get_string_str_arr()
-
-        public val str_template: StringResource = get_string_str_template()
-    }
-
-    public object font {
-        public val emptyFont: FontResource = get_font_emptyFont()
-    }
+  public object font
 }
-
-private fun get_drawable__3_strange_name(): DrawableResource =
-    org.jetbrains.compose.resources.DrawableResource(
-        "drawable:_3_strange_name",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/3-strange-name.xml"),
-        )
-    )
-
-private fun get_drawable_camelCaseName(): DrawableResource =
-    org.jetbrains.compose.resources.DrawableResource(
-        "drawable:camelCaseName",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/camelCaseName.xml"),
-        )
-    )
-
-private fun get_drawable_vector(): DrawableResource =
-    org.jetbrains.compose.resources.DrawableResource(
-        "drawable:vector",
-        setOf(
-
-            org.jetbrains.compose.resources.ResourceItem(setOf(org.jetbrains.compose.resources.LanguageQualifier("au"),
-                org.jetbrains.compose.resources.RegionQualifier("US"), ), "drawable-au-rUS/vector.xml"),
-
-            org.jetbrains.compose.resources.ResourceItem(setOf(org.jetbrains.compose.resources.ThemeQualifier.DARK,
-                org.jetbrains.compose.resources.LanguageQualifier("ge"), ), "drawable-dark-ge/vector.xml"),
-
-            org.jetbrains.compose.resources.ResourceItem(setOf(org.jetbrains.compose.resources.LanguageQualifier("en"),
-            ), "drawable-en/vector.xml"),
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/vector.xml"),
-        )
-    )
-
-private fun get_drawable_vector_2(): DrawableResource =
-    org.jetbrains.compose.resources.DrawableResource(
-        "drawable:vector_2",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/vector_2.xml"),
-        )
-    )
-
-private fun get_string_PascalCase(): StringResource =
-    org.jetbrains.compose.resources.StringResource(
-        "string:PascalCase", "PascalCase",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
-
-private fun get_string__1_kebab_case(): StringResource =
-    org.jetbrains.compose.resources.StringResource(
-        "string:_1_kebab_case", "_1_kebab_case",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
-
-private fun get_string_app_name(): StringResource = org.jetbrains.compose.resources.StringResource(
-    "string:app_name", "app_name",
-    setOf(
-        org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-    )
-)
-
-private fun get_string_camelCase(): StringResource = org.jetbrains.compose.resources.StringResource(
-    "string:camelCase", "camelCase",
-    setOf(
-        org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-    )
-)
-
-private fun get_string_hello(): StringResource = org.jetbrains.compose.resources.StringResource(
-    "string:hello", "hello",
-    setOf(
-        org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-    )
-)
-
-private fun get_string_multi_line(): StringResource =
-    org.jetbrains.compose.resources.StringResource(
-        "string:multi_line", "multi_line",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
-
-private fun get_string_str_arr(): StringResource = org.jetbrains.compose.resources.StringResource(
-    "string:str_arr", "str_arr",
-    setOf(
-        org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-    )
-)
-
-private fun get_string_str_template(): StringResource =
-    org.jetbrains.compose.resources.StringResource(
-        "string:str_template", "str_template",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
-
-private fun get_font_emptyFont(): FontResource = org.jetbrains.compose.resources.FontResource(
-    "font:emptyFont",
-    setOf(
-        org.jetbrains.compose.resources.ResourceItem(setOf(), "font/emptyFont.otf"),
-    )
-)

gradle-plugins/compose/src/test/test-projects/misc/commonResources/expected/String0.kt

@@ -0,0 +1,98 @@
+@file:OptIn(org.jetbrains.compose.resources.InternalResourceApi::class)
+
+package app.group.resources_test.generated.resources
+
+import kotlin.OptIn
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.StringResource
+
+@ExperimentalResourceApi
+private object String0 {
+    public val PascalCase: StringResource = org.jetbrains.compose.resources.StringResource(
+        "string:PascalCase", "PascalCase",
+        setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+        )
+    )
+
+    public val _1_kebab_case: StringResource = org.jetbrains.compose.resources.StringResource(
+        "string:_1_kebab_case", "_1_kebab_case",
+        setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+        )
+    )
+
+    public val app_name: StringResource = org.jetbrains.compose.resources.StringResource(
+        "string:app_name", "app_name",
+        setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+        )
+    )
+
+    public val camelCase: StringResource = org.jetbrains.compose.resources.StringResource(
+        "string:camelCase", "camelCase",
+        setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+        )
+    )
+
+    public val hello: StringResource = org.jetbrains.compose.resources.StringResource(
+        "string:hello", "hello",
+        setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+        )
+    )
+
+    public val multi_line: StringResource = org.jetbrains.compose.resources.StringResource(
+        "string:multi_line", "multi_line",
+        setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+        )
+    )
+
+    public val str_arr: StringResource = org.jetbrains.compose.resources.StringResource(
+        "string:str_arr", "str_arr",
+        setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+        )
+    )
+
+    public val str_template: StringResource = org.jetbrains.compose.resources.StringResource(
+        "string:str_template", "str_template",
+        setOf(
+            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+        )
+    )
+}
+
+@ExperimentalResourceApi
+internal val Res.string.PascalCase: StringResource
+    get() = String0.PascalCase
+
+@ExperimentalResourceApi
+internal val Res.string._1_kebab_case: StringResource
+    get() = String0._1_kebab_case
+
+@ExperimentalResourceApi
+internal val Res.string.app_name: StringResource
+    get() = String0.app_name
+
+@ExperimentalResourceApi
+internal val Res.string.camelCase: StringResource
+    get() = String0.camelCase
+
+@ExperimentalResourceApi
+internal val Res.string.hello: StringResource
+    get() = String0.hello
+
+@ExperimentalResourceApi
+internal val Res.string.multi_line: StringResource
+    get() = String0.multi_line
+
+@ExperimentalResourceApi
+internal val Res.string.str_arr: StringResource
+    get() = String0.str_arr
+
+@ExperimentalResourceApi
+internal val Res.string.str_template: StringResource
+    get() = String0.str_template

gradle-plugins/compose/src/test/test-projects/misc/commonResources/src/commonMain/kotlin/App.kt

@@ -6,6 +6,9 @@ import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
 import app.group.resources_test.generated.resources.Res
+import app.group.resources_test.generated.resources.app_name
+import app.group.resources_test.generated.resources.emptyFont
+import app.group.resources_test.generated.resources.vector
 import org.jetbrains.compose.resources.*
 
 @OptIn(ExperimentalResourceApi::class)

gradle-plugins/compose/src/test/test-projects/misc/emptyResources/expected/Res.kt

@@ -22,4 +22,10 @@ internal object Res {
      * @return The content of the file as a byte array.
      */
     public suspend fun readBytes(path: String): ByteArray = readResourceBytes(path)
+
+    public object drawable
+
+    public object string
+
+    public object font
 }

gradle-plugins/compose/src/test/test-projects/misc/hugeResources/build.gradle.kts

@@ -0,0 +1,50 @@
+plugins {
+    kotlin("multiplatform")
+    id("org.jetbrains.compose")
+}
+
+group = "app.group"
+
+kotlin {
+    jvm("desktop")
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation(compose.runtime)
+                implementation(compose.material)
+                implementation(compose.components.resources)
+            }
+        }
+    }
+}
+
+val generateResourceFiles = tasks.register("generateResourceFiles") {
+    val resourcesFolder = project.file("src/commonMain/composeResources")
+    val count = 25_000
+    doLast {
+        val txt = buildString {
+            appendLine("<resources>")
+            repeat(count) {
+                appendLine("    <string name=\"str_${it}\">str_${it}</string>")
+            }
+            appendLine("</resources>")
+        }
+        File(resourcesFolder, "values/strings.xml").apply {
+            parentFile.mkdirs()
+            writeText(txt)
+        }
+    }
+    doLast {
+        repeat(count) {
+            File(resourcesFolder, "drawable/icon_$it.xml").apply {
+                parentFile.mkdirs()
+                createNewFile() //empty file
+            }
+        }
+    }
+}
+
+tasks.named("generateComposeResClass") {
+    dependsOn(generateResourceFiles)
+}

gradle-plugins/compose/src/test/test-projects/misc/hugeResources/expected/Res.kt

@@ -0,0 +1,31 @@
+@file:OptIn(
+  org.jetbrains.compose.resources.InternalResourceApi::class,
+  org.jetbrains.compose.resources.ExperimentalResourceApi::class,
+)
+
+package app.group.huge.generated.resources
+
+import kotlin.ByteArray
+import kotlin.OptIn
+import kotlin.String
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.readResourceBytes
+
+@ExperimentalResourceApi
+internal object Res {
+  /**
+   * Reads the content of the resource file at the specified path and returns it as a byte array.
+   *
+   * Example: `val bytes = Res.readBytes("files/key.bin")`
+   *
+   * @param path The path of the file to read in the compose resource's directory.
+   * @return The content of the file as a byte array.
+   */
+  public suspend fun readBytes(path: String): ByteArray = readResourceBytes(path)
+
+  public object drawable
+
+  public object string
+
+  public object font
+}