From e57de9a08f5cec5283c9d93eb303e3d560718d99 Mon Sep 17 00:00:00 2001 From: Ivan Kylchik Date: Wed, 17 Jun 2020 12:14:16 +0300 Subject: [PATCH] Mark most of classes and functions from interpreter package as internal Main goal is to avoid ambiguity because some names, that are used by interpreter, can be found in other modules --- .../backend/common/interpreter/Label.kt | 5 ++- .../backend/common/interpreter/Utils.kt | 40 ++++++++----------- .../intrinsics/IntrinsicEvaluator.kt | 2 +- .../intrinsics/IntrinsicImplementations.kt | 20 +++++----- .../backend/common/interpreter/stack/Frame.kt | 4 +- .../backend/common/interpreter/stack/Stack.kt | 4 +- .../common/interpreter/stack/Variable.kt | 3 +- .../common/interpreter/state/Common.kt | 2 +- .../common/interpreter/state/Complex.kt | 2 +- .../interpreter/state/ExceptionState.kt | 2 +- .../common/interpreter/state/Lambda.kt | 2 +- .../common/interpreter/state/Primitive.kt | 2 +- .../backend/common/interpreter/state/State.kt | 14 +++---- .../common/interpreter/state/Wrapper.kt | 2 +- 14 files changed, 50 insertions(+), 54 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Label.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Label.kt index 656ab2770ca..8ae9600ee86 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Label.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Label.kt @@ -37,7 +37,10 @@ inline fun ExecutionResult.check(toCheckLabel: ReturnLabel = ReturnLabel.NEXT, r return this } -fun ExecutionResult.implicitCastIfNeeded(expectedType: IrType, actualType: IrType, stack: Stack): ExecutionResult { +/** + * This method is analog of `checkcast` jvm bytecode operation. Throw exception whenever actual type is not a subtype of expected. + */ +internal fun ExecutionResult.implicitCastIfNeeded(expectedType: IrType, actualType: IrType, stack: Stack): ExecutionResult { if (actualType.classifierOrNull !is IrTypeParameterSymbol) return this if (expectedType.classifierOrFail is IrTypeParameterSymbol) return this diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Utils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Utils.kt index 3ad85afdf8b..210de640b89 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Utils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/Utils.kt @@ -23,23 +23,15 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.addToStdlib.safeAs -fun IrFunction.getDispatchReceiver(): IrValueParameterSymbol? { - return this.dispatchReceiverParameter?.symbol -} +internal fun IrFunction.getDispatchReceiver(): IrValueParameterSymbol? = this.dispatchReceiverParameter?.symbol -fun IrFunction.getExtensionReceiver(): IrValueParameterSymbol? { - return this.extensionReceiverParameter?.symbol -} +internal fun IrFunction.getExtensionReceiver(): IrValueParameterSymbol? = this.extensionReceiverParameter?.symbol -fun IrFunction.getReceiver(): IrSymbol? { - return this.getDispatchReceiver() ?: this.getExtensionReceiver() -} +internal fun IrFunction.getReceiver(): IrSymbol? = this.getDispatchReceiver() ?: this.getExtensionReceiver() -fun IrFunctionAccessExpression.getBody(): IrBody? { - return this.symbol.owner.body -} +internal fun IrFunctionAccessExpression.getBody(): IrBody? = this.symbol.owner.body -fun State.toIrExpression(expression: IrExpression): IrExpression { +internal fun State.toIrExpression(expression: IrExpression): IrExpression { val start = expression.startOffset val end = expression.endOffset val type = expression.type.makeNotNull() @@ -61,7 +53,7 @@ fun State.toIrExpression(expression: IrExpression): IrExpression { } } -fun Any?.toState(irType: IrType): State { +internal fun Any?.toState(irType: IrType): State { return when (this) { is State -> this is Boolean, is Char, is Byte, is Short, is Int, is Long, is String, is Float, is Double, is Array<*>, is ByteArray, @@ -92,7 +84,7 @@ fun Any?.toIrConst(irType: IrType, startOffset: Int = UNDEFINED_OFFSET, endOffse } } -fun IrConst.toPrimitive(): Primitive { +internal fun IrConst.toPrimitive(): Primitive { return Primitive(this.value, this.type) } @@ -109,13 +101,13 @@ fun IrAnnotationContainer.getAnnotation(annotation: FqName): IrConstructorCall { ?: ((this as IrFunction).parent as IrClass).annotations.first { it.symbol.owner.parentAsClass.fqNameWhenAvailable == annotation } } -fun IrAnnotationContainer.getEvaluateIntrinsicValue(): String? { +internal fun IrAnnotationContainer.getEvaluateIntrinsicValue(): String? { if (this is IrClass && this.fqNameWhenAvailable?.startsWith(Name.identifier("java")) == true) return this.fqNameWhenAvailable?.asString() if (!this.hasAnnotation(evaluateIntrinsicAnnotation)) return null return (this.getAnnotation(evaluateIntrinsicAnnotation).getValueArgument(0) as IrConst<*>).value.toString() } -fun getPrimitiveClass(irType: IrType, asObject: Boolean = false): Class<*>? { +internal fun getPrimitiveClass(irType: IrType, asObject: Boolean = false): Class<*>? { return when { irType.isBoolean() -> if (asObject) Boolean::class.javaObjectType else Boolean::class.java irType.isChar() -> if (asObject) Char::class.javaObjectType else Char::class.java @@ -130,7 +122,7 @@ fun getPrimitiveClass(irType: IrType, asObject: Boolean = false): Class<*>? { } } -fun IrFunction.getArgsForMethodInvocation(args: List): List { +internal fun IrFunction.getArgsForMethodInvocation(args: List): List { val argsValues = args.map { when (val state = it.state) { is ExceptionState -> state.getThisAsCauseForException() @@ -157,7 +149,7 @@ fun IrFunction.getLastOverridden(): IrFunction { return generateSequence(listOf(this)) { it.firstOrNull()?.overriddenSymbols?.map { it.owner } }.flatten().last() } -fun List.toPrimitiveStateArray(type: IrType): Primitive<*> { +internal fun List.toPrimitiveStateArray(type: IrType): Primitive<*> { return when { type.isByteArray() -> Primitive(ByteArray(size) { i -> (this[i] as Number).toByte() }, type) type.isCharArray() -> Primitive(CharArray(size) { i -> this[i] as Char }, type) @@ -178,7 +170,7 @@ fun IrFunctionAccessExpression.getVarargType(index: Int): IrType? { return this.getTypeArgument(typeParameter.index) } -fun getTypeArguments( +internal fun getTypeArguments( container: IrTypeParametersContainer, expression: IrFunctionAccessExpression, mapper: (IrTypeParameterSymbol) -> State ): List { fun IrType.getState(): State { @@ -198,13 +190,13 @@ fun getTypeArguments( return typeArguments } -fun State?.extractNonLocalDeclarations(): List { +internal fun State?.extractNonLocalDeclarations(): List { this ?: return listOf() val state = this.takeIf { it !is Complex } ?: (this as Complex).getOriginal() return state.fields.filter { it.symbol !is IrFieldSymbol } } -fun State?.getCorrectReceiverByFunction(irFunction: IrFunction): State? { +internal fun State?.getCorrectReceiverByFunction(irFunction: IrFunction): State? { if (this !is Complex) return this val original: Complex? = this.getOriginal() @@ -212,7 +204,7 @@ fun State?.getCorrectReceiverByFunction(irFunction: IrFunction): State? { return generateSequence(original) { it.superClass }.firstOrNull { it.irClass.thisReceiver == other } ?: this } -fun State.checkNullability(irType: IrType?): State { +internal fun State.checkNullability(irType: IrType?): State { if (irType !is IrSimpleType) return this if (this.isNull() && !irType.hasQuestionMark) { throw NullPointerException() @@ -225,4 +217,4 @@ fun IrValueParameterSymbol.isNullable(): Boolean { return type.isNullable() } -fun IrFunction.getCapitalizedFileName() = this.file.name.replace(".kt", "Kt").capitalize() \ No newline at end of file +internal fun IrFunction.getCapitalizedFileName() = this.file.name.replace(".kt", "Kt").capitalize() \ No newline at end of file diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/intrinsics/IntrinsicEvaluator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/intrinsics/IntrinsicEvaluator.kt index 716f368e1e9..eed1260add5 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/intrinsics/IntrinsicEvaluator.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/intrinsics/IntrinsicEvaluator.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.backend.common.interpreter.stack.Stack import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.IrFunction -class IntrinsicEvaluator { +internal class IntrinsicEvaluator { suspend fun evaluate(irFunction: IrFunction, stack: Stack, interpret: suspend IrElement.() -> ExecutionResult): ExecutionResult { return when { EmptyArray.equalTo(irFunction) -> EmptyArray.evaluate(irFunction, stack, interpret) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/intrinsics/IntrinsicImplementations.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/intrinsics/IntrinsicImplementations.kt index f35252e7731..e1bffd3a533 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/intrinsics/IntrinsicImplementations.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/intrinsics/IntrinsicImplementations.kt @@ -17,12 +17,12 @@ import org.jetbrains.kotlin.ir.declarations.IrFunction import org.jetbrains.kotlin.ir.types.classOrNull import org.jetbrains.kotlin.ir.util.* -sealed class IntrinsicBase { +internal sealed class IntrinsicBase { abstract fun equalTo(irFunction: IrFunction): Boolean abstract suspend fun evaluate(irFunction: IrFunction, stack: Stack, interpret: suspend IrElement.() -> ExecutionResult): ExecutionResult } -object EmptyArray : IntrinsicBase() { +internal object EmptyArray : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return fqName in setOf("kotlin.emptyArray", "kotlin.ArrayIntrinsicsKt.emptyArray") @@ -37,7 +37,7 @@ object EmptyArray : IntrinsicBase() { } } -object ArrayOf : IntrinsicBase() { +internal object ArrayOf : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return fqName == "kotlin.arrayOf" @@ -53,7 +53,7 @@ object ArrayOf : IntrinsicBase() { } } -object ArrayOfNulls : IntrinsicBase() { +internal object ArrayOfNulls : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return fqName == "kotlin.arrayOfNulls" @@ -70,7 +70,7 @@ object ArrayOfNulls : IntrinsicBase() { } } -object EnumValues : IntrinsicBase() { +internal object EnumValues : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return (fqName == "kotlin.enumValues" || fqName.endsWith(".values")) && irFunction.valueParameters.isEmpty() @@ -91,7 +91,7 @@ object EnumValues : IntrinsicBase() { } } -object EnumValueOf : IntrinsicBase() { +internal object EnumValueOf : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return (fqName == "kotlin.enumValueOf" || fqName.endsWith(".valueOf")) && irFunction.valueParameters.size == 1 @@ -113,7 +113,7 @@ object EnumValueOf : IntrinsicBase() { } } -object RegexReplace : IntrinsicBase() { +internal object RegexReplace : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return fqName == "kotlin.text.Regex.replace" && irFunction.valueParameters.size == 2 @@ -137,7 +137,7 @@ object RegexReplace : IntrinsicBase() { } } -object EnumHashCode : IntrinsicBase() { +internal object EnumHashCode : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return fqName == "kotlin.Enum.hashCode" @@ -152,7 +152,7 @@ object EnumHashCode : IntrinsicBase() { } } -object JsPrimitives : IntrinsicBase() { +internal object JsPrimitives : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return fqName == "kotlin.Long." || fqName == "kotlin.Char." @@ -176,7 +176,7 @@ object JsPrimitives : IntrinsicBase() { } } -object ArrayConstructor : IntrinsicBase() { +internal object ArrayConstructor : IntrinsicBase() { override fun equalTo(irFunction: IrFunction): Boolean { val fqName = irFunction.fqNameWhenAvailable.toString() return fqName.matches("kotlin\\.(Byte|Char|Short|Int|Long|Float|Double|Boolean|)Array\\.".toRegex()) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Frame.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Frame.kt index 31ab87dd341..44218099b93 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Frame.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Frame.kt @@ -9,7 +9,7 @@ import org.jetbrains.kotlin.backend.common.interpreter.state.State import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol -interface Frame { +internal interface Frame { fun addVar(variable: Variable) fun addAll(variables: List) fun getVariable(symbol: IrSymbol): Variable? @@ -23,7 +23,7 @@ interface Frame { } // TODO replace exceptions with InterpreterException -class InterpreterFrame( +internal class InterpreterFrame( private val pool: MutableList = mutableListOf(), private val typeArguments: List = listOf() ) : Frame { diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Stack.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Stack.kt index 2efd27e505e..c0f57fc3b0f 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Stack.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Stack.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.ir.util.fileEntry import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult -interface Stack { +internal interface Stack { suspend fun newFrame( asSubFrame: Boolean = false, initPool: List = listOf(), block: suspend () -> ExecutionResult ): ExecutionResult @@ -39,7 +39,7 @@ interface Stack { fun peekReturnValue(): State } -class StackImpl : Stack { +internal class StackImpl : Stack { private val frameList = mutableListOf(FrameContainer()) // first frame is default, it is easier to work when last() is not null private fun getCurrentFrame() = frameList.last() diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Variable.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Variable.kt index 1840aafb005..94b4d754860 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Variable.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/stack/Variable.kt @@ -8,4 +8,5 @@ package org.jetbrains.kotlin.backend.common.interpreter.stack import org.jetbrains.kotlin.backend.common.interpreter.state.State import org.jetbrains.kotlin.ir.symbols.IrSymbol -data class Variable(val symbol: IrSymbol, var state: State) \ No newline at end of file +// TODO maybe switch to typealias and use map instead of list +internal data class Variable(val symbol: IrSymbol, var state: State) \ No newline at end of file diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Common.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Common.kt index 16c575291cc..d208ea78966 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Common.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Common.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.ir.types.classOrNull import org.jetbrains.kotlin.ir.util.fqNameForIrSerialization import org.jetbrains.kotlin.ir.util.isInterface -class Common private constructor( +internal class Common private constructor( override val irClass: IrClass, override val fields: MutableList ) : Complex(irClass, fields) { diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Complex.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Complex.kt index 08229dd7b34..fb4b9725976 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Complex.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Complex.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.ir.util.fqNameForIrSerialization import org.jetbrains.kotlin.ir.util.isInterface import org.jetbrains.kotlin.ir.util.overrides -abstract class Complex(override val irClass: IrClass, override val fields: MutableList) : State { +internal abstract class Complex(override val irClass: IrClass, override val fields: MutableList) : State { var superClass: Complex? = null var subClass: Complex? = null val interfaces: MutableList = mutableListOf() // filled lazily, as needed diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/ExceptionState.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/ExceptionState.kt index 9d00a6e9e7d..489291f7f8b 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/ExceptionState.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/ExceptionState.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.ir.util.isSubclassOf import org.jetbrains.kotlin.ir.util.nameForIrSerialization import kotlin.math.min -class ExceptionState private constructor( +internal class ExceptionState private constructor( override val irClass: IrClass, override val fields: MutableList, stackTrace: List ) : Complex(irClass, fields) { diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Lambda.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Lambda.kt index f36e9704d42..c8c97c0bb20 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Lambda.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Lambda.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.ir.util.nameForIrSerialization import org.jetbrains.kotlin.ir.util.render import org.jetbrains.kotlin.utils.addToStdlib.cast -class Lambda(val irFunction: IrFunction, override val irClass: IrClass) : State { +internal class Lambda(val irFunction: IrFunction, override val irClass: IrClass) : State { override val fields: MutableList = mutableListOf() override val typeArguments: MutableList = mutableListOf() diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Primitive.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Primitive.kt index a149a269875..067c5267965 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Primitive.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Primitive.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.classOrNull import org.jetbrains.kotlin.ir.util.isFakeOverride -class Primitive(var value: T, val type: IrType) : State { +internal class Primitive(var value: T, val type: IrType) : State { override val fields: MutableList = mutableListOf() override val typeArguments: MutableList = mutableListOf() override val irClass: IrClass = type.classOrNull!!.owner diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/State.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/State.kt index 9ed8e394c23..a60b5c8d251 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/State.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/State.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.util.defaultType -interface State { +internal interface State { val fields: MutableList val irClass: IrClass val typeArguments: MutableList @@ -36,15 +36,15 @@ interface State { fun getIrFunctionByIrCall(expression: IrCall): IrFunction? } -fun State.isNull() = this is Primitive<*> && this.value == null +internal fun State.isNull() = this is Primitive<*> && this.value == null -fun State.asInt() = (this as Primitive<*>).value as Int -fun State.asBoolean() = (this as Primitive<*>).value as Boolean -fun State.asString() = (this as Primitive<*>).value.toString() +internal fun State.asInt() = (this as Primitive<*>).value as Int +internal fun State.asBoolean() = (this as Primitive<*>).value as Boolean +internal fun State.asString() = (this as Primitive<*>).value.toString() -fun State.asBooleanOrNull() = (this as? Primitive<*>)?.value as? Boolean +internal fun State.asBooleanOrNull() = (this as? Primitive<*>)?.value as? Boolean -fun State.isSubtypeOf(other: IrType): Boolean { +internal fun State.isSubtypeOf(other: IrType): Boolean { if (this is Primitive<*> && this.value == null) return other.isNullable() if (this is Primitive<*> && this.type.isArray() && other.isArray()) { diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Wrapper.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Wrapper.kt index 3806a66a14f..2651385ff2a 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Wrapper.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/interpreter/state/Wrapper.kt @@ -30,7 +30,7 @@ import java.lang.invoke.MethodHandle import java.lang.invoke.MethodHandles import java.lang.invoke.MethodType -class Wrapper(val value: Any, override val irClass: IrClass) : Complex(irClass, mutableListOf()) { +internal class Wrapper(val value: Any, override val irClass: IrClass) : Complex(irClass, mutableListOf()) { private val typeFqName = irClass.fqNameForIrSerialization.toUnsafe() private val receiverClass = irClass.defaultType.getClass(true)