[resources] Init resource accessors lazily and in external function to avoid MethodTooLargeException (#4404)

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

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

@@ -188,42 +188,50 @@ private fun getChunkFileSpec(
         val objectSpec = TypeSpec.objectBuilder(chunkClassName).also { typeObject ->
             typeObject.addModifiers(KModifier.PRIVATE)
             typeObject.addAnnotation(experimentalAnnotation)
-            val properties = idToResources.map { (resName, items) ->
+            val properties = idToResources.keys.map { resName ->
                 PropertySpec.builder(resName, type.getClassName())
-                    .initializer(
+                    .delegate("\nlazy·{ init_$resName() }")
-                        CodeBlock.builder()
-                            .add("%T(\n", type.getClassName()).withIndent {
-                                add("\"${type}:${resName}\",")
-                                if (type == ResourceType.STRING) add(" \"$resName\",")
-                                withIndent {
-                                    add("\nsetOf(\n").withIndent {
-                                        items.forEach { item ->
-                                            add("%T(", resourceItemClass)
-                                            add("setOf(").addQualifiers(item).add("), ")
-                                            //file separator should be '/' on all platforms
-                                            add("\"${item.path.invariantSeparatorsPathString}\"") //todo: add module ID here
-                                            add("),\n")
-                                        }
-                                    }
-                                    add(")\n")
-                                }
-                            }
-                            .add(")")
-                            .build().toString()
-                    )
                     .build()
             }
             typeObject.addProperties(properties)
         }.build()
         chunkFile.addType(objectSpec)
 
-        idToResources.keys.forEach { resName ->
+        idToResources.forEach { (resName, items) ->
             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)
+
+            val initializer = FunSpec.builder("init_$resName")
+                .addModifiers(KModifier.PRIVATE)
+                .addAnnotation(experimentalAnnotation)
+                .returns(type.getClassName())
+                .addStatement(
+                    CodeBlock.builder()
+                        .add("return %T(\n", type.getClassName()).withIndent {
+                            add("\"${type}:${resName}\",")
+                            if (type == ResourceType.STRING) add(" \"$resName\",")
+                            withIndent {
+                                add("\nsetOf(\n").withIndent {
+                                    items.forEach { item ->
+                                        add("%T(", resourceItemClass)
+                                        add("setOf(").addQualifiers(item).add("), ")
+                                        //file separator should be '/' on all platforms
+                                        add("\"${item.path.invariantSeparatorsPathString}\"") //todo: add module ID here
+                                        add("),\n")
+                                    }
+                                }
+                                add(")\n")
+                            }
+                        }
+                        .add(")")
+                        .build().toString()
+                )
+                .build()
+            chunkFile.addFunction(initializer)
         }
     }.build()
 }

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

@@ -299,7 +299,7 @@ class ResourcesTest : GradlePluginTestBase() {
     //https://github.com/JetBrains/compose-multiplatform/issues/4194
     //https://github.com/JetBrains/compose-multiplatform/issues/4285
     //
-    // 25_000 icons + 25_000 strings!!!
+    // 1500 icons + 1500*20 strings!!!
     @Test
     fun testHugeNumberOfResources(): Unit = with(
         //disable cache for the test because the generateResourceFiles task doesn't support it

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

@@ -8,60 +8,77 @@ import org.jetbrains.compose.resources.ExperimentalResourceApi
 
 @ExperimentalResourceApi
 private object Drawable0 {
-  public val _3_strange_name: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+  public val _3_strange_name: DrawableResource by 
-        "drawable:_3_strange_name",
+      lazy { init__3_strange_name() }
-          setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/3-strange-name.xml"),
-          )
-      )
 
-  public val camelCaseName: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+  public val camelCaseName: DrawableResource by 
-        "drawable:camelCaseName",
+      lazy { init_camelCaseName() }
-          setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/camelCaseName.xml"),
-          )
-      )
 
