Add range iteration tests for rangeUntil

#KT-52932

compiler/testData/codegen/box/ranges/expression/openRangeUntil.kt

@@ -0,0 +1,60 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// !LANGUAGE: +RangeUntilOperator
+// WITH_STDLIB
+
+
+
+@OptIn(ExperimentalStdlibApi::class)
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 1..<5
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(1, 2, 3, 4)) {
+        return "Wrong elements for 1..<5: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 1.toByte()..<5.toByte()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(1, 2, 3, 4)) {
+        return "Wrong elements for 1.toByte()..<5.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 1.toShort()..<5.toShort()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(1, 2, 3, 4)) {
+        return "Wrong elements for 1.toShort()..<5.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 1L..<5L
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(1, 2, 3, 4)) {
+        return "Wrong elements for 1L..<5L: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'a'..<'d'
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('a', 'b', 'c')) {
+        return "Wrong elements for 'a'..<'d': $list5"
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/expression/overflowZeroToMinValue.kt

@@ -1,4 +1,5 @@
 // Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// !LANGUAGE: +RangeUntilOperator
 // WITH_STDLIB
 
 
@@ -7,6 +8,7 @@ val MinB = Byte.MIN_VALUE
 val MinS = Short.MIN_VALUE
 val MinL = Long.MIN_VALUE
 
+@OptIn(ExperimentalStdlibApi::class)
 fun box(): String {
     val list1 = ArrayList<Int>()
     val range1 = 0.toByte()..MinB step 3
@@ -88,5 +90,45 @@ fun box(): String {
         return "Wrong elements for 0L until MinL step 3: $list8"
     }
 
+    val list9 = ArrayList<Int>()
+    val range9 = 0.toByte()..<MinB step 3
+    for (i in range9) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<Int>()) {
+        return "Wrong elements for 0.toByte()..<MinB step 3: $list9"
+    }
+
+    val list10 = ArrayList<Int>()
+    val range10 = 0.toShort()..<MinS step 3
+    for (i in range10) {
+        list10.add(i)
+        if (list10.size > 23) break
+    }
+    if (list10 != listOf<Int>()) {
+        return "Wrong elements for 0.toShort()..<MinS step 3: $list10"
+    }
+
+    val list11 = ArrayList<Int>()
+    val range11 = 0..<MinI step 3
+    for (i in range11) {
+        list11.add(i)
+        if (list11.size > 23) break
+    }
+    if (list11 != listOf<Int>()) {
+        return "Wrong elements for 0..<MinI step 3: $list11"
+    }
+
+    val list12 = ArrayList<Long>()
+    val range12 = 0L..<MinL step 3
+    for (i in range12) {
+        list12.add(i)
+        if (list12.size > 23) break
+    }
+    if (list12 != listOf<Long>()) {
+        return "Wrong elements for 0L..<MinL step 3: $list12"
+    }
+
     return "OK"
 }

compiler/testData/codegen/box/ranges/literal/openRangeUntil.kt

