Add new tests for step progressions and fix existing tests.

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1 downTo 2
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertTrue(intList.isEmpty())
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L downTo 2L
+    for (i in longProgression step 2L) {
+        longList += i
+    }
+    assertTrue(longList.isEmpty())
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a' downTo 'b'
+    for (i in charProgression step 2) {
+        charList += i
+    }
+    assertTrue(charList.isEmpty())
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 7 downTo 1
+        for (i in intProgression step -1) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 7L downTo 1L
+        for (i in longProgression step -1L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'g' downTo 'a'
+        for (i in charProgression step -1) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepNonConst.kt

@@ -0,0 +1,27 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun zero() = 0
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 7 downTo 1
+        for (i in intProgression step zero()) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 7L downTo 1L
+        for (i in longProgression step zero().toLong()) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'g' downTo 'a'
+        for (i in charProgression step zero()) {
+        }
+    }
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 7 downTo 1
+        for (i in intProgression step 0 step 2) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 7L downTo 1L
+        for (i in longProgression step 0L step 2L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'g' downTo 'a'
+        for (i in charProgression step 0 step 2) {
+        }
+    }
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 7 downTo 1
+        for (i in intProgression step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 7L downTo 1L
+        for (i in longProgression step 0L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'g' downTo 'a'
+        for (i in charProgression step 0) {
+        }
+    }
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    assertFailsWith<IllegalArgumentException> {
+        val intProgression = 7 downTo 1
+        for (i in intProgression step 2 step 0) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 7L downTo 1L
+        for (i in longProgression step 2L step 0L) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'g' downTo 'a'
+        for (i in charProgression step 2 step 0) {
+        }
+    }
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToMinValueStepMaxValue.kt

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = Int.MAX_VALUE downTo Int.MIN_VALUE
+    for (i in intProgression step Int.MAX_VALUE) {
+        intList += i
+    }
+    assertEquals(listOf(Int.MAX_VALUE, 0, Int.MIN_VALUE + 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = Long.MAX_VALUE downTo Long.MIN_VALUE
+    for (i in longProgression step Long.MAX_VALUE) {
+        longList += i
+    }
+    assertEquals(listOf(Long.MAX_VALUE, 0, Long.MIN_VALUE + 1), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = Char.MAX_VALUE downTo Char.MIN_VALUE
+    for (i in charProgression step Char.MAX_VALUE.toInt()) {
+        charList += i
+    }
+    assertEquals(listOf(Char.MAX_VALUE, Char.MIN_VALUE), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToOneStepMaxValue.kt

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = Int.MAX_VALUE downTo 1
+    for (i in intProgression step Int.MAX_VALUE) {
+        intList += i
+    }
+    assertEquals(listOf(Int.MAX_VALUE), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = Long.MAX_VALUE downTo 1L
+    for (i in longProgression step Long.MAX_VALUE) {
+        longList += i
+    }
+    assertEquals(listOf(Long.MAX_VALUE), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = Char.MAX_VALUE downTo 1.toChar()
+    for (i in charProgression step Char.MAX_VALUE.toInt()) {
+        charList += i
+    }
+    assertEquals(listOf(Char.MAX_VALUE), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToZeroStepMaxValue.kt

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = Int.MAX_VALUE downTo 0
+    for (i in intProgression step Int.MAX_VALUE) {
+        intList += i
+    }
+    assertEquals(listOf(Int.MAX_VALUE, 0), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = Long.MAX_VALUE downTo 0L
+    for (i in longProgression step Long.MAX_VALUE) {
+        longList += i
+    }
+    assertEquals(listOf(Long.MAX_VALUE, 0L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = Char.MAX_VALUE downTo 0.toChar()
+    for (i in charProgression step Char.MAX_VALUE.toInt()) {
+        charList += i
+    }
+    assertEquals(listOf(Char.MAX_VALUE, 0.toChar()), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/downTo/mixedTypeStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 7.toByte() downTo 1.toShort()
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertEquals(listOf(7, 5, 3, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 7 downTo 1L
+    for (i in longProgression step 2) {
+        longList += i
+    }
+    assertEquals(listOf(7L, 5L, 3L, 1L), longList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 4 downTo 1
+    for (i in intProgression step 1 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(4, 3, 2, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 4L downTo 1L
+    for (i in longProgression step 1L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(4L, 3L, 2L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'd' downTo 'a'
+    for (i in charProgression step 1 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('d', 'c', 'b', 'a'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 8 downTo 1
+    for (i in intProgression step 2 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(8, 6, 4, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 8L downTo 1L
+    for (i in longProgression step 2L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(8L, 6L, 4L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'h' downTo 'a'
+    for (i in charProgression step 2 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('h', 'f', 'd', 'b'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 5 downTo 1
+    for (i in intProgression step 2 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(5, 4, 3, 2, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 5L downTo 1L
+    for (i in longProgression step 2L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(5L, 4L, 3L, 2L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'e' downTo 'a'
+    for (i in charProgression step 2 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('e', 'd', 'c', 'b', 'a'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 7 downTo 1
+    for (i in intProgression step 3 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(7, 5, 3, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 7L downTo 1L
+    for (i in longProgression step 3L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(7L, 5L, 3L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'g' downTo 'a'
+    for (i in charProgression step 3 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('g', 'e', 'c', 'a'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 10 downTo 1
+    for (i in intProgression step 3 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(10, 8, 6, 4, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 10L downTo 1L
+    for (i in longProgression step 3L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(10L, 8L, 6L, 4L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'j' downTo 'a'
+    for (i in charProgression step 3 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('j', 'h', 'f', 'd', 'b'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 6 downTo 1
+    for (i in intProgression step 2 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(6, 5, 4, 3, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 6L downTo 1L
+    for (i in longProgression step 2L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(6L, 5L, 4L, 3L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'f' downTo 'a'
+    for (i in charProgression step 2 step 1) {
+        charList += i
+    }
+    assertEquals(listOf('f', 'e', 'd', 'c', 'b'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 8 downTo 1
+    for (i in intProgression step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(8, 5, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 8L downTo 1L
+    for (i in longProgression step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(8L, 5L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'h' downTo 'a'
+    for (i in charProgression step 2 step 3) {
+        charList += i
+    }
+    assertEquals(listOf('h', 'e', 'b'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 10 downTo 1
+    for (i in intProgression step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(10, 7, 4), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 10L downTo 1L
+    for (i in longProgression step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(10L, 7L, 4L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'j' downTo 'a'
+    for (i in charProgression step 2 step 3) {
+        charList += i
+    }
+    assertEquals(listOf('j', 'g', 'd'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in (8 downTo 1).reversed() step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in (8L downTo 1L).reversed() step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in ('h' downTo 'a').reversed() step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in ((8 downTo 1).reversed() step 2).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(7, 5, 3, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in ((8L downTo 1L).reversed() step 2L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(7L, 5L, 3L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in (('h' downTo 'a').reversed() step 2).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('g', 'e', 'c', 'a'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in ((10 downTo 1).reversed() step 2).reversed() step 3) {
+        intList += i
+    }
+    assertEquals(listOf(9, 6, 3), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in ((10L downTo 1L).reversed() step 2L).reversed() step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(9L, 6L, 3L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in (('j' downTo 'a').reversed() step 2).reversed() step 3) {
+        charList += i
+    }
+    assertEquals(listOf('i', 'f', 'c'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in (8 downTo 1 step 2).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(2, 4, 6, 8), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in (8L downTo 1L step 2L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(2L, 4L, 6L, 8L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in ('h' downTo 'a' step 2).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('b', 'd', 'f', 'h'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in (10 downTo 1 step 2).reversed() step 3) {
+        intList += i
+    }
+    assertEquals(listOf(2, 5, 8), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in (10L downTo 1L step 2L).reversed() step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(2L, 5L, 8L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in ('j' downTo 'a' step 2).reversed() step 3) {
+        charList += i
+    }
+    assertEquals(listOf('b', 'e', 'h'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,25 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    for (i in ((10 downTo 1 step 2).reversed() step 3).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(8, 5, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    for (i in ((10L downTo 1L step 2L).reversed() step 3L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(8L, 5L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    for (i in (('j' downTo 'a' step 2).reversed() step 3).reversed()) {
+        charList += i
+    }
+    assertEquals(listOf('h', 'e', 'b'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1 downTo 1
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L downTo 1L
+    for (i in longProgression step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a' downTo 'a'
+    for (i in charProgression step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepNonConst.kt

@@ -0,0 +1,30 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun two() = 2
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 8 downTo 1
+    for (i in intProgression step two()) {
+        intList += i
+    }
+    assertEquals(listOf(8, 6, 4, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 8L downTo 1L
+    for (i in longProgression step two().toLong()) {
+        longList += i
+    }
+    assertEquals(listOf(8L, 6L, 4L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'h' downTo 'a'
+    for (i in charProgression step two()) {
+        charList += i
+    }
+    assertEquals(listOf('h', 'f', 'd', 'b'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 4 downTo 1
+    for (i in intProgression step 1) {
+        intList += i
+    }
+    assertEquals(listOf(4, 3, 2, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 4L downTo 1L
+    for (i in longProgression step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(4L, 3L, 2L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'd' downTo 'a'
+    for (i in charProgression step 1) {
+        charList += i
+    }
+    assertEquals(listOf('d', 'c', 'b', 'a'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 7 downTo 1
+    for (i in intProgression step 7) {
+        intList += i
+    }
+    assertEquals(listOf(7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 7L downTo 1L
+    for (i in longProgression step 7L) {
+        longList += i
+    }
+    assertEquals(listOf(7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'g' downTo 'a'
+    for (i in charProgression step 7) {
+        charList += i
+    }
+    assertEquals(listOf('g'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 7 downTo 1
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertEquals(listOf(7, 5, 3, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 7L downTo 1L
+    for (i in longProgression step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(7L, 5L, 3L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'g' downTo 'a'
+    for (i in charProgression step 2) {
+        charList += i
+    }
+    assertEquals(listOf('g', 'e', 'c', 'a'), charList)
+
+    return "OK"
+}

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 8 downTo 1
+    for (i in intProgression step 2) {
+        intList += i
+    }
+    assertEquals(listOf(8, 6, 4, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 8L downTo 1L
+    for (i in longProgression step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(8L, 6L, 4L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'h' downTo 'a'
+    for (i in charProgression step 2) {
+        charList += i
+    }
+    assertEquals(listOf('h', 'f', 'd', 'b'), charList)
+
+    return "OK"
+}