From be6100527b14bb0a43972274605425b0c69a985f Mon Sep 17 00:00:00 2001
From: Mikhail Glukhikh <mikhail.glukhikh@jetbrains.com>
Date: Wed, 23 Oct 2019 09:48:53 +0300
Subject: [PATCH] FIR Java enhancement: fix JVM signature generation for type
 parameters

---
 .../jetbrains/kotlin/fir/java/JavaUtils.kt    | 46 ++++++++++++++-----
 1 file changed, 34 insertions(+), 12 deletions(-)

diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt
index 1433ce12d67..818b8875873 100644
--- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt
+++ b/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 {
-                            append("L")
-                            append(it.asString().replace(".", "/"))
-                        }
+                        is JavaClass -> appendClass(classifier)
                         is JavaTypeParameter -> {
-                            append("L")
-                            append(classifier.name)
+                            val representative = classifier.upperBounds.firstOrNull { it.classifier is JavaClass }
+                            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
-            append(classId.packageFqName.asString().replace(".", "/"))
-            append("/")
-            append(classId.relativeClassName)
+            appendClassLikeType(coneType)
+        }
+        is ConeTypeParameterType -> {
+            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(";")
 }