From 484e5afb59ed77a58a3ebe93cc86803fd2a68257 Mon Sep 17 00:00:00 2001 From: Artem Kobzar Date: Thu, 9 Mar 2023 16:51:07 +0000 Subject: [PATCH] [K/JS] Remove unused `Unit_getInstance` import into generated code --- .../IrElementToJsStatementTransformer.kt | 34 +++++++++++-------- .../js/transformers/irToJs/SwitchOptimizer.kt | 13 ++++--- .../friendDependency/project.info | 8 ++++- .../interfaceSuperUsage/project.info | 8 ++++- 4 files changed, 42 insertions(+), 21 deletions(-) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt index e3f7d47bec0..f6e6e5f8ab1 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrElementToJsStatementTransformer.kt @@ -90,50 +90,56 @@ class IrElementToJsStatementTransformer : BaseIrElementToJsNodeTransformer JsStatement): JsStatement { + private fun IrExpression.maybeOptimizeIntoSwitch( + context: JsGenerationContext, + transformer: (() -> JsExpression) -> JsStatement + ): JsStatement { if (this is IrWhen) { - val stmtTransformer = { stmt: JsStatement -> - assert(stmt is JsExpressionStatement) { "${render()} is not a statement $stmt" } - transformer((stmt as JsExpressionStatement).expression) + val stmtTransformer: (() -> JsStatement) -> JsStatement = { + transformer { + 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) } - ?.run { JsBreak(makeRef()) } ?: JsEmpty + .takeIf { !expression.isTheLastReturnStatementIn(targetSymbol) } + ?.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 - val expr = (stmt as JsExpressionStatement).expression + val transformer: (() -> JsStatement) -> JsStatement = { + val expr = (it() as JsExpressionStatement).expression JsBinaryOperation(JsBinaryOperator.ASG, varRef, expr).makeStmt() } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/SwitchOptimizer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/SwitchOptimizer.kt index 305033b18ff..a292134c840 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/SwitchOptimizer.kt +++ b/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(expression) + val lastStatement = lastStatementTransformer { case.body.accept(exprTransformer, context).makeStmt() } 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 } diff --git a/js/js.translator/testData/incremental/invalidation/friendDependency/project.info b/js/js.translator/testData/incremental/invalidation/friendDependency/project.info index d663ddcdb66..ff7fdf220dc 100644 --- a/js/js.translator/testData/incremental/invalidation/friendDependency/project.info +++ b/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 diff --git a/js/js.translator/testData/incremental/invalidation/interfaceSuperUsage/project.info b/js/js.translator/testData/incremental/invalidation/interfaceSuperUsage/project.info index e1f2243bc04..3cc679c1435 100644 --- a/js/js.translator/testData/incremental/invalidation/interfaceSuperUsage/project.info +++ b/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: