[CMP] CMP-9167 fix

Author: shishkin-pavel

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ComposeIT.kt

@@ -11,6 +11,7 @@ import org.gradle.kotlin.dsl.getByType
 import org.gradle.util.GradleVersion
 import org.jetbrains.kotlin.compose.compiler.gradle.ComposeCompilerGradlePluginExtension
 import org.jetbrains.kotlin.gradle.testbase.*
+import org.jetbrains.kotlin.gradle.uklibs.applyMultiplatform
 import org.jetbrains.kotlin.test.TestMetadata
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.condition.DisabledOnOs
@@ -755,6 +756,90 @@ class ComposeIT : KGPBaseTest() {
         }
     }
 
+    @DisplayName("CMP-9167 verification")
+    @GradleTest
+    @OtherGradlePluginTests
+    fun testComposeDefaultValueParamStubs(
+        gradleVersion: GradleVersion,
+    ) {
+        project(
+            projectName = "empty",
+            gradleVersion = gradleVersion,
+            buildOptions = defaultBuildOptions.copy(
+                nativeOptions = super.defaultBuildOptions.nativeOptions.copy(
+                    version = TestVersions.Kotlin.CURRENT
+                ),
+                isolatedProjects = BuildOptions.IsolatedProjectsMode.DISABLED
+            ),
+            dependencyManagement = DependencyManagement.DefaultDependencyManagement(setOf("https://maven.pkg.jetbrains.space/public/p/compose/dev")),
+            enableGradleDaemonMemoryLimitInMb = 2048,
+            enableKotlinDaemonMemoryLimitInMb = 2048,
+        ) {
+            plugins {
+                id("org.jetbrains.kotlin.plugin.compose")
+            }
+            buildScriptInjection {
+                project.applyMultiplatform {
+                    listOf(
+                        iosArm64(),
+                        iosSimulatorArm64()
+                    ).forEach { iosTarget ->
+                        iosTarget.binaries.framework {
+                            baseName = "ComposeApp"
+                            isStatic = true
+                        }
+                    }
+                    jvm()
+
+                    @OptIn(ExperimentalWasmDsl::class)
+                    wasmJs {
+                        browser()
+                        binaries.library()
+                    }
+
+                    js {
+                        browser()
+                        binaries.library()
+                    }
+                    sourceSets.commonMain {
+                        compileSource(
+                            //language=kotlin
+                            """
+                            package com.example
+                            
+                            import androidx.compose.runtime.Composable
+                            import kotlin.jvm.JvmInline
+                            
+                            @JvmInline
+                            value class ImeAction private constructor(val value: Int) {
+                                companion object {
+                                    val Default = ImeAction(0)
+                                }
+                            }
+                            
+                            @Composable
+                            fun <T> TextCompose(genericText: (T) -> String, imeAction: ImeAction = ImeAction.Default) {}
+                            """.trimIndent()
+                        )
+                        dependencies {
+                            implementation("org.jetbrains.compose.runtime:runtime:1.9.1")
+                        }
+                    }
+                }
+            }
+
+            build(":compileKotlinIosSimulatorArm64") {
+                assertTasksExecuted(":compileKotlinIosSimulatorArm64")
+            }
+            build(":compileKotlinWasmJs") {
+                assertTasksExecuted(":compileKotlinWasmJs")
+            }
+            build(":compileKotlinJs") {
+                assertTasksExecuted(":compileKotlinJs")
+            }
+        }
+    }
+
     private fun Path.appendComposePlugin() {
         modify { originalBuildScript ->
             """

plugins/compose/compiler-hosted/src/main/java/androidx/compose/compiler/plugins/kotlin/lower/ComposerParamTransformer.kt

@@ -35,6 +35,8 @@ import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
+import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
+import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.symbols.UnsafeDuringIrConstructionAPI
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
@@ -609,6 +611,29 @@ class ComposerParamTransformer(
         return (transform(DeepCopyPreservingMetadata(symbolRemapper, typeRemapper), null) as T).patchDeclarationParents(initialParent)
     }
 
+    private fun IrSimpleFunction.toComparableParams(referenceFn: IrSimpleFunction): List<Pair<IrClassifierSymbol, SimpleTypeNullability>?> =
+        parameters.map {
+            when (val paramType = it.type) {
+                is IrSimpleType ->
+                    if (paramType.classifier is IrTypeParameterSymbol) {
+                        val typeParam = paramType.classifier.owner as IrTypeParameter
+                        // if a type parameter is defined on a stub,
+                        // it should be compared with matching original function's type parameter
+                        // instead of comparing each stub's type parameters
+                        val classifier = if (typeParam.parent == this) {
+                            referenceFn.typeParameters[typeParam.index].symbol
+                        } else {
+                            paramType.classifier
+                        }
+                        Pair(classifier, paramType.nullability)
+
+                    } else {
+                        Pair(paramType.classifier, paramType.nullability)
+                    }
+                else -> null
+            }
+        }
+
     private fun IrSimpleFunction.copyWithComposerParam(): IrSimpleFunction {
         assert(parameters.lastOrNull()?.name != ComposeNames.ComposerParameter) {
             "Attempted to add composer param to $this, but it has already been added."
@@ -717,9 +742,9 @@ class ComposerParamTransformer(
             val parent = fn.parent
             if (parent is IrClass || parent is IrFile) {
                 // checking if any stubs have all same-type parameters and discarding them
-                val addedParamTypes = mutableSetOf(fn.parameters.map { it.type })
+                val addedParamTypes = mutableSetOf(fn.toComparableParams(fn))
                 stubs.forEach { stub ->
-                    val stubParamTypes = stub.parameters.map { it.type }
+                    val stubParamTypes = stub.toComparableParams(fn)
                     if (addedParamTypes.add(stubParamTypes)) {
                         parent.addChild(stub)
                     }