FIR Java enhancement: fix JVM signature generation for type parameters

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -338,19 +338,27 @@ internal fun FirFunction<*>.computeJvmDescriptor(): String = buildString {
 
 // TODO: primitive types, arrays, etc.
 private fun StringBuilder.appendErasedType(typeRef: FirTypeRef) {
+    fun appendClass(klass: JavaClass) {
+        klass.fqName?.let {
+            append("L")
+            append(it.asString().replace(".", "/"))
+        }
+    }
+
     when (typeRef) {
         is FirResolvedTypeRef -> appendConeType(typeRef.type)
         is FirJavaTypeRef -> {
             when (val javaType = typeRef.type) {
                 is JavaClassifierType -> {
                     when (val classifier = javaType.classifier) {
-                        is JavaClass -> classifier.fqName?.let {
+                        is JavaClass -> appendClass(classifier)
-                            append("L")
-                            append(it.asString().replace(".", "/"))
-                        }
                         is JavaTypeParameter -> {
-                            append("L")
+                            val representative = classifier.upperBounds.firstOrNull { it.classifier is JavaClass }
-                            append(classifier.name)
+                            if (representative == null) {
+                                append("Ljava/lang/Object")
+                            } else {
+                                appendClass(representative.classifier as JavaClass)
+                            }
                         }
                         else -> return
                     }
@@ -362,16 +370,30 @@ private fun StringBuilder.appendErasedType(typeRef: FirTypeRef) {
 }
 
 private fun StringBuilder.appendConeType(coneType: ConeKotlinType) {
+    fun appendClassLikeType(type: ConeClassLikeType) {
+        append("L")
+        val classId = type.lookupTag.classId
+        append(classId.packageFqName.asString().replace(".", "/"))
+        append("/")
+        append(classId.relativeClassName)
+    }
+
     if (coneType is ConeClassErrorType) return
-    append("L")
     when (coneType) {
         is ConeClassLikeType -> {
-            val classId = coneType.lookupTag.classId
+            appendClassLikeType(coneType)
-            append(classId.packageFqName.asString().replace(".", "/"))
+        }
-            append("/")
+        is ConeTypeParameterType -> {
-            append(classId.relativeClassName)
+            val representative = coneType.lookupTag.typeParameterSymbol.fir.bounds.firstOrNull {
+                (it as? FirResolvedTypeRef)?.type is ConeClassLikeType
+            }
+            if (representative == null) {
+                append("Ljava/lang/Object")
+            } else {
+                appendClassLikeType(representative.coneTypeUnsafe())
+            }
+            append(coneType.lookupTag.name)
         }
-        is ConeTypeParameterType -> append(coneType.lookupTag.name)
     }
     append(";")
 }