-  public val vector: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+  public val vector: DrawableResource by 
-        "drawable:vector",
+      lazy { init_vector() }
-          setOf(
 
-          org.jetbrains.compose.resources.ResourceItem(setOf(org.jetbrains.compose.resources.LanguageQualifier("ast"),
+  public val vector_2: DrawableResource by 
-          ), "drawable-ast/vector.xml"),
+      lazy { init_vector_2() }
-
-          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
+private fun init__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"),
+    )
+)
+
 @ExperimentalResourceApi
 internal val Res.drawable.camelCaseName: DrawableResource
   get() = Drawable0.camelCaseName
 
+@ExperimentalResourceApi
+private fun init_camelCaseName(): DrawableResource =
+    org.jetbrains.compose.resources.DrawableResource(
+  "drawable:camelCaseName",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/camelCaseName.xml"),
+    )
+)
+
 @ExperimentalResourceApi
 internal val Res.drawable.vector: DrawableResource
   get() = Drawable0.vector
 
+@ExperimentalResourceApi
+private fun init_vector(): DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+  "drawable:vector",
+    setOf(
+     
+    org.jetbrains.compose.resources.ResourceItem(setOf(org.jetbrains.compose.resources.LanguageQualifier("ast"),
+    ), "drawable-ast/vector.xml"),
+     
+    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"),
+    )
+)
+
 @ExperimentalResourceApi
 internal val Res.drawable.vector_2: DrawableResource
   get() = Drawable0.vector_2
+
+@ExperimentalResourceApi
+private fun init_vector_2(): DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+  "drawable:vector_2",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "drawable/vector_2.xml"),
+    )
+)

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

@@ -8,14 +8,18 @@ import org.jetbrains.compose.resources.FontResource
 
 @ExperimentalResourceApi
 private object Font0 {
-  public val emptyFont: FontResource = org.jetbrains.compose.resources.FontResource(
+  public val emptyFont: FontResource by 
-        "font:emptyFont",
+      lazy { init_emptyFont() }
-          setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "font/emptyFont.otf"),
-          )
-      )
 }
 
 @ExperimentalResourceApi
 internal val Res.font.emptyFont: FontResource
   get() = Font0.emptyFont
+
+@ExperimentalResourceApi
+private fun init_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

