rrr/1.6.20/ilgonmic/duplicated-signatures

[JS IR] Add tests from master

[JS IR] Add test from master

[JS IR] Add test with overloading by generic

Get rid of duplicated signatures

Revert "[JS IR] Consider erasing type parameters in return type in js signatures"

This reverts commit 6adcbe0.

Revert "rra/ilgonmic/exported-bridges-2 [JS IR] Use js name for signature"

This reverts commit 00289d3

[JS IR] Leave as is

Merge-request: KT-MR-5967
Merged-by: Ilya Goncharov <[email protected]>

^KT-51700 fixed
^KT-51523 fixed
^KT-51685 fixed

Author: ilgonmic

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsBridgesConstruction.kt

@@ -7,58 +7,18 @@ package org.jetbrains.kotlin.ir.backend.js.lower
 
 import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
 import org.jetbrains.kotlin.ir.backend.js.JsLoweredDeclarationOrigin
-import org.jetbrains.kotlin.ir.backend.js.utils.eraseGenerics
-import org.jetbrains.kotlin.ir.backend.js.utils.getJsNameOrKotlinName
 import org.jetbrains.kotlin.ir.backend.js.utils.hasStableJsName
+import org.jetbrains.kotlin.ir.backend.js.utils.jsFunctionSignature
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.types.isUnit
-import org.jetbrains.kotlin.ir.util.render
-import org.jetbrains.kotlin.name.Name
 
 class JsBridgesConstruction(context: JsIrBackendContext) : BridgesConstruction<JsIrBackendContext>(context) {
-
-    private fun IrType.getJsInlinedClass() = context.inlineClassesUtils.getInlinedClass(this)
-
-    override fun getFunctionSignature(function: IrSimpleFunction): JsSignature =
-        if (function.hasStableJsName(context)) {
-            JsStableNameSignature(function.getJsNameOrKotlinName())
-        } else {
-            JsNonStableSignature(
-                function.name,
-                function.extensionReceiverParameter?.type?.eraseGenerics(context.irBuiltIns),
-                function.valueParameters.map { it.type.eraseGenerics(context.irBuiltIns) },
-                function.returnType.takeIf {
-                    it.getJsInlinedClass() != null || it.isUnit()
-                }?.eraseGenerics(context.irBuiltIns)
-            )
-        }
+    override fun getFunctionSignature(function: IrSimpleFunction): String =
+        jsFunctionSignature(function, context)
 
     override fun getBridgeOrigin(bridge: IrSimpleFunction): IrDeclarationOrigin =
         if (bridge.hasStableJsName(context))
             JsLoweredDeclarationOrigin.BRIDGE_WITH_STABLE_NAME
         else
             JsLoweredDeclarationOrigin.BRIDGE_WITHOUT_STABLE_NAME
 }
-
-interface JsSignature {
-    val name: Name
-}
-
-data class JsNonStableSignature(
-    override val name: Name,
-    val extensionReceiverType: IrType?,
-    val valueParametersType: List<IrType>,
-    val returnType: IrType?,
-) : JsSignature {
-    override fun toString(): String {
-        val er = extensionReceiverType?.let { "(er: ${it.render()}) " } ?: ""
-        val parameters = valueParametersType.joinToString(", ") { it.render() }
-        return "[$er$name($parameters) -> ${returnType?.let { " -> ${it.render()}" } ?: ""}]"
-    }
-}
-
-data class JsStableNameSignature(
-    override val name: Name,
-) : JsSignature

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/NameTables.kt

@@ -13,7 +13,11 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
 import org.jetbrains.kotlin.ir.types.isUnit
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.file
+import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
+import org.jetbrains.kotlin.ir.util.isEffectivelyExternal
+import org.jetbrains.kotlin.ir.util.isInterface
+import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
 import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 import org.jetbrains.kotlin.js.common.isES5IdentifierPart
