ForLoopsLowering: Move isLastInclusive to HeaderInfo.

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

@@ -67,6 +67,7 @@ internal sealed class NumericHeaderInfo(
     val first: IrExpression,
     val last: IrExpression,
     val step: IrExpression,
+    val isLastInclusive: Boolean,
     val canCacheLast: Boolean,
     val isReversed: Boolean,
     val direction: ProgressionDirection,
@@ -79,13 +80,14 @@ internal class ProgressionHeaderInfo(
     first: IrExpression,
     last: IrExpression,
     step: IrExpression,
+    isLastInclusive: Boolean = true,
     isReversed: Boolean = false,
     canOverflow: Boolean? = null,
     direction: ProgressionDirection,
     additionalNotEmptyCondition: IrExpression? = null,
     val additionalStatements: List<IrStatement> = listOf()
 ) : NumericHeaderInfo(
-    progressionType, first, last, step,
+    progressionType, first, last, step, isLastInclusive,
     canCacheLast = true,
     isReversed = isReversed,
     direction = direction,
@@ -152,16 +154,22 @@ internal class ProgressionHeaderInfo(
         }
     }
 
-    override fun asReversed() = ProgressionHeaderInfo(
+    override fun asReversed() = if (isLastInclusive) {
-        progressionType = progressionType,
+        ProgressionHeaderInfo(
-        first = last,
+            progressionType = progressionType,
-        last = first,
+            first = last,
-        step = step.negate(),
+            last = first,
-        isReversed = !isReversed,
+            step = step.negate(),
-        direction = direction.asReversed(),
+            isReversed = !isReversed,
-        additionalNotEmptyCondition = additionalNotEmptyCondition,
+            direction = direction.asReversed(),
-        additionalStatements = additionalStatements
+            additionalNotEmptyCondition = additionalNotEmptyCondition,
-    )
+            additionalStatements = additionalStatements
+        )
+    } else {
+        // If reversed, we would have a "first-exclusive" loop. We are currently not supporting this since it would add more complexity
+        // due to possible overflow when pre-incrementing the loop variable (see KT-42533).
+        null
+    }
 }
 
 /**
@@ -177,10 +185,8 @@ internal class IndexedGetHeaderInfo(
     val objectVariable: IrVariable,
     val expressionHandler: IndexedGetIterationHandler
 ) : NumericHeaderInfo(
-    IntProgressionType(symbols),
+    IntProgressionType(symbols), first, last, step,
-    first,
+    isLastInclusive = false,
-    last,
-    step,
     canCacheLast = canCacheLast,
     isReversed = false,
     direction = ProgressionDirection.INCREASING,

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

@@ -59,8 +59,7 @@ internal interface ForLoopHeader {
 internal abstract class NumericForLoopHeader<T : NumericHeaderInfo>(
     protected val headerInfo: T,
     builder: DeclarationIrBuilder,
-    context: CommonBackendContext,
+    context: CommonBackendContext
-    protected val isLastInclusive: Boolean
 ) : ForLoopHeader {
 
     override val consumesLoopVariableComponents = false
@@ -160,7 +159,7 @@ internal abstract class NumericForLoopHeader<T : NumericHeaderInfo>(
                 // Bounds are signed for unsigned progressions but bound comparisons should be done as unsigned, to ensure that the
                 // correct comparison function is used (`UInt/ULongCompare`). Also, `compareTo` must be used for UInt/ULong;
                 // they don't have intrinsic comparison operators.
-                val intCompFun = if (isLastInclusive) {
+                val intCompFun = if (headerInfo.isLastInclusive) {
                     builtIns.lessOrEqualFunByOperandType.getValue(builtIns.intClass)
                 } else {
                     builtIns.lessFunByOperandType.getValue(builtIns.intClass)
@@ -174,7 +173,7 @@ internal abstract class NumericForLoopHeader<T : NumericHeaderInfo>(
                 } else null
 
                 val elementCompFun =
-                    if (isLastInclusive) {
+                    if (headerInfo.isLastInclusive) {
                         builtIns.lessOrEqualFunByOperandType[elementClass.symbol]
                     } else {
                         builtIns.lessFunByOperandType[elementClass.symbol]
@@ -249,7 +248,7 @@ internal class ProgressionLoopHeader(
     headerInfo: ProgressionHeaderInfo,
     builder: DeclarationIrBuilder,
     context: CommonBackendContext
-) : NumericForLoopHeader<ProgressionHeaderInfo>(headerInfo, builder, context, isLastInclusive = true) {
+) : NumericForLoopHeader<ProgressionHeaderInfo>(headerInfo, builder, context) {
 
     // For this loop:
     //
@@ -374,7 +373,7 @@ internal class IndexedGetLoopHeader(
     headerInfo: IndexedGetHeaderInfo,
     builder: DeclarationIrBuilder,
     context: CommonBackendContext
-) : NumericForLoopHeader<IndexedGetHeaderInfo>(headerInfo, builder, context, isLastInclusive = false) {
+) : NumericForLoopHeader<IndexedGetHeaderInfo>(headerInfo, builder, context) {
 
     override val loopInitStatements =
         listOfNotNull(headerInfo.objectVariable, inductionVariable, lastVariableIfCanCacheLast, stepVariable)