[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,11 +188,30 @@ 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() }")
+                    .build()
+            }
+            typeObject.addProperties(properties)
+        }.build()
+        chunkFile.addType(objectSpec)
+
+        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("%T(\n", type.getClassName()).withIndent {
+                        .add("return %T(\n", type.getClassName()).withIndent {
                             add("\"${type}:${resName}\",")
                             if (type == ResourceType.STRING) add(" \"$resName\",")
                             withIndent {
@@ -212,18 +231,7 @@ private fun getChunkFileSpec(
                         .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)
+            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,21 +8,51 @@ 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 
+      lazy { init__3_strange_name() }
+
+  public val camelCaseName: DrawableResource by 
+      lazy { init_camelCaseName() }
+
+  public val vector: DrawableResource by 
+      lazy { init_vector() }
+
+  public val vector_2: DrawableResource by 
+      lazy { init_vector_2() }
+}
+
+@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"),
     )
-      )
+)
 
-  public val camelCaseName: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+@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"),
     )
-      )
+)
 
-  public val vector: DrawableResource = org.jetbrains.compose.resources.DrawableResource(
+@ExperimentalResourceApi
+internal val Res.drawable.vector: DrawableResource
+  get() = Drawable0.vector
+
+@ExperimentalResourceApi
+private fun init_vector(): DrawableResource = org.jetbrains.compose.resources.DrawableResource(
   "drawable:vector",
     setOf(
      
@@ -33,35 +63,22 @@ private object Drawable0 {
     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.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(
+@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"),
     )
-      )
-}
-
-@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

@@ -8,14 +8,18 @@ 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"),
-          )
-      )
+  public val emptyFont: FontResource by 
+      lazy { init_emptyFont() }
 }
 
 @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(
-        "string:PascalCase", "PascalCase",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
+  public val PascalCase: StringResource by 
+      lazy { init_PascalCase() }
 
-    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 _1_kebab_case: StringResource by 
+      lazy { init__1_kebab_case() }
 
-    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 app_name: StringResource by 
+      lazy { init_app_name() }
 
-    public val camelCase: StringResource = org.jetbrains.compose.resources.StringResource(
-        "string:camelCase", "camelCase",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
+  public val camelCase: StringResource by 
+      lazy { init_camelCase() }
 
-    public val hello: StringResource = org.jetbrains.compose.resources.StringResource(
-        "string:hello", "hello",
-        setOf(
-            org.jetbrains.compose.resources.ResourceItem(setOf(), "values/strings.xml"),
-        )
-    )
+  public val hello: StringResource by 
+      lazy { init_hello() }
 
-    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 multi_line: StringResource by 
+      lazy { init_multi_line() }
 
-    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_arr: StringResource by 
+      lazy { init_str_arr() }
 
-    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"),
-        )
-    )
+  public val str_template: StringResource by 
+      lazy { init_str_template() }
 }
 
 @ExperimentalResourceApi
 internal val Res.string.PascalCase: StringResource
   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
 
+@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
 
+@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
 
+@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
 
+@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
 
+@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
 
+@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
+
+@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,11 +40,14 @@ val generateResourceFiles = tasks.register("generateResourceFiles") {
             }
             appendLine("</resources>")
         }
-        File(resourcesFolder, "values/strings.xml").apply {
+        langs.forEachIndexed { langIndex, lang ->
+            val stringsFileName = if (langIndex == 0) "values/strings.xml" else "values-$lang/strings.xml"
+            File(resourcesFolder, stringsFileName).apply {
                 parentFile.mkdirs()
                 writeText(txt)
             }
         }
+    }
     doLast {
         repeat(count) {
             File(resourcesFolder, "drawable/icon_$it.xml").apply {