Add new tests for step progressions and fix existing tests.

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 8) downTo logged("end;", 1)).reversed() step logged("step;", 2)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(1357, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 8) downTo logged("end;", 1)).reversed() step logged("step;", 2)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(7531, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStepReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 10) downTo logged("end;", 1)).reversed() step logged("step2;", 2)).reversed() step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(963, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in logged("start;", 8) downTo logged("end;", 1) step logged("step;", 2)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(8642, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 8) downTo logged("end;", 1) step logged("step;", 2)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(2468, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 9) downTo logged("end;", 0) step logged("step2;", 2)).reversed() step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(147, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversedStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 9) downTo logged("end;", 0) step logged("step2;", 2)).reversed() step logged("step3;", 3)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(741, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in logged("start;", 9) downTo logged("end;", 0) step logged("step2;", 2) step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(963, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 1)..logged("end;", 8)).reversed() step logged("step;", 2)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(8642, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 1)..logged("end;", 8)).reversed() step logged("step;", 2)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(2468, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStepReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 1)..logged("end;", 10)).reversed() step logged("step2;", 2)).reversed() step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(258, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in logged("start;", 1)..logged("end;", 8) step logged("step;", 2)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(1357, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 1)..logged("end;", 8) step logged("step;", 2)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(7531, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 1)..logged("end;", 10) step logged("step2;", 2)).reversed() step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(963, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversedStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 1)..logged("end;", 10) step logged("step2;", 2)).reversed() step logged("step3;", 3)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(369, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in logged("start;", 1)..logged("end;", 10) step logged("step2;", 2) step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(147, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 1) until logged("end;", 9)).reversed() step logged("step;", 2)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(8642, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 1) until logged("end;", 9)).reversed() step logged("step;", 2)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(2468, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStepReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 1) until logged("end;", 11)).reversed() step logged("step2;", 2)).reversed() step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(258, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in logged("start;", 1) until logged("end;", 9) step logged("step;", 2)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(1357, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 1) until logged("end;", 9) step logged("step;", 2)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(7531, sum)
+
+    assertEquals("start;end;step;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversedStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in (logged("start;", 1) until logged("end;", 11) step logged("step2;", 2)).reversed() step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(963, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversedStepReversed.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in ((logged("start;", 1) until logged("end;", 11) step logged("step2;", 2)).reversed() step logged("step3;", 3)).reversed()) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(369, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepStep.kt

@@ -0,0 +1,21 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+val log = StringBuilder()
+
+fun logged(message: String, value: Int) =
+    value.also { log.append(message) }
+
+fun box(): String {
+    var sum = 0
+    for (i in logged("start;", 1) until logged("end;", 11) step logged("step2;", 2) step logged("step3;", 3)) {
+        sum = sum * 10 + i
+    }
+
+    assertEquals(147, sum)
+
+    assertEquals("start;end;step2;step3;", log.toString())
+
+    return "OK"
+}

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"
+}

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

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

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

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

compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/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 = 1..7
+        for (i in intProgression step zero()) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 1L..7L
+        for (i in longProgression step zero().toLong()) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'a'..'g'
+        for (i in charProgression step zero()) {
+        }
+    }
+
+    return "OK"
+}

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

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

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

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

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

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

compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/minValueToMaxValueStepMaxValue.kt

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

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

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

compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/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 = 1..4
+    for (i in intProgression step 1 step 1) {
+        intList += i
+    }
+    assertEquals(listOf(1, 2, 3, 4), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..4L
+    for (i in longProgression step 1L step 1L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 2L, 3L, 4L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'d'
+    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/rangeTo/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 = 1..8
+    for (i in intProgression step 2 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 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 step 2) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/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 = 1..5
+    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..5L
+    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'..'e'
+    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/rangeTo/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 = 1..7
+    for (i in intProgression step 3 step 2) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..7L
+    for (i in longProgression step 3L step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'g'
+    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/rangeTo/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 = 1..10
+    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..10L
+    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'..'j'
+    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/rangeTo/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 = 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/rangeTo/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 = 1..8
+    for (i in intProgression step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(1, 4, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..8L
+    for (i in longProgression step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 4L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'h'
+    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/rangeTo/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 = 1..10
+    for (i in intProgression step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(1, 4, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..10L
+    for (i in longProgression step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 4L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'j'
+    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/rangeTo/oneToMaxValueStepMaxValue.kt

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

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..8
+    for (i in intProgression.reversed() step 2) {
+        intList += i
+    }
+    assertEquals(listOf(8, 6, 4, 2), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..8L
+    for (i in longProgression.reversed() step 2L) {
+        longList += i
+    }
+    assertEquals(listOf(8L, 6L, 4L, 2L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'h'
+    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/rangeTo/reversed/reversedThenStepThenReversed.kt

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..8
+    for (i in (intProgression.reversed() step 2).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(2, 4, 6, 8), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..8L
+    for (i in (longProgression.reversed() step 2L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(2L, 4L, 6L, 8L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'h'
+    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/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..10
+    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..10L
+    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'..'j'
+    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/rangeTo/reversed/stepThenReversed.kt

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..8
+    for (i in (intProgression step 2).reversed()) {
+        intList += i
+    }
+    assertEquals(listOf(7, 5, 3, 1), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..8L
+    for (i in (longProgression step 2L).reversed()) {
+        longList += i
+    }
+    assertEquals(listOf(7L, 5L, 3L, 1L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'h'
+    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/rangeTo/reversed/stepThenReversedThenStep.kt

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+import kotlin.test.*
+
+fun box(): String {
+    val intList = mutableListOf<Int>()
+    val intProgression = 1..10
+    for (i in (intProgression step 2).reversed() step 3) {
+        intList += i
+    }
+    assertEquals(listOf(9, 6, 3), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..10L
+    for (i in (longProgression step 2L).reversed() step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(9L, 6L, 3L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'j'
+    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/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt

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

compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/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 = 1..8
+    for (i in intProgression step two()) {
+        intList += i
+    }
+    assertEquals(listOf(1, 3, 5, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L..8L
+    for (i in longProgression step two().toLong()) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 3L, 5L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a'..'h'
+    for (i in charProgression step two()) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'c', 'e', 'g'), charList)
+
+    return "OK"
+}

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+// KJS_WITH_FULL_RUNTIME
+// WITH_RUNTIME
+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/rangeTo/zeroToMaxValueStepMaxValue.kt

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

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

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

compiler/testData/codegen/box/ranges/stepped/expression/until/emptyProgressionToMinValue.kt

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

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

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

compiler/testData/codegen/box/ranges/stepped/expression/until/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 = 1 until 7
+        for (i in intProgression step zero()) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val longProgression = 1L until 7L
+        for (i in longProgression step zero().toLong()) {
+        }
+    }
+
+    assertFailsWith<IllegalArgumentException> {
+        val charProgression = 'a' until 'g'
+        for (i in charProgression step zero()) {
+        }
+    }
+
+    return "OK"
+}

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

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

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

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

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

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

compiler/testData/codegen/box/ranges/stepped/expression/until/minValueToMaxValueStepMaxValue.kt

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

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

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

compiler/testData/codegen/box/ranges/stepped/expression/until/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 = 1 until 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 until 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' until '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/until/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 = 1 until 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 until 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' until '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/until/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 = 1 until 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 until 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' until '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/until/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 = 1 until 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 until 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' until '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/until/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 = 1 until 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 until 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' until '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/until/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 = 1 until 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 until 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' until '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/until/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 = 1 until 9
+    for (i in intProgression step 2 step 3) {
+        intList += i
+    }
+    assertEquals(listOf(1, 4, 7), intList)
+
+    val longList = mutableListOf<Long>()
+    val longProgression = 1L until 9L
+    for (i in longProgression step 2L step 3L) {
+        longList += i
+    }
+    assertEquals(listOf(1L, 4L, 7L), longList)
+
+    val charList = mutableListOf<Char>()
+    val charProgression = 'a' until 'i'
+    for (i in charProgression step 2 step 3) {
+        charList += i
+    }
+    assertEquals(listOf('a', 'd', 'g'), charList)
+
+    return "OK"
+}