rra/ilgonmic/after-test-promise

[JS] Node downloading for js ir integration kotlin test

[JS] Fix API of Promise

[JS IR] Promise symbol as lazy2

[JS] Support legacy compiler aftertest with promises

[JS IR] Generate finally for promised tests

[JS] Setup it tests for JS IR kotlin-test

Merge-request: KT-MR-5168

^KT-49738 fixed

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CompilationException.kt

@@ -34,6 +34,8 @@ class CompilationException(
             val irStartOffset = irStartOffset
                 ?: return UNDEFINED_OFFSET
 
+            if (irStartOffset == UNDEFINED_OFFSET) return UNDEFINED_OFFSET
+
             val lineNumber = file?.fileEntry?.getLineNumber(irStartOffset)
                 ?: return UNDEFINED_OFFSET
 
@@ -45,6 +47,8 @@ class CompilationException(
             val irStartOffset = irStartOffset
                 ?: return UNDEFINED_OFFSET
 
+            if (irStartOffset == UNDEFINED_OFFSET) return UNDEFINED_OFFSET
+
             val columnNumber = file?.fileEntry?.getColumnNumber(irStartOffset)
                 ?: return UNDEFINED_OFFSET
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt

@@ -178,6 +178,9 @@ class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendC
     val jsNumberRangeToLong = getInternalFunction("numberRangeToLong")
 
     val longClassSymbol = getInternalClassWithoutPackage("kotlin.Long")
+    val promiseClassSymbol: IrClassSymbol by context.lazy2 {
+        getInternalClassWithoutPackage("kotlin.js.Promise")
+    }
 
     val longToDouble = context.symbolTable.referenceSimpleFunction(
         context.getClass(FqName("kotlin.Long")).unsubstitutedMemberScope.findSingleFunction(

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

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.FqName
@@ -168,15 +169,60 @@ class TestGenerator(val context: JsCommonBackendContext, val groupByPackage: Boo
 
         if (afterFuns.isEmpty()) {
             body.statements += returnStatement
-        } else {
-            body.statements += JsIrBuilder.buildTry(context.irBuiltIns.unitType).apply {
-                tryResult = returnStatement
-                finallyExpression = JsIrBuilder.buildComposite(context.irBuiltIns.unitType).apply {
-                    statements += afterFuns.map {
+            return
+        }
+
+        if (context is JsIrBackendContext && (testFun.returnType as? IrSimpleType)?.classifier == context.intrinsics.promiseClassSymbol) {
+            val finally = context.intrinsics.promiseClassSymbol.owner.declarations
+                .filterIsInstance<IrSimpleFunction>()
+                .first {
+                    it.name.asString() == "finally"
+                }
+
+            val refType = IrSimpleTypeImpl(context.ir.symbols.functionN(0), false, emptyList(), emptyList())
+
+            val afterFunction = context.irFactory.buildFun {
+                this.name = Name.identifier("${irClass.name.asString()} after test fun")
+                this.returnType = context.irBuiltIns.unitType
+                this.origin = JsIrBuilder.SYNTHESIZED_DECLARATION
+            }.apply {
+                parent = fn
+                this.body = context.irFactory.createBlockBody(
+                    UNDEFINED_OFFSET,
+                    UNDEFINED_OFFSET,
+                    afterFuns.map {
                         JsIrBuilder.buildCall(it.symbol).apply {
                             dispatchReceiver = JsIrBuilder.buildGetValue(classVal.symbol)
                         }
                     }
+                )
+            }
+
+            val finallyLambda = JsIrBuilder.buildFunctionExpression(refType, afterFunction)
+
+            val returnValue = JsIrBuilder.buildCall(
+                finally.symbol
+            ).apply {
+                this.dispatchReceiver = returnStatement.value
+                putValueArgument(0, finallyLambda)
+            }
+
+            body.statements += JsIrBuilder.buildReturn(
+                fn.symbol,
+                returnValue,
+                fn.returnType
+            )
+
+            return
+        }
+
+        body.statements += JsIrBuilder.buildTry(context.irBuiltIns.unitType).apply {
+            tryResult = returnStatement
+            finallyExpression = JsIrBuilder.buildComposite(context.irBuiltIns.unitType).apply {
+                statements += afterFuns.map {
+                    JsIrBuilder.buildCall(it.symbol).apply {
+                        dispatchReceiver = JsIrBuilder.buildGetValue(classVal.symbol)
+                    }
                 }
             }
         }