rra/ilgonmic/revert-signatures-changes

[JS IR] Fix line number test

[JS IR] Ignore isInstance repl test

[JS IR] Ignore isInstance repl test

[JS IR] Add test with unsafe variance

Revert "[JS IR] Optimize away upcasts"

This reverts commit 8149189585.

Get rid of duplicated signatures

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

This reverts commit 6adcbe081e.

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

This reverts commit 00289d35

[JS IR] Leave as is

[JS IR] Add test with overloading by generic

[JS IR] Add test from master

[JS IR] Add tests from master

Merge-request: KT-MR-5987
Merged-by: Ilya Goncharov <Ilya.Goncharov@jetbrains.com>

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

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

@@ -9,18 +9,16 @@ import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
 import org.jetbrains.kotlin.ir.backend.js.JsLoweredDeclarationOrigin
 import org.jetbrains.kotlin.ir.backend.js.ir.JsIrArithBuilder
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.varargParameterIndex
-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.builders.*
-import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.IrValueDeclaration
+import org.jetbrains.kotlin.ir.declarations.IrVariable
 import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.classifierOrNull
-import org.jetbrains.kotlin.ir.types.isUnit
 import org.jetbrains.kotlin.ir.util.isEffectivelyExternal
-import org.jetbrains.kotlin.ir.util.render
-import org.jetbrains.kotlin.name.Name
 
 class JsBridgesConstruction(context: JsIrBackendContext) : BridgesConstruction<JsIrBackendContext>(context) {
 
@@ -35,21 +33,8 @@ class JsBridgesConstruction(context: JsIrBackendContext) : BridgesConstruction<J
     private val primitiveArrays = context.intrinsics.primitiveArrays
     private val primitiveToLiteralConstructor = context.intrinsics.primitiveToLiteralConstructor
 
-    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) =
+        jsFunctionSignature(function, context)
 
     override fun getBridgeOrigin(bridge: IrSimpleFunction): IrDeclarationOrigin =
         when {
@@ -167,24 +152,3 @@ class JsBridgesConstruction(context: JsIrBackendContext) : BridgesConstruction<J
         return createTmpVariable(varargCopiedAsArray, nameHint = varargElement.name.asString())
     }
 }
-
-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/lower/TypeOperatorLowering.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.backend.common.BodyLoweringPass
 import org.jetbrains.kotlin.backend.common.compilationException
 import org.jetbrains.kotlin.backend.common.ir.isPure
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext
 import org.jetbrains.kotlin.ir.backend.js.ir.JsIrArithBuilder
 import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
@@ -19,7 +18,6 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCompositeImpl
-import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
@@ -229,37 +227,13 @@ class TypeOperatorLowering(val context: JsIrBackendContext) : BodyLoweringPass {
              * └─────────────┻─────────────────────────────┴───────────────────────────────┘
              * ```
              * Note: advanced check is performed when casting to primitive types, array types, function types, or interfaces.
-             *
-             * If we statically know that this is an upcast, we try to generate no checks.
-             * In this case, the following logic is applied:
-             * ```
-             *               ┌─────────────┬─────────────┐
-             *               │ to non-null │ to nullable │
-             * ┌─────────────╋━━━━━━━━━━━━━┻━━━━━━━━━━━━━┫
-             * │from non-null┃           true            │
-             * ├─────────────╋─────────────┬─────────────┤
-             * │from nullable┃ null check  │    true     │
-             * └─────────────┻─────────────┴─────────────┘
-             * ```
              */
             private fun generateTypeCheck(argument: () -> IrExpression, toType: IrType): IrExpression {
                 val toNotNullable = toType.makeNotNull()
                 val argumentInstance = argument()
-                val fromType = argumentInstance.type
-                val fromNotNullable = fromType.makeNotNull()
-
-                val isFromNullable = fromType.isNullable()
-                val isToNullable = toType.isNullable()
-
-                if (fromNotNullable !is IrDynamicType && fromNotNullable.isSubtypeOf(toNotNullable, context.typeSystem)) {
-                    // This is an upcast
-                    return when {
-                        isFromNullable && !isToNullable -> calculator.run { not(nullCheck(argument())) }
-                        else -> IrConstImpl.constTrue(UNDEFINED_OFFSET, UNDEFINED_OFFSET, context.irBuiltIns.booleanType)
-                    }
-                }
-
                 val instanceCheck = generateTypeCheckNonNull(argumentInstance, toNotNullable)
+                val isFromNullable = argumentInstance.type.isNullable()
+                val isToNullable = toType.isNullable()
                 val isNativeCheck = !advancedCheckRequired(toNotNullable)
 
                 return when {

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

@@ -14,7 +14,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
@@ -137,17 +141,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.
  */
 

compiler/testData/codegen/boxError/semantic/missedBody.kt

@@ -4,9 +4,9 @@
 // MODULE: lib
 // FILE: t.kt
 
-fun bar(a: String, b: String): Any
+fun bar(a: String, b: String): String
 
-fun foo(): Any {
+fun foo(): String {
     return bar("O", "K")
 }
 
@@ -17,4 +17,4 @@ fun box(): String {
     val r = foo()
     if (r is String) return r
     return "OK"
-}
+}