Maintain bounds evaluation order in intrinsics for 'reversed'

Makes sense for 'rangeTo', 'downTo', and 'until' with non-const bounds.

compiler/backend/src/org/jetbrains/kotlin/codegen/range/DownToProgressionRangeValue.kt

@@ -43,7 +43,10 @@ class DownToProgressionRangeValue(rangeCall: ResolvedCall<out CallableDescriptor
 
     override fun createForInReversedLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             createConstBoundedForInReversedDownToGenerator(codegen, forExpression) ?:
-            ForInSimpleProgressionLoopGenerator.fromBoundedValueWithStep1(codegen, forExpression, getBoundedValue(codegen))
+            ForInSimpleProgressionLoopGenerator.fromBoundedValueWithStep1(
+                    codegen, forExpression, getBoundedValue(codegen),
+                    inverseBoundsEvaluationOrder = true
+            )
 
     private fun createConstBoundedForInDownToGenerator(
             codegen: ExpressionCodegen,

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberRangeLiteralRangeValue.kt

@@ -41,7 +41,10 @@ class PrimitiveNumberRangeLiteralRangeValue(
 
     override fun createForInReversedLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression): ForLoopGenerator =
             createConstBoundedRangeForInReversedRangeLiteralGenerator(codegen, forExpression) ?:
-            ForInSimpleProgressionLoopGenerator.fromBoundedValueWithStepMinus1(codegen, forExpression, getBoundedValue(codegen))
+            ForInSimpleProgressionLoopGenerator.fromBoundedValueWithStepMinus1(
+                    codegen, forExpression, getBoundedValue(codegen),
+                    inverseBoundsEvaluationOrder = true
+            )
 
     private fun createConstBoundedForInRangeLiteralGenerator(
             codegen: ExpressionCodegen,

compiler/backend/src/org/jetbrains/kotlin/codegen/range/PrimitiveNumberUntilRangeValue.kt

@@ -36,7 +36,10 @@ class PrimitiveNumberUntilRangeValue(rangeCall: ResolvedCall<out CallableDescrip
 
     override fun createForInReversedLoopGenerator(codegen: ExpressionCodegen, forExpression: KtForExpression) =
             createConstBoundedForInReversedUntilGenerator(codegen, forExpression) ?:
-            ForInSimpleProgressionLoopGenerator.fromBoundedValueWithStepMinus1(codegen, forExpression, getBoundedValue(codegen))
+            ForInSimpleProgressionLoopGenerator.fromBoundedValueWithStepMinus1(
+                    codegen, forExpression, getBoundedValue(codegen),
+                    inverseBoundsEvaluationOrder = true
+            )
 
     private fun createConstBoundedForInReversedUntilGenerator(
             codegen: ExpressionCodegen,

compiler/backend/src/org/jetbrains/kotlin/codegen/range/forLoop/ForInSimpleProgressionLoopGenerator.kt

@@ -30,6 +30,7 @@ class ForInSimpleProgressionLoopGenerator(
         private val isStartInclusive: Boolean,
         private val endValue: StackValue,
         private val isEndInclusive: Boolean,
+        private val inverseBoundsEvaluationOrder: Boolean,
         step: Int
 ) : AbstractForInRangeLoopGenerator(codegen, forExpression, step) {
 
@@ -37,6 +38,7 @@ class ForInSimpleProgressionLoopGenerator(
             codegen: ExpressionCodegen,
             forExpression: KtForExpression,
             boundedValue: SimpleBoundedValue,
+            inverseBoundsEvaluationOrder: Boolean,
             step: Int
     ) : this(
             codegen, forExpression,
@@ -44,23 +46,40 @@ class ForInSimpleProgressionLoopGenerator(
             isStartInclusive = if (step == 1) boundedValue.isLowInclusive else boundedValue.isHighInclusive,
             endValue = if (step == 1) boundedValue.highBound else boundedValue.lowBound,
             isEndInclusive = if (step == 1) boundedValue.isHighInclusive else boundedValue.isLowInclusive,
+            inverseBoundsEvaluationOrder = inverseBoundsEvaluationOrder,
             step = step
     )
 
     companion object {
-        fun fromBoundedValueWithStep1(codegen: ExpressionCodegen, forExpression: KtForExpression, boundedValue: SimpleBoundedValue) =
-                ForInSimpleProgressionLoopGenerator(codegen, forExpression, boundedValue, 1)
+        fun fromBoundedValueWithStep1(
+                codegen: ExpressionCodegen,
+                forExpression: KtForExpression,
+                boundedValue: SimpleBoundedValue,
+                inverseBoundsEvaluationOrder: Boolean = false
+        ) =
+                ForInSimpleProgressionLoopGenerator(codegen, forExpression, boundedValue, inverseBoundsEvaluationOrder, 1)
 
-        fun fromBoundedValueWithStepMinus1(codegen: ExpressionCodegen, forExpression: KtForExpression, boundedValue: SimpleBoundedValue) =
-                ForInSimpleProgressionLoopGenerator(codegen, forExpression, boundedValue, -1)
+        fun fromBoundedValueWithStepMinus1(
+                codegen: ExpressionCodegen,
+                forExpression: KtForExpression,
+                boundedValue: SimpleBoundedValue,
+                inverseBoundsEvaluationOrder: Boolean = false
+        ) =
+                ForInSimpleProgressionLoopGenerator(codegen, forExpression, boundedValue, inverseBoundsEvaluationOrder, -1)
     }
 
     override fun storeRangeStartAndEnd() {
-        loopParameter().store(startValue, v)
+        if (inverseBoundsEvaluationOrder) {
+            StackValue.local(endVar, asmElementType).store(endValue, v)
+            loopParameter().store(startValue, v)
+        }
+        else {
+            loopParameter().store(startValue, v)
+            StackValue.local(endVar, asmElementType).store(endValue, v)
+        }
+
         // Skip 1st element if start is not inclusive.
         if (!isStartInclusive) incrementLoopVariable()
-
-        StackValue.local(endVar, asmElementType).store(endValue, v)
     }
 
     override fun checkEmptyLoop(loopExit: Label) {