[IR] Make IrReturnTargetSymbol a sealed interface

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractValueUsageTransformer.kt

@@ -72,7 +72,6 @@ abstract class AbstractValueUsageTransformer(
             is IrSimpleFunctionSymbol -> this.useAs(returnTarget.owner.returnType)
             is IrConstructorSymbol -> this.useAs(irBuiltIns.unitType)
             is IrReturnableBlockSymbol -> this.useAs(returnTarget.owner.type)
-            else -> error(returnTarget)
         }
 
     protected open fun IrExpression.useAsResult(enclosing: IrExpression): IrExpression =

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

@@ -149,7 +149,6 @@ class AutoboxingTransformer(context: JsCommonBackendContext) : AbstractValueUsag
         is IrSimpleFunctionSymbol -> useReturnableExpressionAsType(returnTarget.owner.returnType)
         is IrConstructorSymbol -> useReturnableExpressionAsType(irBuiltIns.unitType)
         is IrReturnableBlockSymbol -> useReturnableExpressionAsType(returnTarget.owner.type)
-        else -> error(returnTarget)
     }
 
     override fun IrExpression.useExpressionAsType(actualType: IrType, expectedType: IrType): IrExpression {

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

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.declarations.IrVariable
 import org.jetbrains.kotlin.ir.expressions.*
+import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
 import org.jetbrains.kotlin.ir.types.isAny
 import org.jetbrains.kotlin.ir.util.constructedClassType
@@ -125,17 +126,19 @@ class IrElementToJsStatementTransformer : BaseIrElementToJsNodeTransformer<JsSta
     }
 
     override fun visitReturn(expression: IrReturn, context: JsGenerationContext): JsStatement {
-        val targetSymbol = expression.returnTargetSymbol
         val lastStatementTransformer: (() -> JsExpression) -> JsStatement =
-            if (targetSymbol is IrReturnableBlockSymbol) {
+            when (val targetSymbol = expression.returnTargetSymbol) {
-                // TODO assert that value is Unit?
+                is IrReturnableBlockSymbol -> {
-                {
+                    // TODO assert that value is Unit?
-                    context.getNameForReturnableBlock(targetSymbol.owner)
+                    {
-                        .takeIf { !expression.isTheLastReturnStatementIn(targetSymbol) }
+                        context.getNameForReturnableBlock(targetSymbol.owner)
-                        ?.run { JsBreak(makeRef()) } ?: JsEmpty
+                            .takeIf { !expression.isTheLastReturnStatementIn(targetSymbol) }
+                            ?.run { JsBreak(makeRef()) } ?: JsEmpty
+                    }
+                }
+                is IrFunctionSymbol -> {
+                    { JsReturn(it()) }
                 }
-            } else {
-                { JsReturn(it()) }
             }
 
         return expression.value.maybeOptimizeIntoSwitch(context, lastStatementTransformer).withSource(expression, context)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt

@@ -91,7 +91,7 @@ interface IrValueParameterSymbol : IrValueSymbol, IrBindableSymbol<ParameterDesc
 
 interface IrVariableSymbol : IrValueSymbol, IrBindableSymbol<VariableDescriptor, IrVariable>
 
-interface IrReturnTargetSymbol : IrSymbol {
+sealed interface IrReturnTargetSymbol : IrSymbol {
     @ObsoleteDescriptorBasedAPI
     override val descriptor: FunctionDescriptor
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt

@@ -806,7 +806,6 @@ open class DeepCopyIrTreeWithSymbols(
         when (returnTarget) {
             is IrFunctionSymbol -> getReferencedFunction(returnTarget)
             is IrReturnableBlockSymbol -> getReferencedReturnableBlock(returnTarget)
-            else -> throw AssertionError("Unexpected return target: ${returnTarget.javaClass} $returnTarget")
         }
 
     override fun visitThrow(expression: IrThrow): IrThrow =

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/common/AbstractValueUsageTransformer.kt

@@ -75,7 +75,6 @@ internal abstract class AbstractValueUsageTransformer(
                 is IrSimpleFunctionSymbol -> this.useAs(returnTarget.owner.returnType)
                 is IrConstructorSymbol -> this.useAs(irBuiltIns.unitType)
                 is IrReturnableBlockSymbol -> this.useAs(returnTarget.owner.type)
-                else -> error(returnTarget)
             }
 
     protected open fun IrExpression.useAsResult(enclosing: IrExpression): IrExpression =

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/Autoboxing.kt

@@ -79,7 +79,6 @@ private class AutoboxingTransformer(val context: Context) : AbstractValueUsageTr
         is IrSimpleFunctionSymbol -> this.useAs(returnTarget.owner.returnType)
         is IrConstructorSymbol -> this.useAs(irBuiltIns.unitType)
         is IrReturnableBlockSymbol -> this.useAs(returnTarget.owner.type)
-        else -> error(returnTarget)
     }
 
     override fun IrExpression.useAs(type: IrType): IrExpression {