[K/JS] Remove unused Unit_getInstance import into generated code

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt

@@ -90,50 +90,56 @@ class IrElementToJsStatementTransformer : BaseIrElementToJsNodeTransformer<JsSta
         return JsContinue(context.getNameForLoop(jump.loop)?.let { JsNameRef(it) }).withSource(jump, context)
     }
 
-    private fun IrExpression.maybeOptimizeIntoSwitch(context: JsGenerationContext, transformer: (JsExpression) -> JsStatement): JsStatement {
+    private fun IrExpression.maybeOptimizeIntoSwitch(
+        context: JsGenerationContext,
+        transformer: (() -> JsExpression) -> JsStatement
+    ): JsStatement {
         if (this is IrWhen) {
-            val stmtTransformer = { stmt: JsStatement ->
+            val stmtTransformer: (() -> JsStatement) -> JsStatement = {
-                assert(stmt is JsExpressionStatement) { "${render()} is not a statement $stmt" }
+                transformer {
-                transformer((stmt as JsExpressionStatement).expression)
+                    val stmt = it()
+                    assert(stmt is JsExpressionStatement) { "${render()} is not a statement $stmt" }
+                    (stmt as JsExpressionStatement).expression
+                }
             }
             SwitchOptimizer(context, isExpression = true, stmtTransformer).tryOptimize(this)?.let { return it }
         }
 
-        return transformer(accept(IrElementToJsExpressionTransformer(), context))
+        return transformer { accept(IrElementToJsExpressionTransformer(), context) }
     }
 
     override fun visitSetField(expression: IrSetField, context: JsGenerationContext): JsStatement {
         val fieldName = context.getNameForField(expression.symbol.owner)
         val expressionTransformer = IrElementToJsExpressionTransformer()
         val dest = jsElementAccess(fieldName, expression.receiver?.accept(expressionTransformer, context))
-        return expression.value.maybeOptimizeIntoSwitch(context) { jsAssignment(dest, it).withSource(expression, context).makeStmt() }
+        return expression.value.maybeOptimizeIntoSwitch(context) { jsAssignment(dest, it()).withSource(expression, context).makeStmt() }
     }
 
     override fun visitSetValue(expression: IrSetValue, context: JsGenerationContext): JsStatement {
         val owner = expression.symbol.owner
         val ref = JsNameRef(context.getNameForValueDeclaration(owner))
-        return expression.value.maybeOptimizeIntoSwitch(context) { jsAssignment(ref, it).withSource(expression, context).makeStmt() }
+        return expression.value.maybeOptimizeIntoSwitch(context) { jsAssignment(ref, it()).withSource(expression, context).makeStmt() }
     }
 
     override fun visitReturn(expression: IrReturn, context: JsGenerationContext): JsStatement {
         val targetSymbol = expression.returnTargetSymbol
-        val lastStatementTransformer: (JsExpression) -> JsStatement =
+        val lastStatementTransformer: (() -> JsExpression) -> JsStatement =
             if (targetSymbol is IrReturnableBlockSymbol) {
                 // TODO assert that value is Unit?
                 {
                     context.getNameForReturnableBlock(targetSymbol.owner)
-                    .takeIf { !expression.isTheLastReturnStatementIn(targetSymbol) }
+                        .takeIf { !expression.isTheLastReturnStatementIn(targetSymbol) }
-                    ?.run { JsBreak(makeRef()) } ?: JsEmpty
+                        ?.run { JsBreak(makeRef()) } ?: JsEmpty
                 }
             } else {
-                { JsReturn(it) }
+                { JsReturn(it()) }
             }
 
         return expression.value.maybeOptimizeIntoSwitch(context, lastStatementTransformer).withSource(expression, context)
     }
 
     override fun visitThrow(expression: IrThrow, context: JsGenerationContext): JsStatement {
-        return expression.value.maybeOptimizeIntoSwitch(context) { JsThrow(it) }.withSource(expression, context)
+        return expression.value.maybeOptimizeIntoSwitch(context) { JsThrow(it()) }.withSource(expression, context)
     }
 
     override fun visitVariable(declaration: IrVariable, context: JsGenerationContext): JsStatement {
@@ -142,8 +148,8 @@ class IrElementToJsStatementTransformer : BaseIrElementToJsNodeTransformer<JsSta
 
         if (value is IrWhen) {
             val varRef = varName.makeRef()
-            val transformer = { stmt: JsStatement ->
+            val transformer: (() -> JsStatement) -> JsStatement = {
-                val expr = (stmt as JsExpressionStatement).expression
+                val expr = (it() as JsExpressionStatement).expression
                 JsBinaryOperation(JsBinaryOperator.ASG, varRef, expr).makeStmt()
             }
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/SwitchOptimizer.kt

@@ -11,10 +11,14 @@ import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.js.backend.ast.*
 
-class SwitchOptimizer(private val context: JsGenerationContext, private val isExpression: Boolean, private val lastStatementTransformer: (JsStatement) -> JsStatement) {
+class SwitchOptimizer(
+    private val context: JsGenerationContext,
+    private val isExpression: Boolean,
+    private val lastStatementTransformer: (() -> JsStatement) -> JsStatement
+) {
 
     // TODO: reimplement optimization on top of IR
-    constructor(context: JsGenerationContext) : this(context, isExpression = false, { it })
+    constructor(context: JsGenerationContext) : this(context, isExpression = false, { it() })
 
     private val jsEqeqeq = context.staticContext.backendContext.intrinsics.jsEqeqeq
     private val jsEqeq = context.staticContext.backendContext.intrinsics.jsEqeq
@@ -145,8 +149,7 @@ class SwitchOptimizer(private val context: JsGenerationContext, private val isEx
             }
 
             val lastStatement = if (isExpression) {
-                val expression = case.body.accept(exprTransformer, context).makeStmt()
+                val lastStatement = lastStatementTransformer { case.body.accept(exprTransformer, context).makeStmt() }
-                val lastStatement = lastStatementTransformer(expression)
                 jsCase.statements += lastStatement
                 lastStatement
             } else {
@@ -154,7 +157,7 @@ class SwitchOptimizer(private val context: JsGenerationContext, private val isEx
                 var lastStatement = jsBody.statements.lastOrNull()
 
                 if (lastStatement != null) {
-                    lastStatement = lastStatementTransformer(lastStatement)
+                    lastStatement = lastStatementTransformer { lastStatement!! }
                     jsBody.statements[jsBody.statements.lastIndex] = lastStatement
                 }
 

js/js.translator/testData/incremental/invalidation/friendDependency/project.info

@@ -12,6 +12,12 @@ STEP 3:
 STEP 4:
     libs: lib1, main
     dirty js: main
-STEP 5..9:
+STEP 5..6:
+    libs: lib1, main
+    dirty js: lib1, main
+STEP 7:
+    libs: lib1, main
+    dirty js: main
+STEP 8..9:
     libs: lib1, main
     dirty js: lib1, main

js/js.translator/testData/incremental/invalidation/interfaceSuperUsage/project.info

@@ -1,6 +1,12 @@
 MODULES: lib1, main
 
-STEP 0..3:
+STEP 0..1:
+    libs: lib1, main
+    dirty js: lib1, main
+STEP 2:
+    libs: lib1, main
+    dirty js: lib1
+STEP 3:
     libs: lib1, main
     dirty js: lib1, main
 STEP 4: