[IR] Make checkers public

mcpiroman · Space Team · commit a46bee07d116 · 2025-08-07T14:27:05.000Z
To be able to pass them individually to the validator.

KT-76601
KT-77819
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/context/ParentChainUpdater.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/context/ParentChainUpdater.kt
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.backend.common.checkers.context
 import org.jetbrains.kotlin.backend.common.temporarilyPushing
 import org.jetbrains.kotlin.ir.IrElement
 
-internal object ParentChainUpdater : ContextUpdater {
+object ParentChainUpdater : ContextUpdater {
     override fun runInNewContext(
         context: CheckerContext,
         element: IrElement,
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/context/TypeParameterScopeUpdater.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/context/TypeParameterScopeUpdater.kt
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.backend.common.checkers.context
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer
 
-internal object TypeParameterScopeUpdater : ContextUpdater {
+object TypeParameterScopeUpdater : ContextUpdater {
     override fun runInNewContext(
         context: CheckerContext,
         element: IrElement,
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/context/ValueScopeUpdater.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/context/ValueScopeUpdater.kt
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.ir.visitors.IrVisitorVoid
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.utils.addIfNotNull
 
-internal object ValueScopeUpdater : ContextUpdater {
+object ValueScopeUpdater : ContextUpdater {
     override fun runInNewContext(
         context: CheckerContext,
         element: IrElement,
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrConstructorReceiverChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrConstructorReceiverChecker.kt
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrParameterKind
 import org.jetbrains.kotlin.ir.util.constructedClass
 
-internal object IrConstructorReceiverChecker : IrElementChecker<IrFunction>(IrFunction::class) {
+object IrConstructorReceiverChecker : IrElementChecker<IrFunction>(IrFunction::class) {
     override fun check(element: IrFunction, context: CheckerContext) {
         if (element !is IrConstructor) return
         if (!element.constructedClass.isInner && element.dispatchReceiverParameter != null) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrExpressionBodyInFunctionChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrExpressionBodyInFunctionChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 
-internal object IrExpressionBodyInFunctionChecker : IrElementChecker<IrFunction>(IrFunction::class) {
+object IrExpressionBodyInFunctionChecker : IrElementChecker<IrFunction>(IrFunction::class) {
     override fun check(element: IrFunction, context: CheckerContext) {
         if (element.body is IrExpressionBody) {
             context.error(element, "IrFunction body cannot be of type IrExpressionBody. Use IrBlockBody instead.")
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrFieldVisibilityChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrFieldVisibilityChecker.kt
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.name.ClassId
 /**
  * Makes sure that all encountered [IrField]s are private unless they participate in Java interop.
  */
-internal object IrFieldVisibilityChecker : IrElementChecker<IrField>(IrField::class) {
+object IrFieldVisibilityChecker : IrElementChecker<IrField>(IrField::class) {
     private val JVM_FIELD_CLASS_ID = ClassId.fromString("kotlin/jvm/JvmField")
 
     // TODO: Some backing fields inherit their visibility from their corresponding properties.
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrFunctionDispatchReceiverChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrFunctionDispatchReceiverChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.IrElementChecker
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.types.IrDynamicType
 
-internal object IrFunctionDispatchReceiverChecker : IrElementChecker<IrFunction>(IrFunction::class) {
+object IrFunctionDispatchReceiverChecker : IrElementChecker<IrFunction>(IrFunction::class) {
     override fun check(element: IrFunction, context: CheckerContext) {
         if (element.dispatchReceiverParameter?.type is IrDynamicType) {
             context.error(element, "Dispatch receivers with 'dynamic' type are not allowed")
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrFunctionParametersChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrFunctionParametersChecker.kt
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.backend.common.checkers.IrElementChecker
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrParameterKind
 
-internal object IrFunctionParametersChecker : IrElementChecker<IrFunction>(IrFunction::class) {
+object IrFunctionParametersChecker : IrElementChecker<IrFunction>(IrFunction::class) {
     override fun check(element: IrFunction, context: CheckerContext) {
         @OptIn(DeprecatedForRemovalCompilerApi::class)
         for ((i, param) in element.valueParameters.withIndex()) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrFunctionPropertiesChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrFunctionPropertiesChecker.kt
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.util.render
 
-internal object IrFunctionPropertiesChecker : IrElementChecker<IrFunction>(IrFunction::class) {
+object IrFunctionPropertiesChecker : IrElementChecker<IrFunction>(IrFunction::class) {
     override fun check(element: IrFunction, context: CheckerContext) {
         if (element is IrSimpleFunction) {
             val property = element.correspondingPropertySymbol?.owner
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrPrivateDeclarationOverrideChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrPrivateDeclarationOverrideChecker.kt
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclarationWithVisibility
 import org.jetbrains.kotlin.ir.declarations.IrOverridableDeclaration
 import org.jetbrains.kotlin.ir.util.render
 
-internal object IrPrivateDeclarationOverrideChecker : IrElementChecker<IrDeclaration>(IrDeclaration::class) {
+object IrPrivateDeclarationOverrideChecker : IrElementChecker<IrDeclaration>(IrDeclaration::class) {
     override fun check(element: IrDeclaration, context: CheckerContext) {
         if (element is IrOverridableDeclaration<*>) {
             for (overriddenSymbol in element.overriddenSymbols) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrPropertyAccessorsChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrPropertyAccessorsChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.IrElementChecker
 import org.jetbrains.kotlin.ir.declarations.IrProperty
 import org.jetbrains.kotlin.ir.util.render
 
-internal object IrPropertyAccessorsChecker : IrElementChecker<IrProperty>(IrProperty::class) {
+object IrPropertyAccessorsChecker : IrElementChecker<IrProperty>(IrProperty::class) {
     override fun check(element: IrProperty, context: CheckerContext) {
         element.getter?.let {
             if (it.correspondingPropertySymbol != element.symbol) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrValueParameterVarargTypesChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/declaration/IrValueParameterVarargTypesChecker.kt
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.ir.expressions.IrVararg
 /**
  * Makes sure that: [IrVararg.type] is an array of [IrVararg.varargElementType].
  */
-internal object IrValueParameterVarargTypesChecker : IrElementChecker<IrValueParameter>(IrValueParameter::class) {
+object IrValueParameterVarargTypesChecker : IrElementChecker<IrValueParameter>(IrValueParameter::class) {
     override fun check(
         element: IrValueParameter,
         context: CheckerContext
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrCallTypeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrCallTypeChecker.kt
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.ir.types.classifierOrNull
 import org.jetbrains.kotlin.ir.util.resolveFakeOverrideMaybeAbstract
 
-internal object IrCallTypeChecker : IrElementChecker<IrCall>(IrCall::class) {
+object IrCallTypeChecker : IrElementChecker<IrCall>(IrCall::class) {
     override fun check(element: IrCall, context: CheckerContext) {
         val callee = element.symbol.owner
         // TODO: We don't have the proper type substitution yet, so skip generics for now.
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrConstTypeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrConstTypeChecker.kt
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.ir.expressions.IrConstKind
 import org.jetbrains.kotlin.ir.util.isNullable
 import org.jetbrains.kotlin.ir.util.render
 
-internal object IrConstTypeChecker : IrElementChecker<IrConst>(IrConst::class) {
+object IrConstTypeChecker : IrElementChecker<IrConst>(IrConst::class) {
     override fun check(element: IrConst, context: CheckerContext) {
         val irBuiltIns = context.irBuiltIns
 
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrCrossFileFieldUsageChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrCrossFileFieldUsageChecker.kt
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.ir.util.fileOrNull
 /**
  * Makes sure that [IrField]s are not accessed outside their containing files.
  */
-internal object IrCrossFileFieldUsageChecker : IrElementChecker<IrFieldAccessExpression>(IrFieldAccessExpression::class) {
+object IrCrossFileFieldUsageChecker : IrElementChecker<IrFieldAccessExpression>(IrFieldAccessExpression::class) {
     override fun check(element: IrFieldAccessExpression, context: CheckerContext) {
         val field = element.symbol.owner
         if (field.origin == IrDeclarationOrigin.IR_EXTERNAL_JAVA_DECLARATION_STUB) return
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrDynamicTypeFieldAccessChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrDynamicTypeFieldAccessChecker.kt
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.ir.types.IrDynamicType
 /**
  * Makes sure that [IrDynamicType] is not used as receiver of IrFieldAccessExpression.
  */
-internal object IrDynamicTypeFieldAccessChecker : IrElementChecker<IrFieldAccessExpression>(IrFieldAccessExpression::class) {
+object IrDynamicTypeFieldAccessChecker : IrElementChecker<IrFieldAccessExpression>(IrFieldAccessExpression::class) {
     override fun check(element: IrFieldAccessExpression, context: CheckerContext) {
         if (element.receiver?.type is IrDynamicType) {
             context.error(
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrGetFieldTypeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrGetFieldTypeChecker.kt
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.ir.expressions.IrGetField
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.types.IrSimpleType
 
-internal object IrGetFieldTypeChecker : IrElementChecker<IrGetField>(IrGetField::class) {
+object IrGetFieldTypeChecker : IrElementChecker<IrGetField>(IrGetField::class) {
     override fun check(element: IrGetField, context: CheckerContext) {
         val fieldType = element.symbol.owner.type
         // TODO: We don't have the proper type substitution yet, so skip generics for now.
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrGetObjectValueTypeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrGetObjectValueTypeChecker.kt
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.backend.common.checkers.ensureTypeIs
 import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
 import org.jetbrains.kotlin.ir.types.createType
 
-internal object IrGetObjectValueTypeChecker : IrElementChecker<IrGetObjectValue>(IrGetObjectValue::class) {
+object IrGetObjectValueTypeChecker : IrElementChecker<IrGetObjectValue>(IrGetObjectValue::class) {
     override fun check(element: IrGetObjectValue, context: CheckerContext) {
         element.ensureTypeIs(element.symbol.createType(false, emptyList()), context)
     }
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrGetValueTypeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrGetValueTypeChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.backend.common.checkers.ensureTypeIs
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
 
-internal object IrGetValueTypeChecker : IrElementChecker<IrGetValue>(IrGetValue::class) {
+object IrGetValueTypeChecker : IrElementChecker<IrGetValue>(IrGetValue::class) {
     override fun check(element: IrGetValue, context: CheckerContext) {
         element.ensureTypeIs(element.symbol.owner.type, context)
     }
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrNoInlineUseSitesChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrNoInlineUseSitesChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.checkFunctionUseSite
 import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
 
-internal object IrNoInlineUseSitesChecker : IrElementChecker<IrFunctionAccessExpression>(IrFunctionAccessExpression::class) {
+object IrNoInlineUseSitesChecker : IrElementChecker<IrFunctionAccessExpression>(IrFunctionAccessExpression::class) {
     override fun check(element: IrFunctionAccessExpression, context: CheckerContext) {
         context.checkInlineFunctionUseSites?.let {
             checkFunctionUseSite(element, it, context)
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrNothingTypeExpressionChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrNothingTypeExpressionChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.backend.common.checkers.ensureTypeIs
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 
-internal object IrNothingTypeExpressionChecker : IrElementChecker<IrExpression>(IrExpression::class) {
+object IrNothingTypeExpressionChecker : IrElementChecker<IrExpression>(IrExpression::class) {
     override fun check(element: IrExpression, context: CheckerContext) {
         element.ensureTypeIs(context.irBuiltIns.nothingType, context)
     }
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrSetValueAssignabilityChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrSetValueAssignabilityChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.expressions.IrSetValue
 
-internal object IrSetValueAssignabilityChecker : IrElementChecker<IrSetValue>(IrSetValue::class) {
+object IrSetValueAssignabilityChecker : IrElementChecker<IrSetValue>(IrSetValue::class) {
     override fun check(element: IrSetValue, context: CheckerContext) {
         val declaration = element.symbol.owner
         if (declaration is IrValueParameter && !declaration.isAssignable) {
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrStringConcatenationTypeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrStringConcatenationTypeChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.backend.common.checkers.ensureTypeIs
 import org.jetbrains.kotlin.ir.expressions.IrStringConcatenation
 
-internal object IrStringConcatenationTypeChecker : IrElementChecker<IrStringConcatenation>(IrStringConcatenation::class) {
+object IrStringConcatenationTypeChecker : IrElementChecker<IrStringConcatenation>(IrStringConcatenation::class) {
     override fun check(element: IrStringConcatenation, context: CheckerContext) {
         element.ensureTypeIs(context.irBuiltIns.stringType, context)
     }
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrTypeOperatorTypeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrTypeOperatorTypeChecker.kt
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.ir.expressions.IrTypeOperator
 import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
 import org.jetbrains.kotlin.ir.types.makeNullable
 
-internal object IrTypeOperatorTypeChecker : IrElementChecker<IrTypeOperatorCall>(IrTypeOperatorCall::class) {
+object IrTypeOperatorTypeChecker : IrElementChecker<IrTypeOperatorCall>(IrTypeOperatorCall::class) {
     override fun check(element: IrTypeOperatorCall, context: CheckerContext) {
         // TODO: check IMPLICIT_NOTNULL's argument type.
         val operator = element.operator
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrTypeOperatorTypeOperandChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrTypeOperatorTypeOperandChecker.kt
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.ir.expressions.IrTypeOperatorCall
 import org.jetbrains.kotlin.ir.types.isUnit
 import org.jetbrains.kotlin.ir.util.render
 
-internal object IrTypeOperatorTypeOperandChecker : IrElementChecker<IrTypeOperatorCall>(IrTypeOperatorCall::class) {
+object IrTypeOperatorTypeOperandChecker : IrElementChecker<IrTypeOperatorCall>(IrTypeOperatorCall::class) {
     override fun check(element: IrTypeOperatorCall, context: CheckerContext) {
         val operator = element.operator
         val typeOperand = element.typeOperand
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrUnitTypeExpressionChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrUnitTypeExpressionChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.backend.common.checkers.ensureTypeIs
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 
-internal object IrUnitTypeExpressionChecker : IrElementChecker<IrExpression>(IrExpression::class) {
+object IrUnitTypeExpressionChecker : IrElementChecker<IrExpression>(IrExpression::class) {
     override fun check(element: IrExpression, context: CheckerContext) {
         element.ensureTypeIs(context.irBuiltIns.unitType, context)
     }
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrValueAccessScopeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrValueAccessScopeChecker.kt
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.backend.common.checkers.IrElementChecker
 import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.ir.expressions.IrValueAccessExpression
 
-internal object IrValueAccessScopeChecker : IrElementChecker<IrValueAccessExpression>(IrValueAccessExpression::class) {
+object IrValueAccessScopeChecker : IrElementChecker<IrValueAccessExpression>(IrValueAccessExpression::class) {
     override fun check(element: IrValueAccessExpression, context: CheckerContext) {
         if (!context.valueSymbolScopeStack.isVisibleInCurrentScope(element.symbol)) {
             context.error(element, "The following expression references a value that is not available in the current scope.")
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrVarargTypesChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrVarargTypesChecker.kt
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.ir.expressions.IrVararg
 /**
  * Makes sure that [IrVararg.type] is an array of [IrVararg.varargElementType].
  */
-internal object IrVarargTypesChecker : IrElementChecker<IrVararg>(IrVararg::class) {
+object IrVarargTypesChecker : IrElementChecker<IrVararg>(IrVararg::class) {
     override fun check(element: IrVararg, context: CheckerContext) {
         validateVararg(element, element.type, element.varargElementType, context)
     }
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/symbol/IrVisibilityChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/symbol/IrVisibilityChecker.kt
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 
-internal object IrVisibilityChecker : IrSymbolChecker {
+object IrVisibilityChecker : IrSymbolChecker {
     override fun check(
         symbol: IrSymbol,
         container: IrElement,
diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/type/IrTypeParameterScopeChecker.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/type/IrTypeParameterScopeChecker.kt
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.ir.util.render
 /**
  * Makes sure that all the type parameter references are within the scope of the corresponding type parameters.
  */
-internal object IrTypeParameterScopeChecker : IrTypeChecker {
+object IrTypeParameterScopeChecker : IrTypeChecker {
     override fun check(
         type: IrType,
         container: IrElement,
