IR Validator: New checker for nested IR element offsets

^KT-81475

Author: ddolovov

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/convertToIr.kt

@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.ir.util.KotlinMangler
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.ir.validation.IrValidationError
 import org.jetbrains.kotlin.ir.validation.IrValidatorConfig
+import org.jetbrains.kotlin.ir.validation.checkers.IrNestedOffsetRangeChecker
 import org.jetbrains.kotlin.ir.validation.checkers.symbol.IrVisibilityChecker
 import org.jetbrains.kotlin.ir.validation.checkers.declaration.IrFieldVisibilityChecker
 import org.jetbrains.kotlin.ir.validation.checkers.declaration.IrExpressionBodyInFunctionChecker
@@ -513,6 +514,9 @@ private class Fir2IrPipeline(
                     // so visibility checks are only performed if requested via a flag, and in tests.
                     withCheckers(IrVisibilityChecker.Strict)
                 }
+                .applyIf(fir2IrConfiguration.irVerificationSettings.enableIrNestedOffsetsChecks) {
+                    withCheckers(IrNestedOffsetRangeChecker)
+                }
                 .applyIf(extension == null) {
                     // KT-80065: This checker is known to trigger on a lot of internal and external compiler plugins,
                     //  while most of them, somehow, work. It is disabled for now, not to cause too much breakage.

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConfiguration.kt

@@ -47,6 +47,7 @@ class Fir2IrConfiguration private constructor(
         val validateForKlibSerialization: Boolean,
         val enableIrVisibilityChecks: Boolean,
         val enableIrVarargTypesChecks: Boolean,
+        val enableIrNestedOffsetsChecks: Boolean,
     )
 
     companion object {
@@ -70,6 +71,7 @@ class Fir2IrConfiguration private constructor(
                     mode = compilerConfiguration.get(CommonConfigurationKeys.VERIFY_IR, IrVerificationMode.NONE),
                     enableIrVisibilityChecks = compilerConfiguration.enableIrVisibilityChecks,
                     enableIrVarargTypesChecks = compilerConfiguration.enableIrVarargTypesChecks,
+                    enableIrNestedOffsetsChecks = compilerConfiguration.enableIrNestedOffsetsChecks,
                     validateForKlibSerialization = false,
                 ),
                 carefulApproximationOfContravariantProjectionForSam = compilerConfiguration.get(JVMConfigurationKeys.SAM_CONVERSIONS) != JvmClosureGenerationScheme.CLASS
@@ -95,6 +97,7 @@ class Fir2IrConfiguration private constructor(
                     mode = compilerConfiguration.get(CommonConfigurationKeys.VERIFY_IR, IrVerificationMode.NONE),
                     enableIrVisibilityChecks = compilerConfiguration.enableIrVisibilityChecks,
                     enableIrVarargTypesChecks = compilerConfiguration.enableIrVarargTypesChecks,
+                    enableIrNestedOffsetsChecks = compilerConfiguration.enableIrNestedOffsetsChecks,
                     validateForKlibSerialization = true,
                 ),
                 carefulApproximationOfContravariantProjectionForSam = false,
@@ -121,6 +124,7 @@ class Fir2IrConfiguration private constructor(
                     mode = compilerConfiguration.get(CommonConfigurationKeys.VERIFY_IR, IrVerificationMode.NONE),
                     enableIrVisibilityChecks = compilerConfiguration.enableIrVisibilityChecks,
                     enableIrVarargTypesChecks = compilerConfiguration.enableIrVarargTypesChecks,
+                    enableIrNestedOffsetsChecks = compilerConfiguration.enableIrNestedOffsetsChecks,
                     validateForKlibSerialization = false,
                 ),
                 carefulApproximationOfContravariantProjectionForSam = compilerConfiguration.get(JVMConfigurationKeys.SAM_CONVERSIONS) != JvmClosureGenerationScheme.CLASS,

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/phaser/IrValidationPhase.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.backend.common.ModuleLoweringPass
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.validation.*
+import org.jetbrains.kotlin.ir.validation.checkers.IrNestedOffsetRangeChecker
 import org.jetbrains.kotlin.ir.validation.checkers.declaration.IrExpressionBodyInFunctionChecker
 import org.jetbrains.kotlin.ir.validation.checkers.declaration.IrFieldVisibilityChecker
 import org.jetbrains.kotlin.ir.validation.checkers.expression.InlineFunctionUseSiteChecker
@@ -45,6 +46,9 @@ abstract class IrValidationBeforeLoweringPhase<Context : LoweringContext>(contex
             .applyIf(context.configuration.enableIrVisibilityChecks) {
                 withCheckers(IrVisibilityChecker.Strict)
             }
+            .applyIf(context.configuration.enableIrNestedOffsetsChecks) {
+                withCheckers(IrNestedOffsetRangeChecker)
+            }
             .applyIf(context.configuration.enableIrVarargTypesChecks) {
                 withVarargChecks()
             }
@@ -74,6 +78,9 @@ class IrValidationAfterInliningOnlyPrivateFunctionsPhase<Context : LoweringConte
             .applyIf(context.configuration.enableIrVisibilityChecks) {
                 withCheckers(IrVisibilityChecker.Strict)
             }
+            .applyIf(context.configuration.enableIrNestedOffsetsChecks) {
+                withCheckers(IrNestedOffsetRangeChecker)
+            }
             //.withTypeChecks() // TODO: Re-enable checking types (KT-68663)
             .applyIf(context.configuration.enableIrVarargTypesChecks) {
                 withVarargChecks()
@@ -92,6 +99,9 @@ class IrValidationAfterInliningAllFunctionsOnTheSecondStagePhase<Context : Lower
             .applyIf(context.configuration.enableIrVisibilityChecks) {
                 withCheckers(IrVisibilityChecker.Relaxed, IrCrossFileFieldUsageChecker, IrValueAccessScopeChecker)
             }
+            .applyIf(context.configuration.enableIrNestedOffsetsChecks) {
+                withCheckers(IrNestedOffsetRangeChecker)
+            }
             .applyIf(context.configuration.enableIrVarargTypesChecks) {
                 withVarargChecks()
             }
@@ -112,4 +122,7 @@ open class IrValidationAfterLoweringPhase<Context : LoweringContext>(context: Co
     override val defaultValidationConfig: IrValidatorConfig
         get() = IrValidatorConfig(checkTreeConsistency = true)
             .withBasicChecks()
+            .applyIf(context.configuration.enableIrNestedOffsetsChecks) {
+                withCheckers(IrNestedOffsetRangeChecker)
+            }
 }

compiler/ir/ir.validation/src/org/jetbrains/kotlin/ir/validation/IrValidatorConfig.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.ir.validation
 
 import org.jetbrains.kotlin.ir.validation.checkers.IrChecker
+import org.jetbrains.kotlin.ir.validation.checkers.IrNestedOffsetRangeChecker
 import org.jetbrains.kotlin.ir.validation.checkers.IrOffsetsChecker
 import org.jetbrains.kotlin.ir.validation.checkers.declaration.*
 import org.jetbrains.kotlin.ir.validation.checkers.expression.*
@@ -64,5 +65,6 @@ fun IrValidatorConfig.withAllChecks() = withBasicChecks()
         IrTypeParameterScopeChecker,
         IrCrossFileFieldUsageChecker,
         IrFieldVisibilityChecker,
-        IrExpressionBodyInFunctionChecker
+        IrExpressionBodyInFunctionChecker,
+        IrNestedOffsetRangeChecker,
     )

compiler/ir/ir.validation/src/org/jetbrains/kotlin/ir/validation/checkers/IrNestedOffsetRangeChecker.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.ir.validation.checkers
+
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.util.render
+import org.jetbrains.kotlin.ir.validation.checkers.context.CheckerContext
+import org.jetbrains.kotlin.ir.validation.checkers.context.ContextUpdater
+import org.jetbrains.kotlin.ir.validation.checkers.context.OffsetRange
+import org.jetbrains.kotlin.ir.validation.checkers.context.OffsetRangeChainUpdater
+
+object IrNestedOffsetRangeChecker : IrElementChecker<IrElement>(IrElement::class) {
+    override val requiredContextUpdaters: Set<ContextUpdater>
+        get() = setOf(OffsetRangeChainUpdater)
+
+    override fun check(
+        element: IrElement,
+        context: CheckerContext,
+    ) {
+        val outerRange = context.offsetRanges.lastOrNull() ?: return
+        val currentRange = OffsetRange.createIfRealValidOffsets(element, useOwnOffsetsOfInlinedFunctionBlock = true) ?: return
+
+        if (currentRange !in outerRange)
+            context.error(
+                element,
+                "The offsets range $currentRange is not within the outer offsets range $outerRange (owner = ${outerRange.owner.render()})"
+            )
+    }
+}

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

@@ -26,6 +26,7 @@ class CheckerContext(
     val parentChain: MutableList<IrElement> = mutableListOf()
     val typeParameterScopeStack = ScopeStack<IrTypeParameterSymbol>()
     val valueSymbolScopeStack = ScopeStack<IrValueSymbol>()
+    val offsetRanges: MutableList<OffsetRange> = mutableListOf()
 
     var withinAnnotationUsageSubTree: Boolean = false
         private set

compiler/ir/ir.validation/src/org/jetbrains/kotlin/ir/validation/checkers/context/OffsetRangeChainUpdater.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.ir.validation.checkers.context
+
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.expressions.IrInlinedFunctionBlock
+import org.jetbrains.kotlin.ir.validation.temporarilyPushing
+
+object OffsetRangeChainUpdater : ContextUpdater {
+    override fun runInNewContext(
+        context: CheckerContext,
+        element: IrElement,
+        block: () -> Unit,
+    ) {
+        OffsetRange.createIfRealValidOffsets(element, useOwnOffsetsOfInlinedFunctionBlock = false)?.let { newOffsetBoundaries ->
+            context.offsetRanges.temporarilyPushing(newOffsetBoundaries) {
+                block()
+            }
+        } ?: block()
+    }
+}
+
+class OffsetRange private constructor(val owner: IrElement, val startOffset: Int, val endOffset: Int) {
+    operator fun contains(other: OffsetRange): Boolean = startOffset <= other.startOffset && endOffset >= other.endOffset
+
+    override fun toString() = "[$startOffset:$endOffset]"
+
+    companion object {
+        fun createIfRealValidOffsets(element: IrElement, useOwnOffsetsOfInlinedFunctionBlock: Boolean): OffsetRange? =
+            if (useOwnOffsetsOfInlinedFunctionBlock || element !is IrInlinedFunctionBlock)
+                createIfRealValidOffsets(element, element.startOffset, element.endOffset)
+            else
+                createIfRealValidOffsets(element, element.inlinedFunctionStartOffset, element.inlinedFunctionEndOffset)
+
+        private fun createIfRealValidOffsets(owner: IrElement, startOffset: Int, endOffset: Int): OffsetRange? =
+            if (startOffset in 0..endOffset) OffsetRange(owner, startOffset, endOffset) else null
+    }
+}