@@ -8,91 +8,123 @@ import org.jetbrains.compose.resources.StringResource
 
 @ExperimentalResourceApi
 private object String0 {
-    public val PascalCase: StringResource = org.jetbrains.compose.resources.StringResource(
+  public val PascalCase: StringResource by 
-        "string:PascalCase", "PascalCase",
+      lazy { init_PascalCase() }
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
 
-    public val _1_kebab_case: StringResource = org.jetbrains.compose.resources.StringResource(
+  public val _1_kebab_case: StringResource by 
-        "string:_1_kebab_case", "_1_kebab_case",
+      lazy { init__1_kebab_case() }
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
 
-    public val app_name: StringResource = org.jetbrains.compose.resources.StringResource(
+  public val app_name: StringResource by 
-        "string:app_name", "app_name",
+      lazy { init_app_name() }
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
 
-    public val camelCase: StringResource = org.jetbrains.compose.resources.StringResource(
+  public val camelCase: StringResource by 
-        "string:camelCase", "camelCase",
+      lazy { init_camelCase() }
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
 
-    public val hello: StringResource = org.jetbrains.compose.resources.StringResource(
+  public val hello: StringResource by 
-        "string:hello", "hello",
+      lazy { init_hello() }
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
 
-    public val multi_line: StringResource = org.jetbrains.compose.resources.StringResource(
+  public val multi_line: StringResource by 
-        "string:multi_line", "multi_line",
+      lazy { init_multi_line() }
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
 
-    public val str_arr: StringResource = org.jetbrains.compose.resources.StringResource(
+  public val str_arr: StringResource by 
-        "string:str_arr", "str_arr",
+      lazy { init_str_arr() }
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
 
-    public val str_template: StringResource = org.jetbrains.compose.resources.StringResource(
+  public val str_template: StringResource by 
-        "string:str_template", "str_template",
+      lazy { init_str_template() }
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
 }
 
 @ExperimentalResourceApi
 internal val Res.string.PascalCase: StringResource
-    get() = String0.PascalCase
+  get() = String0.PascalCase
+
+@ExperimentalResourceApi
+private fun init_PascalCase(): StringResource = org.jetbrains.compose.resources.StringResource(
+  "string:PascalCase", "PascalCase",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+    )
+)
 
 @ExperimentalResourceApi
 internal val Res.string._1_kebab_case: StringResource
-    get() = String0._1_kebab_case
+  get() = String0._1_kebab_case
+
+@ExperimentalResourceApi
+private fun init__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"),
+    )
+)
 
 @ExperimentalResourceApi
 internal val Res.string.app_name: StringResource
-    get() = String0.app_name
+  get() = String0.app_name
+
+@ExperimentalResourceApi
+private fun init_app_name(): StringResource = org.jetbrains.compose.resources.StringResource(
+  "string:app_name", "app_name",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+    )
+)
 
 @ExperimentalResourceApi
 internal val Res.string.camelCase: StringResource
-    get() = String0.camelCase
+  get() = String0.camelCase
+
+@ExperimentalResourceApi
+private fun init_camelCase(): StringResource = org.jetbrains.compose.resources.StringResource(
+  "string:camelCase", "camelCase",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+    )
+)
 
 @ExperimentalResourceApi
 internal val Res.string.hello: StringResource
-    get() = String0.hello
+  get() = String0.hello
+
+@ExperimentalResourceApi
+private fun init_hello(): StringResource = org.jetbrains.compose.resources.StringResource(
+  "string:hello", "hello",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+    )
+)
 
 @ExperimentalResourceApi
 internal val Res.string.multi_line: StringResource
-    get() = String0.multi_line
+  get() = String0.multi_line
+
+@ExperimentalResourceApi
+private fun init_multi_line(): StringResource = org.jetbrains.compose.resources.StringResource(
+  "string:multi_line", "multi_line",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+    )
+)
 
 @ExperimentalResourceApi
 internal val Res.string.str_arr: StringResource
-    get() = String0.str_arr
+  get() = String0.str_arr
+
+@ExperimentalResourceApi
+private fun init_str_arr(): StringResource = org.jetbrains.compose.resources.StringResource(
+  "string:str_arr", "str_arr",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+    )
+)
 
 @ExperimentalResourceApi
 internal val Res.string.str_template: StringResource
-    get() = String0.str_template
+  get() = String0.str_template
+
+@ExperimentalResourceApi
+private fun init_str_template(): StringResource = org.jetbrains.compose.resources.StringResource(
+  "string:str_template", "str_template",
+    setOf(
+      org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
+    )
+)

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

@@ -1,3 +1,5 @@
+import java.util.Locale
+
 plugins {
     kotlin("multiplatform")
     id("org.jetbrains.compose")
@@ -21,7 +23,15 @@ kotlin {
 
 val generateResourceFiles = tasks.register("generateResourceFiles") {
     val resourcesFolder = project.file("src/commonMain/composeResources")
-    val count = 25_000
+    val count = 1500
+    val numberOfLanguages = 20
+    val langs = Locale.getAvailableLocales()
+        .map { it.language }
+        .filter { it.count() == 2 }
+        .sorted()
+        .distinct()
+        .take(numberOfLanguages)
+        .toList()
     doLast {
         val txt = buildString {
             appendLine("<resources>")
@@ -30,9 +40,12 @@ val generateResourceFiles = tasks.register("generateResourceFiles") {
             }
             appendLine("</resources>")
         }
-        File(resourcesFolder, "values/strings.xml").apply {
+        langs.forEachIndexed { langIndex, lang ->
-            parentFile.mkdirs()
+            val stringsFileName = if (langIndex == 0) "values/strings.xml" else "values-$lang/strings.xml"
-            writeText(txt)
+            File(resourcesFolder, stringsFileName).apply {
+                parentFile.mkdirs()
+                writeText(txt)
+            }
         }
     }
     doLast {