@@ -0,0 +1,55 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// !LANGUAGE: +RangeUntilOperator
+// WITH_STDLIB
+
+
+
+@OptIn(ExperimentalStdlibApi::class)
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 1..<5) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(1, 2, 3, 4)) {
+        return "Wrong elements for 1..<5: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 1.toByte()..<5.toByte()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(1, 2, 3, 4)) {
+        return "Wrong elements for 1.toByte()..<5.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 1.toShort()..<5.toShort()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(1, 2, 3, 4)) {
+        return "Wrong elements for 1.toShort()..<5.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 1L..<5L) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(1, 2, 3, 4)) {
+        return "Wrong elements for 1L..<5L: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'a'..<'d') {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('a', 'b', 'c')) {
+        return "Wrong elements for 'a'..<'d': $list5"
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/literal/overflowZeroToMinValue.kt

@@ -1,4 +1,5 @@
 // Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// !LANGUAGE: +RangeUntilOperator
 // WITH_STDLIB
 
 
@@ -7,6 +8,7 @@ val MinB = Byte.MIN_VALUE
 val MinS = Short.MIN_VALUE
 val MinL = Long.MIN_VALUE
 
+@OptIn(ExperimentalStdlibApi::class)
 fun box(): String {
     val list1 = ArrayList<Int>()
     for (i in 0.toByte()..MinB step 3) {
@@ -80,5 +82,41 @@ fun box(): String {
         return "Wrong elements for 0L until MinL step 3: $list8"
     }
 
+    val list9 = ArrayList<Int>()
+    for (i in 0.toByte()..<MinB step 3) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<Int>()) {
+        return "Wrong elements for 0.toByte()..<MinB step 3: $list9"
+    }
+
+    val list10 = ArrayList<Int>()
+    for (i in 0.toShort()..<MinS step 3) {
+        list10.add(i)
+        if (list10.size > 23) break
+    }
+    if (list10 != listOf<Int>()) {
+        return "Wrong elements for 0.toShort()..<MinS step 3: $list10"
+    }
+
+    val list11 = ArrayList<Int>()
+    for (i in 0..<MinI step 3) {
+        list11.add(i)
+        if (list11.size > 23) break
+    }
+    if (list11 != listOf<Int>()) {
+        return "Wrong elements for 0..<MinI step 3: $list11"
+    }
+
+    val list12 = ArrayList<Long>()
+    for (i in 0L..<MinL step 3) {
+        list12.add(i)
+        if (list12.size > 23) break
+    }
+    if (list12 != listOf<Long>()) {
+        return "Wrong elements for 0L..<MinL step 3: $list12"
+    }
+
     return "OK"
 }

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/emptyProgression.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 2..<2
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertTrue(intList.isEmpty())
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 2L..<2L
+    for (i in longProgression step 2L) {
+        longList += i
+    }
+    assertTrue(longList.isEmpty())
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'b'..<'b'
+    for (i in charProgression step 2) {
+        charList += i
+    }
+    assertTrue(charList.isEmpty())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepNegative.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 1..<8
+        for (i in intProgression step -1) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 1L..<8L
+        for (i in longProgression step -1L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'a'..<'h'
+        for (i in charProgression step -1) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepThenLegalStep.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 1..<8
+        for (i in intProgression step 0 step 2) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 1L..<8L
+        for (i in longProgression step 0L step 2L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'a'..<'h'
+        for (i in charProgression step 0 step 2) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepZero.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 1..<8
+        for (i in intProgression step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 1L..<8L
+        for (i in longProgression step 0L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'a'..<'h'
+        for (i in charProgression step 0) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/legalStepThenIllegalStep.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 1..<8
+        for (i in intProgression step 2 step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 1L..<8L
+        for (i in longProgression step 2L step 0L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'a'..<'h'
+        for (i in charProgression step 2 step 0) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<5
+    for (i in intProgression step 1 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<5L
+    for (i in longProgression step 1L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'e'
+    for (i in charProgression step 1 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'b', 'c', 'd'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepThenSameStep.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<9
+    for (i in intProgression step 2 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<9L
+    for (i in longProgression step 2L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'i'
+    for (i in charProgression step 2 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<6
+    for (i in intProgression step 2 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4, 5), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<6L
+    for (i in longProgression step 2L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L, 5L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'f'
+    for (i in charProgression step 2 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'b', 'c', 'd', 'e'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<8
+    for (i in intProgression step 3 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<8L
+    for (i in longProgression step 3L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'h'
+    for (i in charProgression step 3 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<11
+    for (i in intProgression step 3 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7, 9), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<11L
+    for (i in longProgression step 3L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L, 9L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'k'
+    for (i in charProgression step 3 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g', 'i'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<7
+    for (i in intProgression step 2 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4, 5), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<7L
+    for (i in longProgression step 2L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L, 5L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'g'
+    for (i in charProgression step 2 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'b', 'c', 'd', 'e'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<9
+    for (i in intProgression step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(1, 4, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<9L
+    for (i in longProgression step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 4L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'i'
+    for (i in charProgression step 2 step 3) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'd', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<11
+    for (i in intProgression step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(1, 4, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<11L
+    for (i in longProgression step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 4L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'k'
+    for (i in charProgression step 2 step 3) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'd', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStep.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<9
+    for (i in intProgression.reversed() step 2) {
+        intList += i
+    }
+    assertEquals(listOf(8, 6, 4, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<9L
+    for (i in longProgression.reversed() step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(8L, 6L, 4L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'i'
+    for (i in charProgression.reversed() step 2) {
+        charList += i
+    }
+    assertEquals(listOf('h', 'f', 'd', 'b'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<9
+    for (i in (intProgression.reversed() step 2).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(2, 4, 6, 8), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<9L
+    for (i in (longProgression.reversed() step 2L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(2L, 4L, 6L, 8L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'i'
+    for (i in (charProgression.reversed() step 2).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('b', 'd', 'f', 'h'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<11
+    for (i in (intProgression.reversed() step 2).reversed() step 3) {
+        intList += i
+    }
+    assertEquals(listOf(2, 5, 8), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<11L
+    for (i in (longProgression.reversed() step 2L).reversed() step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(2L, 5L, 8L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'k'
+    for (i in (charProgression.reversed() step 2).reversed() step 3) {
+        charList += i
+    }
+    assertEquals(listOf('b', 'e', 'h'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversed.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<9
+    for (i in (intProgression step 2).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(7, 5, 3, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<9L
+    for (i in (longProgression step 2L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(7L, 5L, 3L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'i'
+    for (i in (charProgression step 2).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('g', 'e', 'c', 'a'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStep.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<11
+    for (i in (intProgression step 2).reversed() step 3) {
+        intList += i
+    }
+    assertEquals(listOf(9, 6, 3), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<11L
+    for (i in (longProgression step 2L).reversed() step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(9L, 6L, 3L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'k'
+    for (i in (charProgression step 2).reversed() step 3) {
+        charList += i
+    }
+    assertEquals(listOf('i', 'f', 'c'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<11
+    for (i in ((intProgression step 2).reversed() step 3).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(3, 6, 9), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<11L
+    for (i in ((longProgression step 2L).reversed() step 3L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(3L, 6L, 9L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'k'
+    for (i in ((charProgression step 2).reversed() step 3).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('c', 'f', 'i'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/singleElementStepTwo.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<2
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<2L
+    for (i in longProgression step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'b'
+    for (i in charProgression step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepOne.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<5
+    for (i in intProgression step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<5L
+    for (i in longProgression step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'e'
+    for (i in charProgression step 1) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'b', 'c', 'd'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToOutsideRange.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<8
+    for (i in intProgression step 7) {
+        intList += i
+    }
+    assertEquals(listOf(1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<8L
+    for (i in longProgression step 7L) {
+        longList += i
+    }
+    assertEquals(listOf(1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'h'
+    for (i in charProgression step 7) {
+        charList += i
+    }
+    assertEquals(listOf('a'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSameLast.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<8
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<8L
+    for (i in longProgression step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'h'
+    for (i in charProgression step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSmallerLast.kt

@@ -0,0 +1,30 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..<9
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..<9L
+    for (i in longProgression step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..<'i'
+    for (i in charProgression step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/emptyProgression.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 2..<2 step 2) {
+        intList += i
+    }
+    assertTrue(intList.isEmpty())
+
+    val longList = mutableListOf<Long>()
+    for (i in 2L..<2L step 2L) {
+        longList += i
+    }
+    assertTrue(longList.isEmpty())
+
+    val charList = mutableListOf<Char>()
+    for (i in 'b'..<'b' step 2) {
+        charList += i
+    }
+    assertTrue(charList.isEmpty())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepNegative.kt

@@ -0,0 +1,26 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// KT-34166: Translation of loop over literal completely removes the validation of step
+// DONT_TARGET_EXACT_BACKEND: JS
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1..<8 step -1) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1L..<8L step -1L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 'a'..<'h' step -1) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepThenLegalStep.kt

@@ -0,0 +1,24 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1..<8 step 0 step 2) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1L..<8L step 0L step 2L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 'a'..<'h' step 0 step 2) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepZero.kt

@@ -0,0 +1,26 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// KT-34166: Translation of loop over literal completely removes the validation of step
+// DONT_TARGET_EXACT_BACKEND: JS
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1..<8 step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1L..<8L step 0L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 'a'..<'h' step 0) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/legalStepThenIllegalStep.kt

@@ -0,0 +1,24 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1..<8 step 2 step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1L..<8L step 2L step 0L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 'a'..<'h' step 2 step 0) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<5 step 1 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<5L step 1L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'e' step 1 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'b', 'c', 'd'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepThenSameStep.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<9 step 2 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<9L step 2L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'i' step 2 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<6 step 2 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4, 5), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<6L step 2L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L, 5L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'f' step 2 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'b', 'c', 'd', 'e'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<8 step 3 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<8L step 3L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'h' step 3 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<11 step 3 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7, 9), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<11L step 3L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L, 9L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'k' step 3 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g', 'i'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<7 step 2 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4, 5), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<7L step 2L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L, 5L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'g' step 2 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'b', 'c', 'd', 'e'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<9 step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(1, 4, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<9L step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 4L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'i' step 2 step 3) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'd', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<11 step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(1, 4, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<11L step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 4L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'k' step 2 step 3) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'd', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStep.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in (1..<9).reversed() step 2) {
+        intList += i
+    }
+    assertEquals(listOf(8, 6, 4, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in (1L..<9L).reversed() step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(8L, 6L, 4L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in ('a'..<'i').reversed() step 2) {
+        charList += i
+    }
+    assertEquals(listOf('h', 'f', 'd', 'b'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in ((1..<9).reversed() step 2).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(2, 4, 6, 8), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in ((1L..<9L).reversed() step 2L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(2L, 4L, 6L, 8L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in (('a'..<'i').reversed() step 2).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('b', 'd', 'f', 'h'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in ((1..<11).reversed() step 2).reversed() step 3) {
+        intList += i
+    }
+    assertEquals(listOf(2, 5, 8), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in ((1L..<11L).reversed() step 2L).reversed() step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(2L, 5L, 8L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in (('a'..<'k').reversed() step 2).reversed() step 3) {
+        charList += i
+    }
+    assertEquals(listOf('b', 'e', 'h'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversed.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in (1..<9 step 2).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(7, 5, 3, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in (1L..<9L step 2L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(7L, 5L, 3L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in ('a'..<'i' step 2).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('g', 'e', 'c', 'a'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStep.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in (1..<11 step 2).reversed() step 3) {
+        intList += i
+    }
+    assertEquals(listOf(9, 6, 3), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in (1L..<11L step 2L).reversed() step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(9L, 6L, 3L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in ('a'..<'k' step 2).reversed() step 3) {
+        charList += i
+    }
+    assertEquals(listOf('i', 'f', 'c'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in ((1..<11 step 2).reversed() step 3).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(3, 6, 9), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in ((1L..<11L step 2L).reversed() step 3L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(3L, 6L, 9L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in (('a'..<'k' step 2).reversed() step 3).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('c', 'f', 'i'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/singleElementStepTwo.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<2 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<2L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'b' step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepOne.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<5 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<5L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'e' step 1) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'b', 'c', 'd'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToOutsideRange.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<8 step 7) {
+        intList += i
+    }
+    assertEquals(listOf(1), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<8L step 7L) {
+        longList += i
+    }
+    assertEquals(listOf(1L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'h' step 7) {
+        charList += i
+    }
+    assertEquals(listOf('a'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSameLast.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<8 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<8L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'h' step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSmallerLast.kt

@@ -0,0 +1,27 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in 1..<9 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in 1L..<9L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in 'a'..<'i' step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/emptyProgression.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 2u..<2u
+    for (i in uintProgression step 2) {
+        uintList += i
+    }
+    assertTrue(uintList.isEmpty())
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 2uL..<2uL
+    for (i in ulongProgression step 2L) {
+        ulongList += i
+    }
+    assertTrue(ulongList.isEmpty())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepNegative.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val uintProgression = 1u..<8u
+        for (i in uintProgression step -1) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val ulongProgression = 1uL..<8uL
+        for (i in ulongProgression step -1L) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepThenLegalStep.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val uintProgression = 1u..<8u
+        for (i in uintProgression step 0 step 2) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val ulongProgression = 1uL..<8uL
+        for (i in ulongProgression step 0L step 2L) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepZero.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val uintProgression = 1u..<8u
+        for (i in uintProgression step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val ulongProgression = 1uL..<8uL
+        for (i in ulongProgression step 0L) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/legalStepThenIllegalStep.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val uintProgression = 1u..<8u
+        for (i in uintProgression step 2 step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val ulongProgression = 1uL..<8uL
+        for (i in ulongProgression step 2L step 0L) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<5u
+    for (i in uintProgression step 1 step 1) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 2u, 3u, 4u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<5uL
+    for (i in ulongProgression step 1L step 1L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 2uL, 3uL, 4uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepThenSameStep.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<9u
+    for (i in uintProgression step 2 step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<9uL
+    for (i in ulongProgression step 2L step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<6u
+    for (i in uintProgression step 2 step 1) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 2u, 3u, 4u, 5u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<6uL
+    for (i in ulongProgression step 2L step 1L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 2uL, 3uL, 4uL, 5uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<8u
+    for (i in uintProgression step 3 step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<8uL
+    for (i in ulongProgression step 3L step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<11u
+    for (i in uintProgression step 3 step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u, 9u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<11uL
+    for (i in ulongProgression step 3L step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL, 9uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<7u
+    for (i in uintProgression step 2 step 1) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 2u, 3u, 4u, 5u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<7uL
+    for (i in ulongProgression step 2L step 1L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 2uL, 3uL, 4uL, 5uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<9u
+    for (i in uintProgression step 2 step 3) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 4u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<9uL
+    for (i in ulongProgression step 2L step 3L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 4uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<11u
+    for (i in uintProgression step 2 step 3) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 4u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<11uL
+    for (i in ulongProgression step 2L step 3L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 4uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStep.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<9u
+    for (i in uintProgression.reversed() step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(8u, 6u, 4u, 2u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<9uL
+    for (i in ulongProgression.reversed() step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(8uL, 6uL, 4uL, 2uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<9u
+    for (i in (uintProgression.reversed() step 2).reversed()) {
+        uintList += i
+    }
+    assertEquals(listOf(2u, 4u, 6u, 8u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<9uL
+    for (i in (ulongProgression.reversed() step 2L).reversed()) {
+        ulongList += i
+    }
+    assertEquals(listOf(2uL, 4uL, 6uL, 8uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<11u
+    for (i in (uintProgression.reversed() step 2).reversed() step 3) {
+        uintList += i
+    }
+    assertEquals(listOf(2u, 5u, 8u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<11uL
+    for (i in (ulongProgression.reversed() step 2L).reversed() step 3L) {
+        ulongList += i
+    }
+    assertEquals(listOf(2uL, 5uL, 8uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversed.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<9u
+    for (i in (uintProgression step 2).reversed()) {
+        uintList += i
+    }
+    assertEquals(listOf(7u, 5u, 3u, 1u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<9uL
+    for (i in (ulongProgression step 2L).reversed()) {
+        ulongList += i
+    }
+    assertEquals(listOf(7uL, 5uL, 3uL, 1uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStep.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<11u
+    for (i in (uintProgression step 2).reversed() step 3) {
+        uintList += i
+    }
+    assertEquals(listOf(9u, 6u, 3u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<11uL
+    for (i in (ulongProgression step 2L).reversed() step 3L) {
+        ulongList += i
+    }
+    assertEquals(listOf(9uL, 6uL, 3uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<11u
+    for (i in ((uintProgression step 2).reversed() step 3).reversed()) {
+        uintList += i
+    }
+    assertEquals(listOf(3u, 6u, 9u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<11uL
+    for (i in ((ulongProgression step 2L).reversed() step 3L).reversed()) {
+        ulongList += i
+    }
+    assertEquals(listOf(3uL, 6uL, 9uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/singleElementStepTwo.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<2u
+    for (i in uintProgression step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<2uL
+    for (i in ulongProgression step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepOne.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<5u
+    for (i in uintProgression step 1) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 2u, 3u, 4u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<5uL
+    for (i in ulongProgression step 1L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 2uL, 3uL, 4uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToOutsideRange.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<8u
+    for (i in uintProgression step 7) {
+        uintList += i
+    }
+    assertEquals(listOf(1u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<8uL
+    for (i in ulongProgression step 7L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSameLast.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<8u
+    for (i in uintProgression step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<8uL
+    for (i in ulongProgression step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSmallerLast.kt

@@ -0,0 +1,23 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    val uintProgression = 1u..<9u
+    for (i in uintProgression step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    val ulongProgression = 1uL..<9uL
+    for (i in ulongProgression step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/emptyProgression.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 2u..<2u step 2) {
+        uintList += i
+    }
+    assertTrue(uintList.isEmpty())
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 2uL..<2uL step 2L) {
+        ulongList += i
+    }
+    assertTrue(ulongList.isEmpty())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepNegative.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// KT-34166: Translation of loop over literal completely removes the validation of step
+// DONT_TARGET_EXACT_BACKEND: JS
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1u..<8u step -1) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1uL..<8uL step -1L) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepThenLegalStep.kt

@@ -0,0 +1,19 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1u..<8u step 0 step 2) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1uL..<8uL step 0L step 2L) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepZero.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// KT-34166: Translation of loop over literal completely removes the validation of step
+// DONT_TARGET_EXACT_BACKEND: JS
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1u..<8u step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1uL..<8uL step 0L) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/legalStepThenIllegalStep.kt

@@ -0,0 +1,19 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1u..<8u step 2 step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        for (i in 1uL..<8uL step 2L step 0L) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<5u step 1 step 1) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 2u, 3u, 4u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<5uL step 1L step 1L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 2uL, 3uL, 4uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepThenSameStep.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<9u step 2 step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<9uL step 2L step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<6u step 2 step 1) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 2u, 3u, 4u, 5u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<6uL step 2L step 1L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 2uL, 3uL, 4uL, 5uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<8u step 3 step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<8uL step 3L step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<11u step 3 step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u, 9u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<11uL step 3L step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL, 9uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<7u step 2 step 1) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 2u, 3u, 4u, 5u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<7uL step 2L step 1L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 2uL, 3uL, 4uL, 5uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<9u step 2 step 3) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 4u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<9uL step 2L step 3L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 4uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<11u step 2 step 3) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 4u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<11uL step 2L step 3L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 4uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStep.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in (1u..<9u).reversed() step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(8u, 6u, 4u, 2u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in (1uL..<9uL).reversed() step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(8uL, 6uL, 4uL, 2uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in ((1u..<9u).reversed() step 2).reversed()) {
+        uintList += i
+    }
+    assertEquals(listOf(2u, 4u, 6u, 8u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in ((1uL..<9uL).reversed() step 2L).reversed()) {
+        ulongList += i
+    }
+    assertEquals(listOf(2uL, 4uL, 6uL, 8uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in ((1u..<11u).reversed() step 2).reversed() step 3) {
+        uintList += i
+    }
+    assertEquals(listOf(2u, 5u, 8u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in ((1uL..<11uL).reversed() step 2L).reversed() step 3L) {
+        ulongList += i
+    }
+    assertEquals(listOf(2uL, 5uL, 8uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversed.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in (1u..<9u step 2).reversed()) {
+        uintList += i
+    }
+    assertEquals(listOf(7u, 5u, 3u, 1u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in (1uL..<9uL step 2L).reversed()) {
+        ulongList += i
+    }
+    assertEquals(listOf(7uL, 5uL, 3uL, 1uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStep.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in (1u..<11u step 2).reversed() step 3) {
+        uintList += i
+    }
+    assertEquals(listOf(9u, 6u, 3u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in (1uL..<11uL step 2L).reversed() step 3L) {
+        ulongList += i
+    }
+    assertEquals(listOf(9uL, 6uL, 3uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in ((1u..<11u step 2).reversed() step 3).reversed()) {
+        uintList += i
+    }
+    assertEquals(listOf(3u, 6u, 9u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in ((1uL..<11uL step 2L).reversed() step 3L).reversed()) {
+        ulongList += i
+    }
+    assertEquals(listOf(3uL, 6uL, 9uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/singleElementStepTwo.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<2u step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<2uL step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepOne.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<5u step 1) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 2u, 3u, 4u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<5uL step 1L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 2uL, 3uL, 4uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToOutsideRange.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<8u step 7) {
+        uintList += i
+    }
+    assertEquals(listOf(1u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<8uL step 7L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSameLast.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<8u step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<8uL step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSmallerLast.kt

@@ -0,0 +1,21 @@
+// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit!
+// WITH_STDLIB
+// !LANGUAGE: +RangeUntilOperator
+@file:OptIn(ExperimentalStdlibApi::class)
+import kotlin.test.*
+
+fun box(): String {
+    val uintList = mutableListOf<UInt>()
+    for (i in 1u..<9u step 2) {
+        uintList += i
+    }
+    assertEquals(listOf(1u, 3u, 5u, 7u), uintList)
+
+    val ulongList = mutableListOf<ULong>()
+    for (i in 1uL..<9uL step 2L) {
+        ulongList += i
+    }
+    assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList)
+
+    return "OK"
+}