[IR] Extract inline callsite validation callback to the checker

Author: mcpiroman

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/IrValidator.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.IrTreeSymbolsVisitor
@@ -52,23 +51,6 @@ data class IrValidatorConfig(
     val checkOverridePrivateDeclaration: Boolean = true,
 )
 
-fun interface InlineFunctionUseSiteChecker {
-    /**
-     * Check if the given use site of the inline function is permitted at the current phase of IR validation.
-     *
-     * Example 1: Check use sites after inlining all private functions.
-     *   It is permitted to have only use sites of non-private functions in the whole IR tree. So, for a use site
-     *   of a private inline function we should return `false` if it is met in the IR. For any other use site
-     *   we should return `true` (== permitted).
-     *
-     * Example 2: Check use sites after inlining all functions.
-     *   Normally, no use sites of inline functions should remain in the whole IR tree. So, if we met one we shall
-     *   return `false` (== not permitted). However, there are a few exceptions that are temporarily permitted.
-     *   For example, `inline external` intrinsics in Native (KT-66734).
-     */
-    fun isPermitted(inlineFunctionUseSite: IrFunctionAccessExpression): Boolean
-}
-
 private class IrValidator(
     val validatorConfig: IrValidatorConfig,
     val irBuiltIns: IrBuiltIns,
@@ -78,15 +60,15 @@ private class IrValidator(
         throw IllegalStateException("IR validation must start from files, modules, or declarations")
 
     override fun visitFile(declaration: IrFile) {
-        val context = CheckerContext(irBuiltIns, validatorConfig.checkInlineFunctionUseSites, declaration, reportError)
+        val context = CheckerContext(irBuiltIns, declaration, reportError)
         val fileValidator = IrFileValidator(validatorConfig, context)
         declaration.acceptVoid(fileValidator)
     }
 
     override fun visitModuleFragment(declaration: IrModuleFragment) = declaration.acceptChildrenVoid(this)
 
     override fun visitDeclaration(declaration: IrDeclarationBase) {
-        val context = CheckerContext(irBuiltIns, validatorConfig.checkInlineFunctionUseSites, declaration.file, reportError)
+        val context = CheckerContext(irBuiltIns, declaration.file, reportError)
         val fileValidator = IrFileValidator(validatorConfig, context)
         declaration.acceptVoid(fileValidator)
     }
@@ -98,7 +80,7 @@ private class IrFileValidator(
 ) : IrTreeSymbolsVisitor() {
     private val contextUpdaters: MutableSet<ContextUpdater> = mutableSetOf(ParentChainUpdater)
     private val elementCheckers: MutableList<IrElementChecker<*>> = mutableListOf(
-        IrNoInlineUseSitesChecker, IrSetValueAssignabilityChecker,
+        IrSetValueAssignabilityChecker,
         IrFunctionDispatchReceiverChecker, IrFunctionParametersChecker, IrConstructorReceiverChecker,
         IrTypeOperatorTypeOperandChecker,
         IrPropertyAccessorsChecker, IrFunctionPropertiesChecker,
@@ -144,6 +126,9 @@ private class IrFileValidator(
         if (config.checkOverridePrivateDeclaration) {
             elementCheckers.add(IrPrivateDeclarationOverrideChecker)
         }
+        config.checkInlineFunctionUseSites?.let {
+            elementCheckers.add(IrNoInlineUseSitesChecker(it))
+        }
 
         for (checker in elementCheckers + symbolCheckers + typeCheckers) {
             contextUpdaters += checker.requiredContextUpdaters

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/CheckerUtils.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.backend.common.checkers
 
-import org.jetbrains.kotlin.backend.common.InlineFunctionUseSiteChecker
+import org.jetbrains.kotlin.backend.common.checkers.expression.InlineFunctionUseSiteChecker
 import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibilities
@@ -15,8 +15,6 @@ import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
-import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression
-import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.DescriptorlessExternalPackageFragmentSymbol
 import org.jetbrains.kotlin.ir.types.*

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/context/CheckerContext.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.backend.common.checkers.context
 
-import org.jetbrains.kotlin.backend.common.InlineFunctionUseSiteChecker
 import org.jetbrains.kotlin.backend.common.ReportIrValidationError
 import org.jetbrains.kotlin.backend.common.ScopeStack
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
@@ -20,7 +19,6 @@ import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
 
 class CheckerContext(
     val irBuiltIns: IrBuiltIns,
-    val checkInlineFunctionUseSites: InlineFunctionUseSiteChecker?,
     val file: IrFile,
     private val reportError: ReportIrValidationError,
 ) {

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/checkers/expression/IrNoInlineUseSitesChecker.kt

@@ -10,10 +10,27 @@ import org.jetbrains.kotlin.backend.common.checkers.checkFunctionUseSite
 import org.jetbrains.kotlin.backend.common.checkers.context.CheckerContext
 import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression
 
-object IrNoInlineUseSitesChecker : IrElementChecker<IrFunctionAccessExpression>(IrFunctionAccessExpression::class) {
+fun interface InlineFunctionUseSiteChecker {
+    /**
+     * Check if the given use site of the inline function is permitted at the current phase of IR validation.
+     *
+     * Example 1: Check use sites after inlining all private functions.
+     *   It is permitted to have only use sites of non-private functions in the whole IR tree. So, for a use site
+     *   of a private inline function we should return `false` if it is met in the IR. For any other use site
+     *   we should return `true` (== permitted).
+     *
+     * Example 2: Check use sites after inlining all functions.
+     *   Normally, no use sites of inline functions should remain in the whole IR tree. So, if we met one we shall
+     *   return `false` (== not permitted). However, there are a few exceptions that are temporarily permitted.
+     *   For example, `inline external` intrinsics in Native (KT-66734).
+     */
+    fun isPermitted(inlineFunctionUseSite: IrFunctionAccessExpression): Boolean
+}
+
+class IrNoInlineUseSitesChecker(
+    private val inlineFunctionUseSiteChecker: InlineFunctionUseSiteChecker
+) : IrElementChecker<IrFunctionAccessExpression>(IrFunctionAccessExpression::class) {
     override fun check(element: IrFunctionAccessExpression, context: CheckerContext) {
-        context.checkInlineFunctionUseSites?.let {
-            checkFunctionUseSite(element, it, context)
-        }
+        checkFunctionUseSite(element, inlineFunctionUseSiteChecker, context)
     }
-}
+}