@@ -122,17 +126,22 @@ fun jsFunctionSignature(declaration: IrFunction, context: JsIrBackendContext): S
     val nameBuilder = StringBuilder()
     nameBuilder.append(declarationName)
 
+    // TODO should we skip type parameters and use upper bound of type parameter when print type of value parameters?
+    declaration.typeParameters.ifNotEmpty {
+        nameBuilder.append("_\$t")
+        joinTo(nameBuilder, "") { "_${it.name.asString()}" }
+    }
     declaration.extensionReceiverParameter?.let {
-        nameBuilder.append("_r$${it.type.eraseGenerics(context.irBuiltIns).asString()}")
+        nameBuilder.append("_r$${it.type.asString()}")
     }
     declaration.valueParameters.ifNotEmpty {
-        joinTo(nameBuilder, "") { "_${it.type.eraseGenerics(context.irBuiltIns).asString()}" }
+        joinTo(nameBuilder, "") { "_${it.type.asString()}" }
     }
     declaration.returnType.let {
         // Return type is only used in signature for inline class and Unit types because
         // they are binary incompatible with supertypes.
         if (context.inlineClassesUtils.isTypeInlined(it) || it.isUnit()) {
-            nameBuilder.append("_ret$${it.eraseGenerics(context.irBuiltIns).asString()}")
+            nameBuilder.append("_ret$${it.asString()}")
         }
     }
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/utils/TypeTranformer.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 

js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/BoxJsTestGenerated.java

@@ -0,0 +1,79 @@
+// KJS_WITH_FULL_RUNTIME
+
+class L<T>
+
+class A {
+    fun foo(a: L<Int>) = "Int"
+    fun foo(a: L<String>) = "String"
+    fun L<Int>.bar() = "Int2"
+    fun L<String>.bar() = "String2"
+}
+
+fun foo(a: L<Int>) = "Int"
+fun foo(a: L<String>) = "String"
+
+private class TestClass {
+    private val data = mutableListOf<List<Any>>()
+    fun withData(data: List<List<Any>>) = apply { this.data.addAll(data) }
+    fun withData(row: List<Any>) = apply {
+        data.add(row)
+    }
+
+    fun getCols(): Int {
+        return data.firstOrNull()?.size ?: return 0
+    }
+}
+
+object B {
+    fun baz(vararg v: B) = "[A]"
+
+    fun baz(vararg v: String) = "[S]"
+}
+
+class C<in T> {
+    fun bac(c: T): String {
+        return "T4"
+    }
+
+    fun bac(c: Int): String {
+        return "Int5"
+    }
+
+    fun bac(c: List<T>): String {
+        return "ListT4"
+    }
+
+    fun bac(c: List<Int>): String {
+        return "ListInt4"
+    }
+
+    fun bac(c: List<*>): String {
+        return "ListStar4"
+    }
+}
+
+fun box(): String {
+    if (A().foo(L<Int>()) != "Int") return "fail1"
+    A().apply {
+        if (L<Int>().bar() != "Int2") return "fail2"
+    }
+    if (foo(L<Int>()) != "Int") return "fail3"
+
+    val b = TestClass()
+    val data = mutableListOf<List<Any>>()
+    data.add(listOf("a", "b", "c"))
+    data.add(listOf("d", "e", "f"))
+    b.withData(data)
+    if (b.getCols() != 3) return "fail4"
+
+    if (B.baz(B) != "[A]") return "fail5"
+    if (B.baz("a") != "[S]") return "fail6"
+
+    if(C<String>().bac("a") != "T4") return "fail7"
+    if(C<String>().bac(5) != "Int5") return "fail8"
+    if(C<String>().bac(listOf("a", "b")) != "ListT4") return "fail9"
+    if(C<String>().bac(listOf(5, 6)) != "ListInt4") return "fail10"
+    if(C<String>().bac(listOf(Any(), Any())) != "ListStar4") return "fail11"
+
+    return "OK"
+}