backend/tests: Add blackbox tests from Kotlin JVM

Added tests from testData/codegen/box directory. There are blackbox tests
in other directories and they are to be added.

backend.native/tests/external/codegen/blackbox/ranges/contains/inComparableRange.kt

@@ -0,0 +1,50 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+class ComparablePair<T : Comparable<T>>(val first: T, val second: T) : Comparable<ComparablePair<T>> {
+    override fun compareTo(other: ComparablePair<T>): Int {
+        val result = first.compareTo(other.first)
+        return if (result != 0) result else second.compareTo(other.second)
+    }
+}
+
+fun <T : Comparable<T>> genericRangeTo(start: T, endInclusive: T) = start..endInclusive
+operator fun Double.rangeTo(other: Double) = genericRangeTo(this, other)
+// some weird inverted range
+operator fun Float.rangeTo(other: Float) = object : ClosedFloatingPointRange<Float> {
+    override val endInclusive: Float = this@rangeTo
+    override val start: Float = other
+    override fun lessThanOrEquals(a: Float, b: Float) = a >= b
+}
+
+fun check(x: Double, left: Double, right: Double): Boolean {
+    val result = x in left..right
+    val range = left..right
+    assert(result == x in range) { "Failed: unoptimized === unoptimized for custom double $range" }
+    return result
+}
+
+fun check(x: Float, left: Float, right: Float): Boolean {
+    val result = x in left..right
+    val range = left..right
+    assert(result == x in range) { "Failed: unoptimized === unoptimized for standard float $range" }
+    return result
+}
+
+fun box(): String {
+    assert("a" !in "b".."c")
+    assert("b" in "a".."d")
+
+    assert(ComparablePair(2, 2) !in ComparablePair(1, 10)..ComparablePair(2, 1))
+    assert(ComparablePair(2, 2) in ComparablePair(2, 0)..ComparablePair(2, 10))
+
+    assert(!check(-0.0, 0.0, 0.0))
+    assert(check(Double.NaN, Double.NaN, Double.NaN))
+
+    assert(check(-0.0f, 0.0f, 0.0f))
+    assert(!check(Float.NaN, Float.NaN, Float.NaN))
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inExtensionRange.kt

@@ -0,0 +1,21 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+operator fun Int.rangeTo(right: String): ClosedRange<Int> = this..this + 1
+operator fun Long.rangeTo(right: Double): ClosedRange<Long> = this..right.toLong() + 1
+operator fun String.rangeTo(right: Int): ClosedRange<String> = this..this
+
+fun box(): String {
+    assert(0 !in 1.."a")
+    assert(1 in 1.."a")
+
+    assert(0L !in 1L..2.0)
+    assert(2L in 1L..3.0)
+
+    assert("a" !in "b"..1)
+    assert("a" in "a"..1)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inIntRange.kt

@@ -0,0 +1,28 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun box(): String {
+    for (x in 1..10) {
+        assert(x in 1..10)
+        assert(x + 10 !in 1..10)
+    }
+
+    var x = 0
+    assert(0 !in 1..2)
+
+    assert(++x in 1..1)
+    assert(++x !in 1..1)
+
+    assert(sideEffect(x) in 2..3)
+    return "OK"
+}
+
+
+var invocationCounter = 0
+fun sideEffect(x: Int): Int {
+    ++invocationCounter
+    assert(invocationCounter == 1)
+    return x
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inOptimizableDoubleRange.kt

@@ -0,0 +1,39 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun check(x: Double, left: Double, right: Double): Boolean {
+    val result = x in left..right
+    val manual = x >= left && x <= right
+    val range = left..right
+    assert(result == manual) { "Failed: optimized === manual for $range" }
+    assert(result == checkUnoptimized(x, range)) { "Failed: optimized === unoptimized for $range" }
+    return result
+}
+
+fun checkUnoptimized(x: Double, range: ClosedRange<Double>): Boolean {
+    return x in range
+}
+
+fun box(): String {
+    assert(check(1.0, 0.0, 2.0))
+    assert(!check(1.0, -1.0, 0.0))
+
+    assert(check(Double.MIN_VALUE, 0.0, 1.0))
+    assert(check(Double.MAX_VALUE, Double.MAX_VALUE - Double.MIN_VALUE, Double.MAX_VALUE))
+    assert(!check(Double.NaN, Double.NaN, Double.NaN))
+    assert(!check(0.0, Double.NaN, Double.NaN))
+
+    assert(check(-0.0, -0.0, +0.0))
+    assert(check(-0.0, -0.0, -0.0))
+    assert(check(-0.0, +0.0, +0.0))
+    assert(check(+0.0, -0.0, -0.0))
+    assert(check(+0.0, +0.0, +0.0))
+    assert(check(+0.0, -0.0, +0.0))
+
+    var value = 0.0
+    assert(++value in 1.0..1.0)
+    assert(++value !in 1.0..1.0)
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inOptimizableFloatRange.kt

@@ -0,0 +1,39 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun check(x: Float, left: Float, right: Float): Boolean {
+    val result = x in left..right
+    val manual = x >= left && x <= right
+    val range = left..right
+    assert(result == manual) { "Failed: optimized === manual for $range" }
+    assert(result == checkUnoptimized(x, range)) { "Failed: optimized === unoptimized for $range" }
+    return result
+}
+
+fun checkUnoptimized(x: Float, range: ClosedRange<Float>): Boolean {
+    return x in range
+}
+
+fun box(): String {
+    assert(check(1.0f, 0.0f, 2.0f))
+    assert(!check(1.0f, -1.0f, 0.0f))
+
+    assert(check(Float.MIN_VALUE, 0.0f, 1.0f))
+    assert(check(Float.MAX_VALUE, Float.MAX_VALUE - Float.MIN_VALUE, Float.MAX_VALUE))
+    assert(!check(Float.NaN, Float.NaN, Float.NaN))
+    assert(!check(0.0f, Float.NaN, Float.NaN))
+
+    assert(check(-0.0f, -0.0f, +0.0f))
+    assert(check(-0.0f, -0.0f, -0.0f))
+    assert(check(-0.0f, +0.0f, +0.0f))
+    assert(check(+0.0f, -0.0f, -0.0f))
+    assert(check(+0.0f, +0.0f, +0.0f))
+    assert(check(+0.0f, -0.0f, +0.0f))
+
+    var value = 0.0f
+    assert(++value in 1.0f..1.0f)
+    assert(++value !in 1.0f..1.0f)
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inOptimizableIntRange.kt

@@ -0,0 +1,32 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun check(x: Int, left: Int, right: Int): Boolean {
+    val result = x in left..right
+    val manual = x >= left && x <= right
+    val range = left..right
+    assert(result == manual) { "Failed: optimized === manual for $range" }
+    assert(result == checkUnoptimized(x, range)) { "Failed: optimized === unoptimized for $range" }
+    return result
+}
+
+fun checkUnoptimized(x: Int, range: ClosedRange<Int>): Boolean {
+    return x in range
+}
+
+fun box(): String {
+    assert(check(1, 0, 2))
+    assert(!check(1, -1, 0))
+    assert(!check(239, 239, 238))
+    assert(check(239, 238, 239))
+
+    assert(check(Int.MIN_VALUE, Int.MIN_VALUE, Int.MIN_VALUE))
+    assert(check(Int.MAX_VALUE, Int.MIN_VALUE, Int.MAX_VALUE))
+
+    var value = 0
+    assert(++value in 1..1)
+    assert(++value !in 1..1)
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inOptimizableLongRange.kt

@@ -0,0 +1,32 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun check(x: Long, left: Long, right: Long): Boolean {
+    val result = x in left..right
+    val manual = x >= left && x <= right
+    val range = left..right
+    assert(result == manual) { "Failed: optimized === manual for $range" }
+    assert(result == checkUnoptimized(x, range)) { "Failed: optimized === unoptimized for $range" }
+    return result
+}
+
+fun checkUnoptimized(x: Long, range: ClosedRange<Long>): Boolean {
+    return x in range
+}
+
+fun box(): String {
+    assert(check(1L, 0L, 2L))
+    assert(!check(1L, -1L, 0L))
+    assert(!check(239L, 239L, 238L))
+    assert(check(239L, 238L, 239L))
+
+    assert(check(Long.MIN_VALUE, Long.MIN_VALUE, Long.MIN_VALUE))
+    assert(check(Long.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE))
+
+    var value = 0L
+    assert(++value in 1L..1L)
+    assert(++value !in 1L..1L)
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inRangeWithCustomContains.kt

@@ -0,0 +1,27 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+class Value(val x: Int) : Comparable<Value> {
+    override fun compareTo(other: Value): Int {
+        throw AssertionError("Should not be called")
+    }
+}
+
+class ValueRange(override val start: Value,
+                 override val endInclusive: Value) : ClosedRange<Value> {
+
+    override fun contains(value: Value): Boolean {
+        return value.x == 42
+    }
+}
+
+operator fun Value.rangeTo(other: Value): ClosedRange<Value> = ValueRange(this, other)
+
+fun box(): String {
+    assert(Value(42) in Value(1)..Value(2))
+    assert(Value(41) !in Value(40)..Value(42))
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inRangeWithImplicitReceiver.kt

@@ -0,0 +1,22 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun Long.inLongs(l: Long, r: Long): Boolean {
+    return this in l..r
+}
+
+fun Double.inDoubles(l: Double, r: Double): Boolean {
+    return this in l..r
+}
+
+fun box(): String {
+    assert(2L.inLongs(1L, 3L))
+    assert(!2L.inLongs(0L, 1L))
+
+    assert(2.0.inDoubles(1.0, 3.0))
+    assert(!2.0.inDoubles(0.0, 1.0))
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inRangeWithNonmatchingArguments.kt

@@ -0,0 +1,15 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun box(): String {
+    assert(Long.MAX_VALUE !in Int.MIN_VALUE..Int.MAX_VALUE)
+    assert(Int.MAX_VALUE in Long.MIN_VALUE..Long.MAX_VALUE)
+    assert(Double.MAX_VALUE !in Float.MIN_VALUE..Float.MAX_VALUE)
+    assert(Float.MIN_VALUE in 0..1)
+    assert(2.0 !in 1..0)
+    assert(1.0f in 0L..2L)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/inRangeWithSmartCast.kt

@@ -0,0 +1,29 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun check(x: Any?): Boolean {
+    if (x is Int) {
+        return x in 239..240
+    }
+
+    throw java.lang.AssertionError()
+}
+
+fun check(x: Any?, l: Any?, r: Any?): Boolean {
+    if (x is Int && l is Int && r is Int) {
+       return x in l..r
+    }
+
+    throw java.lang.AssertionError()
+}
+
+
+fun box(): String {
+    assert(check(239))
+    assert(check(239, 239, 240))
+    assert(!check(238))
+    assert(!check(238, 239, 240))
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/contains/rangeContainsString.kt

@@ -0,0 +1,5 @@
+operator fun IntRange.contains(s: String): Boolean = true
+
+fun box(): String {
+    return if ("s" in 0..1) "OK" else "fail"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/emptyDownto.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 5 downTo 10
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for 5 downTo 10: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 5.toByte() downTo 10.toByte()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for 5.toByte() downTo 10.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 5.toShort() downTo 10.toShort()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for 5.toShort() downTo 10.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 5.toLong() downTo 10.toLong()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for 5.toLong() downTo 10.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'a' downTo 'z'
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for 'a' downTo 'z': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/emptyRange.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 10..5
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for 10..5: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 10.toByte()..(-5).toByte()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for 10.toByte()..(-5).toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 10.toShort()..(-5).toShort()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for 10.toShort()..(-5).toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 10.toLong()..-5.toLong()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for 10.toLong()..-5.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'z'..'a'
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for 'z'..'a': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/inexactDownToMinValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = (MinI + 5) downTo MinI step 3
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MinI + 5, MinI + 2)) {
+        return "Wrong elements for (MinI + 5) downTo MinI step 3: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = (MinB + 5).toByte() downTo MinB step 3
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MinB + 5).toInt(), (MinB + 2).toInt())) {
+        return "Wrong elements for (MinB + 5).toByte() downTo MinB step 3: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = (MinS + 5).toShort() downTo MinS step 3
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MinS + 5).toInt(), (MinS + 2).toInt())) {
+        return "Wrong elements for (MinS + 5).toShort() downTo MinS step 3: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = (MinL + 5).toLong() downTo MinL step 3
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MinL + 5).toLong(), (MinL + 2).toLong())) {
+        return "Wrong elements for (MinL + 5).toLong() downTo MinL step 3: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = (MinC + 5) downTo MinC step 3
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MinC + 5), (MinC + 2))) {
+        return "Wrong elements for (MinC + 5) downTo MinC step 3: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/inexactSteppedDownTo.kt

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

backend.native/tests/external/codegen/blackbox/ranges/expression/inexactSteppedRange.kt

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

backend.native/tests/external/codegen/blackbox/ranges/expression/inexactToMaxValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = (MaxI - 5)..MaxI step 3
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI - 5, MaxI - 2)) {
+        return "Wrong elements for (MaxI - 5)..MaxI step 3: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = (MaxB - 5).toByte()..MaxB step 3
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MaxB - 5).toInt(), (MaxB - 2).toInt())) {
+        return "Wrong elements for (MaxB - 5).toByte()..MaxB step 3: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = (MaxS - 5).toShort()..MaxS step 3
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MaxS - 5).toInt(), (MaxS - 2).toInt())) {
+        return "Wrong elements for (MaxS - 5).toShort()..MaxS step 3: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = (MaxL - 5).toLong()..MaxL step 3
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MaxL - 5).toLong(), (MaxL - 2).toLong())) {
+        return "Wrong elements for (MaxL - 5).toLong()..MaxL step 3: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = (MaxC - 5)..MaxC step 3
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MaxC - 5), (MaxC - 2))) {
+        return "Wrong elements for (MaxC - 5)..MaxC step 3: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/maxValueMinusTwoToMaxValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = (MaxI - 2)..MaxI
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI - 2, MaxI - 1, MaxI)) {
+        return "Wrong elements for (MaxI - 2)..MaxI: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = (MaxB - 2).toByte()..MaxB
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MaxB - 2).toInt(), (MaxB - 1).toInt(), MaxB.toInt())) {
+        return "Wrong elements for (MaxB - 2).toByte()..MaxB: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = (MaxS - 2).toShort()..MaxS
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MaxS - 2).toInt(), (MaxS - 1).toInt(), MaxS.toInt())) {
+        return "Wrong elements for (MaxS - 2).toShort()..MaxS: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = (MaxL - 2).toLong()..MaxL
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MaxL - 2).toLong(), (MaxL - 1).toLong(), MaxL)) {
+        return "Wrong elements for (MaxL - 2).toLong()..MaxL: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = (MaxC - 2)..MaxC
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MaxC - 2), (MaxC - 1), MaxC)) {
+        return "Wrong elements for (MaxC - 2)..MaxC: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/maxValueToMaxValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = MaxI..MaxI
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI)) {
+        return "Wrong elements for MaxI..MaxI: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = MaxB..MaxB
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(MaxB.toInt())) {
+        return "Wrong elements for MaxB..MaxB: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = MaxS..MaxS
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(MaxS.toInt())) {
+        return "Wrong elements for MaxS..MaxS: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = MaxL..MaxL
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(MaxL)) {
+        return "Wrong elements for MaxL..MaxL: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = MaxC..MaxC
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>(MaxC)) {
+        return "Wrong elements for MaxC..MaxC: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/maxValueToMinValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = MaxI..MinI
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for MaxI..MinI: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = MaxB..MinB
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for MaxB..MinB: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = MaxS..MinS
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for MaxS..MinS: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = MaxL..MinL
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for MaxL..MinL: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = MaxC..MinC
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for MaxC..MinC: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/oneElementDownTo.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 5 downTo 5
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(5)) {
+        return "Wrong elements for 5 downTo 5: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 5.toByte() downTo 5.toByte()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(5)) {
+        return "Wrong elements for 5.toByte() downTo 5.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 5.toShort() downTo 5.toShort()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(5)) {
+        return "Wrong elements for 5.toShort() downTo 5.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 5.toLong() downTo 5.toLong()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(5.toLong())) {
+        return "Wrong elements for 5.toLong() downTo 5.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'k' downTo 'k'
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('k')) {
+        return "Wrong elements for 'k' downTo 'k': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/oneElementRange.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 5..5
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(5)) {
+        return "Wrong elements for 5..5: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 5.toByte()..5.toByte()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(5)) {
+        return "Wrong elements for 5.toByte()..5.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 5.toShort()..5.toShort()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(5)) {
+        return "Wrong elements for 5.toShort()..5.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 5.toLong()..5.toLong()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(5.toLong())) {
+        return "Wrong elements for 5.toLong()..5.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'k'..'k'
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('k')) {
+        return "Wrong elements for 'k'..'k': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/openRange.kt

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

backend.native/tests/external/codegen/blackbox/ranges/expression/progressionDownToMinValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = (MinI + 2) downTo MinI step 1
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MinI + 2, MinI + 1, MinI)) {
+        return "Wrong elements for (MinI + 2) downTo MinI step 1: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = (MinB + 2).toByte() downTo MinB step 1
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MinB + 2).toInt(), (MinB + 1).toInt(), MinB.toInt())) {
+        return "Wrong elements for (MinB + 2).toByte() downTo MinB step 1: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = (MinS + 2).toShort() downTo MinS step 1
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MinS + 2).toInt(), (MinS + 1).toInt(), MinS.toInt())) {
+        return "Wrong elements for (MinS + 2).toShort() downTo MinS step 1: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = (MinL + 2).toLong() downTo MinL step 1
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MinL + 2).toLong(), (MinL + 1).toLong(), MinL)) {
+        return "Wrong elements for (MinL + 2).toLong() downTo MinL step 1: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = (MinC + 2) downTo MinC step 1
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MinC + 2), (MinC + 1), MinC)) {
+        return "Wrong elements for (MinC + 2) downTo MinC step 1: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/progressionMaxValueMinusTwoToMaxValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = (MaxI - 2)..MaxI step 2
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI - 2, MaxI)) {
+        return "Wrong elements for (MaxI - 2)..MaxI step 2: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = (MaxB - 2).toByte()..MaxB step 2
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MaxB - 2).toInt(), MaxB.toInt())) {
+        return "Wrong elements for (MaxB - 2).toByte()..MaxB step 2: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = (MaxS - 2).toShort()..MaxS step 2
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MaxS - 2).toInt(), MaxS.toInt())) {
+        return "Wrong elements for (MaxS - 2).toShort()..MaxS step 2: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = (MaxL - 2).toLong()..MaxL step 2
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MaxL - 2).toLong(), MaxL)) {
+        return "Wrong elements for (MaxL - 2).toLong()..MaxL step 2: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = (MaxC - 2)..MaxC step 2
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MaxC - 2), MaxC)) {
+        return "Wrong elements for (MaxC - 2)..MaxC step 2: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/progressionMaxValueToMaxValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = MaxI..MaxI step 1
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI)) {
+        return "Wrong elements for MaxI..MaxI step 1: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = MaxB..MaxB step 1
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(MaxB.toInt())) {
+        return "Wrong elements for MaxB..MaxB step 1: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = MaxS..MaxS step 1
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(MaxS.toInt())) {
+        return "Wrong elements for MaxS..MaxS step 1: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = MaxL..MaxL step 1
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(MaxL)) {
+        return "Wrong elements for MaxL..MaxL step 1: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = MaxC..MaxC step 1
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>(MaxC)) {
+        return "Wrong elements for MaxC..MaxC step 1: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/progressionMaxValueToMinValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = MaxI..MinI step 1
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for MaxI..MinI step 1: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = MaxB..MinB step 1
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for MaxB..MinB step 1: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = MaxS..MinS step 1
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for MaxS..MinS step 1: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = MaxL..MinL step 1
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for MaxL..MinL step 1: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = MaxC..MinC step 1
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for MaxC..MinC step 1: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/progressionMinValueToMinValue.kt

@@ -0,0 +1,71 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = MinI..MinI step 1
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MinI)) {
+        return "Wrong elements for MinI..MinI step 1: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = MinB..MinB step 1
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(MinB.toInt())) {
+        return "Wrong elements for MinB..MinB step 1: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = MinS..MinS step 1
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(MinS.toInt())) {
+        return "Wrong elements for MinS..MinS step 1: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = MinL..MinL step 1
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(MinL)) {
+        return "Wrong elements for MinL..MinL step 1: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = MinC..MinC step 1
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>(MinC)) {
+        return "Wrong elements for MinC..MinC step 1: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/reversedBackSequence.kt

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

backend.native/tests/external/codegen/blackbox/ranges/expression/reversedEmptyBackSequence.kt

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

backend.native/tests/external/codegen/blackbox/ranges/expression/reversedEmptyRange.kt

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

backend.native/tests/external/codegen/blackbox/ranges/expression/reversedInexactSteppedDownTo.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = (8 downTo 3 step 2).reversed()
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(4, 6, 8)) {
+        return "Wrong elements for (8 downTo 3 step 2).reversed(): $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = (8.toByte() downTo 3.toByte() step 2).reversed()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(4, 6, 8)) {
+        return "Wrong elements for (8.toByte() downTo 3.toByte() step 2).reversed(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = (8.toShort() downTo 3.toShort() step 2).reversed()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(4, 6, 8)) {
+        return "Wrong elements for (8.toShort() downTo 3.toShort() step 2).reversed(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = (8.toLong() downTo 3.toLong() step 2.toLong()).reversed()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(4, 6, 8)) {
+        return "Wrong elements for (8.toLong() downTo 3.toLong() step 2.toLong()).reversed(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = ('d' downTo 'a' step 2).reversed()
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('b', 'd')) {
+        return "Wrong elements for ('d' downTo 'a' step 2).reversed(): $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/reversedRange.kt

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

backend.native/tests/external/codegen/blackbox/ranges/expression/reversedSimpleSteppedRange.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = (3..9 step 2).reversed()
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for (3..9 step 2).reversed(): $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = (3.toByte()..9.toByte() step 2).reversed()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for (3.toByte()..9.toByte() step 2).reversed(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = (3.toShort()..9.toShort() step 2).reversed()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for (3.toShort()..9.toShort() step 2).reversed(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = (3.toLong()..9.toLong() step 2.toLong()).reversed()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(9, 7, 5, 3)) {
+        return "Wrong elements for (3.toLong()..9.toLong() step 2.toLong()).reversed(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = ('c'..'g' step 2).reversed()
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('g', 'e', 'c')) {
+        return "Wrong elements for ('c'..'g' step 2).reversed(): $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/simpleDownTo.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 9 downTo 3
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(9, 8, 7, 6, 5, 4, 3)) {
+        return "Wrong elements for 9 downTo 3: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 9.toByte() downTo 3.toByte()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(9, 8, 7, 6, 5, 4, 3)) {
+        return "Wrong elements for 9.toByte() downTo 3.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 9.toShort() downTo 3.toShort()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(9, 8, 7, 6, 5, 4, 3)) {
+        return "Wrong elements for 9.toShort() downTo 3.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 9.toLong() downTo 3.toLong()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(9, 8, 7, 6, 5, 4, 3)) {
+        return "Wrong elements for 9.toLong() downTo 3.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'g' downTo 'c'
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('g', 'f', 'e', 'd', 'c')) {
+        return "Wrong elements for 'g' downTo 'c': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/simpleRange.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 3..9
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for 3..9: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 3.toByte()..9.toByte()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for 3.toByte()..9.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 3.toShort()..9.toShort()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for 3.toShort()..9.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 3.toLong()..9.toLong()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for 3.toLong()..9.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'c'..'g'
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('c', 'd', 'e', 'f', 'g')) {
+        return "Wrong elements for 'c'..'g': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/simpleRangeWithNonConstantEnds.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = (1 + 2)..(10 - 1)
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for (1 + 2)..(10 - 1): $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = (1.toByte() + 2.toByte()).toByte()..(10.toByte() - 1.toByte()).toByte()
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for (1.toByte() + 2.toByte()).toByte()..(10.toByte() - 1.toByte()).toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = (1.toShort() + 2.toShort()).toShort()..(10.toShort() - 1.toShort()).toShort()
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for (1.toShort() + 2.toShort()).toShort()..(10.toShort() - 1.toShort()).toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = (1.toLong() + 2.toLong())..(10.toLong() - 1.toLong())
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for (1.toLong() + 2.toLong())..(10.toLong() - 1.toLong()): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = ("ace"[1])..("age"[1])
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('c', 'd', 'e', 'f', 'g')) {
+        return "Wrong elements for (\"ace\"[1])..(\"age\"[1]): $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/simpleSteppedDownTo.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 9 downTo 3 step 2
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for 9 downTo 3 step 2: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 9.toByte() downTo 3.toByte() step 2
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for 9.toByte() downTo 3.toByte() step 2: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 9.toShort() downTo 3.toShort() step 2
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for 9.toShort() downTo 3.toShort() step 2: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 9.toLong() downTo 3.toLong() step 2.toLong()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(9, 7, 5, 3)) {
+        return "Wrong elements for 9.toLong() downTo 3.toLong() step 2.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'g' downTo 'c' step 2
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('g', 'e', 'c')) {
+        return "Wrong elements for 'g' downTo 'c' step 2: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/expression/simpleSteppedRange.kt

@@ -0,0 +1,57 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    val range1 = 3..9 step 2
+    for (i in range1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(3, 5, 7, 9)) {
+        return "Wrong elements for 3..9 step 2: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    val range2 = 3.toByte()..9.toByte() step 2
+    for (i in range2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(3, 5, 7, 9)) {
+        return "Wrong elements for 3.toByte()..9.toByte() step 2: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    val range3 = 3.toShort()..9.toShort() step 2
+    for (i in range3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(3, 5, 7, 9)) {
+        return "Wrong elements for 3.toShort()..9.toShort() step 2: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    val range4 = 3.toLong()..9.toLong() step 2.toLong()
+    for (i in range4) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(3, 5, 7, 9)) {
+        return "Wrong elements for 3.toLong()..9.toLong() step 2.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    val range5 = 'c'..'g' step 2
+    for (i in range5) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('c', 'e', 'g')) {
+        return "Wrong elements for 'c'..'g' step 2: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forByteProgressionWithIntIncrement.kt

@@ -0,0 +1,9 @@
+// WITH_RUNTIME
+
+fun box(): String {
+    for (element in 5.toByte()..1.toByte() step 255) {
+        return "Fail: iterating over an empty progression, element: $element"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInDownTo/forIntInDownTo.kt

@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    var sum = 0
+    for (i in 4 downTo 1) {
+        sum = sum * 10 + i
+    }
+    assertEquals(4321, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInDownTo/forIntInNonOptimizedDownTo.kt

@@ -0,0 +1,14 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    var sum = 0
+    val dt = 4 downTo 1
+    for (i in dt) {
+        sum = sum * 10 + i
+    }
+    assertEquals(4321, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInDownTo/forLongInDownTo.kt

@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    var sum = 0L
+    for (i in 4L downTo 1L) {
+        sum = sum * 10L + i
+    }
+    assertEquals(4321L, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInDownTo/forNullableIntInDownTo.kt

@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    var sum = 0
+    for (i: Int? in 4 downTo 1) {
+        sum = sum * 10 + (i ?: 0)
+    }
+    assertEquals(4321, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/forInCharSequenceIndices.kt

@@ -0,0 +1,16 @@
+// WITH_RUNTIME
+
+fun test(s: CharSequence): Int {
+    var result = 0
+    for (i in s.indices) {
+        result = result * 10 + (i + 1)
+    }
+    return result
+}
+
+fun box(): String {
+    val test = test("abcd")
+    if (test != 1234) return "Fail: $test"
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/forInCollectionImplicitReceiverIndices.kt

@@ -0,0 +1,19 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun Collection<Int>.sumIndices(): Int {
+    var sum = 0
+    for (i in indices) {
+        sum += i
+    }
+    return sum
+}
+
+fun box(): String {
+    val list = listOf(0, 0, 0, 0)
+    val sum = list.sumIndices()
+    assertEquals(6, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/forInCollectionIndices.kt

@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    var sum = 0
+    for (i in listOf(0, 0, 0, 0).indices) {
+        sum += i
+    }
+    assertEquals(6, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/forInNonOptimizedIndices.kt

@@ -0,0 +1,18 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun sumIndices(coll: Collection<*>?): Int {
+    var sum = 0
+    for (i in coll?.indices ?: return 0) {
+        sum += i
+    }
+    return sum
+}
+
+fun box(): String {
+    assertEquals(6, sumIndices(listOf(0, 0, 0, 0)))
+    assertEquals(0, sumIndices(null))
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/forInObjectArrayIndices.kt

@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    var sum = 0
+    for (i in arrayOf("", "", "", "").indices) {
+        sum += i
+    }
+    assertEquals(6, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/forInPrimitiveArrayIndices.kt

@@ -0,0 +1,13 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun box(): String {
+    var sum = 0
+    for (i in intArrayOf(0, 0, 0, 0).indices) {
+        sum += i
+    }
+    assertEquals(6, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/forNullableIntInArrayIndices.kt

@@ -0,0 +1,16 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun suppressBoxingOptimization(ni: Int?) {}
+
+fun box(): String {
+    var sum = 0
+    for (i: Int? in arrayOf("", "", "", "").indices) {
+        suppressBoxingOptimization(i)
+        sum += i ?: 0
+    }
+    assertEquals(6, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/forNullableIntInCollectionIndices.kt

@@ -0,0 +1,16 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun suppressBoxingOptimization(ni: Int?) {}
+
+fun box(): String {
+    var sum = 0
+    for (i: Int? in listOf("", "", "", "").indices) {
+        suppressBoxingOptimization(i)
+        sum += i ?: 0
+    }
+    assertEquals(6, sum)
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/kt12983_forInGenericArrayIndices.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+abstract class BaseGeneric<T>(val t: T) {
+    abstract fun iterate()
+}
+
+class Derived<T>(array: Array<T>) : BaseGeneric<Array<T>>(array) {
+    var test = 0
+
+    override fun iterate() {
+        test = 0
+        for (i in t.indices) {
+            test = test * 10 + (i + 1)
+        }
+    }
+}
+
+fun box(): String {
+    val t = Derived(arrayOf("", "", "", ""))
+    t.iterate()
+    return if (t.test == 1234) "OK" else "Fail: ${t.test}"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/kt12983_forInGenericCollectionIndices.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+abstract class BaseGeneric<T>(val t: T) {
+    abstract fun iterate()
+}
+
+class Derived<T>(t: List<T>) : BaseGeneric<List<T>>(t) {
+    var test = 0
+
+    override fun iterate() {
+        test = 0
+        for (i in t.indices) {
+            test = test * 10 + (i + 1)
+        }
+    }
+}
+
+fun box(): String {
+    val t = Derived(listOf("", "", "", ""))
+    t.iterate()
+    return if (t.test == 1234) "OK" else "Fail: ${t.test}"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/kt12983_forInSpecificArrayIndices.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+abstract class BaseGeneric<T>(val t: T) {
+    abstract fun iterate()
+}
+
+class Derived(array: DoubleArray) : BaseGeneric<DoubleArray>(array) {
+    var test = 0
+
+    override fun iterate() {
+        test = 0
+        for (i in t.indices) {
+            test = test * 10 + (i + 1)
+        }
+    }
+}
+
+fun box(): String {
+    val t = Derived(doubleArrayOf(0.0, 0.0, 0.0, 0.0))
+    t.iterate()
+    return if (t.test == 1234) "OK" else "Fail: ${t.test}"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/kt12983_forInSpecificCollectionIndices.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+abstract class BaseGeneric<T>(val t: T) {
+    abstract fun iterate()
+}
+
+class Derived(t: List<Int>) : BaseGeneric<List<Int>>(t) {
+    var test = 0
+
+    override fun iterate() {
+        test = 0
+        for (i in t.indices) {
+            test = test * 10 + (i + 1)
+        }
+    }
+}
+
+fun box(): String {
+    val t = Derived(listOf(1, 2, 3, 4))
+    t.iterate()
+    return if (t.test == 1234) "OK" else "Fail: ${t.test}"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/kt13241_Array.kt

@@ -0,0 +1,21 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun test(x: Any): Int {
+    var sum = 0
+    if (x is IntArray) {
+        for (i in x.indices) {
+            sum = sum * 10 + i
+        }
+    }
+    return sum
+}
+
+fun box(): String {
+    assertEquals(123, test(intArrayOf(0, 0, 0, 0)))
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/kt13241_CharSequence.kt

@@ -0,0 +1,18 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun test(x: Any): Int {
+    var sum = 0
+    if (x is String) {
+        for (i in x.indices) {
+            sum = sum * 10 + i
+        }
+    }
+    return sum
+}
+
+fun box(): String {
+    assertEquals(123, test("0000"))
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInIndices/kt13241_Collection.kt

@@ -0,0 +1,18 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun test(x: Any): Int {
+    var sum = 0
+    if (x is List<*>) {
+        for (i in x.indices) {
+            sum = sum * 10 + i
+        }
+    }
+    return sum
+}
+
+fun box(): String {
+    assertEquals(123, test(listOf(0, 0, 0, 0)))
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forInRangeWithImplicitReceiver.kt

@@ -0,0 +1,17 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun Int.digitsUpto(end: Int): Int {
+    var sum = 0
+    for (i in rangeTo(end)) {
+        sum = sum*10 + i
+    }
+    return sum
+}
+
+fun box(): String {
+    assertEquals(1234, 1.digitsUpto(4))
+    return "OK"
+}
+

backend.native/tests/external/codegen/blackbox/ranges/forIntRange.kt

@@ -0,0 +1,15 @@
+// WITH_RUNTIME
+
+fun box() : String {
+    val a = arrayOfNulls<String>(3)
+    a[0] = "a"
+    a[1] = "b"
+    a[2] = "c"
+
+    var result = 0
+    for(i in a.indices) {
+      result += i
+    }
+    if (result != 3) return "FAIL"
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/forNullableIntInRangeWithImplicitReceiver.kt

@@ -0,0 +1,20 @@
+// WITH_RUNTIME
+
+import kotlin.test.assertEquals
+
+fun suppressBoxingOptimization(ni: Int?) {}
+
+fun Int.digitsUpto(end: Int): Int {
+    var sum = 0
+    for (i: Int? in rangeTo(end)) {
+        suppressBoxingOptimization(i)
+        sum = sum*10 + i!!
+    }
+    return sum
+}
+
+fun box(): String {
+    assertEquals(1234, 1.digitsUpto(4))
+    return "OK"
+}
+

backend.native/tests/external/codegen/blackbox/ranges/literal/emptyDownto.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 5 downTo 10) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for 5 downTo 10: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 5.toByte() downTo 10.toByte()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for 5.toByte() downTo 10.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 5.toShort() downTo 10.toShort()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for 5.toShort() downTo 10.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 5.toLong() downTo 10.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for 5.toLong() downTo 10.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'a' downTo 'z') {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for 'a' downTo 'z': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/emptyRange.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 10..5) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for 10..5: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 10.toByte()..(-5).toByte()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for 10.toByte()..(-5).toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 10.toShort()..(-5).toShort()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for 10.toShort()..(-5).toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 10.toLong()..-5.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for 10.toLong()..-5.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'z'..'a') {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for 'z'..'a': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/inexactDownToMinValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (MinI + 5) downTo MinI step 3) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MinI + 5, MinI + 2)) {
+        return "Wrong elements for (MinI + 5) downTo MinI step 3: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (MinB + 5).toByte() downTo MinB step 3) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MinB + 5).toInt(), (MinB + 2).toInt())) {
+        return "Wrong elements for (MinB + 5).toByte() downTo MinB step 3: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (MinS + 5).toShort() downTo MinS step 3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MinS + 5).toInt(), (MinS + 2).toInt())) {
+        return "Wrong elements for (MinS + 5).toShort() downTo MinS step 3: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (MinL + 5).toLong() downTo MinL step 3) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MinL + 5).toLong(), (MinL + 2).toLong())) {
+        return "Wrong elements for (MinL + 5).toLong() downTo MinL step 3: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in (MinC + 5) downTo MinC step 3) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MinC + 5), (MinC + 2))) {
+        return "Wrong elements for (MinC + 5) downTo MinC step 3: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/inexactSteppedDownTo.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 8 downTo 3 step 2) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(8, 6, 4)) {
+        return "Wrong elements for 8 downTo 3 step 2: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 8.toByte() downTo 3.toByte() step 2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(8, 6, 4)) {
+        return "Wrong elements for 8.toByte() downTo 3.toByte() step 2: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 8.toShort() downTo 3.toShort() step 2) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(8, 6, 4)) {
+        return "Wrong elements for 8.toShort() downTo 3.toShort() step 2: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 8.toLong() downTo 3.toLong() step 2.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(8, 6, 4)) {
+        return "Wrong elements for 8.toLong() downTo 3.toLong() step 2.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'd' downTo 'a' step 2) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('d', 'b')) {
+        return "Wrong elements for 'd' downTo 'a' step 2: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/inexactSteppedRange.kt

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

backend.native/tests/external/codegen/blackbox/ranges/literal/inexactToMaxValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (MaxI - 5)..MaxI step 3) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI - 5, MaxI - 2)) {
+        return "Wrong elements for (MaxI - 5)..MaxI step 3: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (MaxB - 5).toByte()..MaxB step 3) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MaxB - 5).toInt(), (MaxB - 2).toInt())) {
+        return "Wrong elements for (MaxB - 5).toByte()..MaxB step 3: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (MaxS - 5).toShort()..MaxS step 3) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MaxS - 5).toInt(), (MaxS - 2).toInt())) {
+        return "Wrong elements for (MaxS - 5).toShort()..MaxS step 3: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (MaxL - 5).toLong()..MaxL step 3) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MaxL - 5).toLong(), (MaxL - 2).toLong())) {
+        return "Wrong elements for (MaxL - 5).toLong()..MaxL step 3: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in (MaxC - 5)..MaxC step 3) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MaxC - 5), (MaxC - 2))) {
+        return "Wrong elements for (MaxC - 5)..MaxC step 3: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/maxValueMinusTwoToMaxValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (MaxI - 2)..MaxI) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI - 2, MaxI - 1, MaxI)) {
+        return "Wrong elements for (MaxI - 2)..MaxI: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (MaxB - 2).toByte()..MaxB) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MaxB - 2).toInt(), (MaxB - 1).toInt(), MaxB.toInt())) {
+        return "Wrong elements for (MaxB - 2).toByte()..MaxB: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (MaxS - 2).toShort()..MaxS) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MaxS - 2).toInt(), (MaxS - 1).toInt(), MaxS.toInt())) {
+        return "Wrong elements for (MaxS - 2).toShort()..MaxS: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (MaxL - 2).toLong()..MaxL) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MaxL - 2).toLong(), (MaxL - 1).toLong(), MaxL)) {
+        return "Wrong elements for (MaxL - 2).toLong()..MaxL: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in (MaxC - 2)..MaxC) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MaxC - 2), (MaxC - 1), MaxC)) {
+        return "Wrong elements for (MaxC - 2)..MaxC: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/maxValueToMaxValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in MaxI..MaxI) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI)) {
+        return "Wrong elements for MaxI..MaxI: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in MaxB..MaxB) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(MaxB.toInt())) {
+        return "Wrong elements for MaxB..MaxB: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in MaxS..MaxS) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(MaxS.toInt())) {
+        return "Wrong elements for MaxS..MaxS: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in MaxL..MaxL) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(MaxL)) {
+        return "Wrong elements for MaxL..MaxL: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in MaxC..MaxC) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>(MaxC)) {
+        return "Wrong elements for MaxC..MaxC: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/maxValueToMinValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in MaxI..MinI) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for MaxI..MinI: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in MaxB..MinB) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for MaxB..MinB: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in MaxS..MinS) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for MaxS..MinS: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in MaxL..MinL) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for MaxL..MinL: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in MaxC..MinC) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for MaxC..MinC: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/oneElementDownTo.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 5 downTo 5) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(5)) {
+        return "Wrong elements for 5 downTo 5: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 5.toByte() downTo 5.toByte()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(5)) {
+        return "Wrong elements for 5.toByte() downTo 5.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 5.toShort() downTo 5.toShort()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(5)) {
+        return "Wrong elements for 5.toShort() downTo 5.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 5.toLong() downTo 5.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(5.toLong())) {
+        return "Wrong elements for 5.toLong() downTo 5.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'k' downTo 'k') {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('k')) {
+        return "Wrong elements for 'k' downTo 'k': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/oneElementRange.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 5..5) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(5)) {
+        return "Wrong elements for 5..5: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 5.toByte()..5.toByte()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(5)) {
+        return "Wrong elements for 5.toByte()..5.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 5.toShort()..5.toShort()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(5)) {
+        return "Wrong elements for 5.toShort()..5.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 5.toLong()..5.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(5.toLong())) {
+        return "Wrong elements for 5.toLong()..5.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'k'..'k') {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('k')) {
+        return "Wrong elements for 'k'..'k': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/openRange.kt

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

backend.native/tests/external/codegen/blackbox/ranges/literal/progressionDownToMinValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (MinI + 2) downTo MinI step 1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MinI + 2, MinI + 1, MinI)) {
+        return "Wrong elements for (MinI + 2) downTo MinI step 1: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (MinB + 2).toByte() downTo MinB step 1) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MinB + 2).toInt(), (MinB + 1).toInt(), MinB.toInt())) {
+        return "Wrong elements for (MinB + 2).toByte() downTo MinB step 1: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (MinS + 2).toShort() downTo MinS step 1) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MinS + 2).toInt(), (MinS + 1).toInt(), MinS.toInt())) {
+        return "Wrong elements for (MinS + 2).toShort() downTo MinS step 1: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (MinL + 2).toLong() downTo MinL step 1) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MinL + 2).toLong(), (MinL + 1).toLong(), MinL)) {
+        return "Wrong elements for (MinL + 2).toLong() downTo MinL step 1: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in (MinC + 2) downTo MinC step 1) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MinC + 2), (MinC + 1), MinC)) {
+        return "Wrong elements for (MinC + 2) downTo MinC step 1: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/progressionMaxValueMinusTwoToMaxValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (MaxI - 2)..MaxI step 2) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI - 2, MaxI)) {
+        return "Wrong elements for (MaxI - 2)..MaxI step 2: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (MaxB - 2).toByte()..MaxB step 2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>((MaxB - 2).toInt(), MaxB.toInt())) {
+        return "Wrong elements for (MaxB - 2).toByte()..MaxB step 2: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (MaxS - 2).toShort()..MaxS step 2) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>((MaxS - 2).toInt(), MaxS.toInt())) {
+        return "Wrong elements for (MaxS - 2).toShort()..MaxS step 2: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (MaxL - 2).toLong()..MaxL step 2) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>((MaxL - 2).toLong(), MaxL)) {
+        return "Wrong elements for (MaxL - 2).toLong()..MaxL step 2: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in (MaxC - 2)..MaxC step 2) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>((MaxC - 2), MaxC)) {
+        return "Wrong elements for (MaxC - 2)..MaxC step 2: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/progressionMaxValueToMaxValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in MaxI..MaxI step 1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MaxI)) {
+        return "Wrong elements for MaxI..MaxI step 1: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in MaxB..MaxB step 1) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(MaxB.toInt())) {
+        return "Wrong elements for MaxB..MaxB step 1: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in MaxS..MaxS step 1) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(MaxS.toInt())) {
+        return "Wrong elements for MaxS..MaxS step 1: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in MaxL..MaxL step 1) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(MaxL)) {
+        return "Wrong elements for MaxL..MaxL step 1: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in MaxC..MaxC step 1) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>(MaxC)) {
+        return "Wrong elements for MaxC..MaxC step 1: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/progressionMaxValueToMinValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in MaxI..MinI step 1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for MaxI..MinI step 1: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in MaxB..MinB step 1) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for MaxB..MinB step 1: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in MaxS..MinS step 1) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for MaxS..MinS step 1: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in MaxL..MinL step 1) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for MaxL..MinL step 1: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in MaxC..MinC step 1) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for MaxC..MinC step 1: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/progressionMinValueToMinValue.kt

@@ -0,0 +1,66 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+import java.lang.Integer.MAX_VALUE as MaxI
+import java.lang.Integer.MIN_VALUE as MinI
+import java.lang.Byte.MAX_VALUE as MaxB
+import java.lang.Byte.MIN_VALUE as MinB
+import java.lang.Short.MAX_VALUE as MaxS
+import java.lang.Short.MIN_VALUE as MinS
+import java.lang.Long.MAX_VALUE as MaxL
+import java.lang.Long.MIN_VALUE as MinL
+import java.lang.Character.MAX_VALUE as MaxC
+import java.lang.Character.MIN_VALUE as MinC
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in MinI..MinI step 1) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(MinI)) {
+        return "Wrong elements for MinI..MinI step 1: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in MinB..MinB step 1) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(MinB.toInt())) {
+        return "Wrong elements for MinB..MinB step 1: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in MinS..MinS step 1) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(MinS.toInt())) {
+        return "Wrong elements for MinS..MinS step 1: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in MinL..MinL step 1) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(MinL)) {
+        return "Wrong elements for MinL..MinL step 1: $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in MinC..MinC step 1) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>(MinC)) {
+        return "Wrong elements for MinC..MinC step 1: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/reversedBackSequence.kt

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

backend.native/tests/external/codegen/blackbox/ranges/literal/reversedEmptyBackSequence.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (3 downTo 5).reversed()) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>()) {
+        return "Wrong elements for (3 downTo 5).reversed(): $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (3.toByte() downTo 5.toByte()).reversed()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>()) {
+        return "Wrong elements for (3.toByte() downTo 5.toByte()).reversed(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (3.toShort() downTo 5.toShort()).reversed()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>()) {
+        return "Wrong elements for (3.toShort() downTo 5.toShort()).reversed(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (3.toLong() downTo 5.toLong()).reversed()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>()) {
+        return "Wrong elements for (3.toLong() downTo 5.toLong()).reversed(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in ('a' downTo 'c').reversed()) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>()) {
+        return "Wrong elements for ('a' downTo 'c').reversed(): $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/reversedEmptyRange.kt

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

backend.native/tests/external/codegen/blackbox/ranges/literal/reversedInexactSteppedDownTo.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (8 downTo 3 step 2).reversed()) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(4, 6, 8)) {
+        return "Wrong elements for (8 downTo 3 step 2).reversed(): $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (8.toByte() downTo 3.toByte() step 2).reversed()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(4, 6, 8)) {
+        return "Wrong elements for (8.toByte() downTo 3.toByte() step 2).reversed(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (8.toShort() downTo 3.toShort() step 2).reversed()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(4, 6, 8)) {
+        return "Wrong elements for (8.toShort() downTo 3.toShort() step 2).reversed(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (8.toLong() downTo 3.toLong() step 2.toLong()).reversed()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(4, 6, 8)) {
+        return "Wrong elements for (8.toLong() downTo 3.toLong() step 2.toLong()).reversed(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in ('d' downTo 'a' step 2).reversed()) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('b', 'd')) {
+        return "Wrong elements for ('d' downTo 'a' step 2).reversed(): $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/reversedRange.kt

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

backend.native/tests/external/codegen/blackbox/ranges/literal/reversedSimpleSteppedRange.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (3..9 step 2).reversed()) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for (3..9 step 2).reversed(): $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (3.toByte()..9.toByte() step 2).reversed()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for (3.toByte()..9.toByte() step 2).reversed(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (3.toShort()..9.toShort() step 2).reversed()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for (3.toShort()..9.toShort() step 2).reversed(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (3.toLong()..9.toLong() step 2.toLong()).reversed()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(9, 7, 5, 3)) {
+        return "Wrong elements for (3.toLong()..9.toLong() step 2.toLong()).reversed(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in ('c'..'g' step 2).reversed()) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('g', 'e', 'c')) {
+        return "Wrong elements for ('c'..'g' step 2).reversed(): $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/simpleDownTo.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 9 downTo 3) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(9, 8, 7, 6, 5, 4, 3)) {
+        return "Wrong elements for 9 downTo 3: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 9.toByte() downTo 3.toByte()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(9, 8, 7, 6, 5, 4, 3)) {
+        return "Wrong elements for 9.toByte() downTo 3.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 9.toShort() downTo 3.toShort()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(9, 8, 7, 6, 5, 4, 3)) {
+        return "Wrong elements for 9.toShort() downTo 3.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 9.toLong() downTo 3.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(9, 8, 7, 6, 5, 4, 3)) {
+        return "Wrong elements for 9.toLong() downTo 3.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'g' downTo 'c') {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('g', 'f', 'e', 'd', 'c')) {
+        return "Wrong elements for 'g' downTo 'c': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/simpleRange.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 3..9) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for 3..9: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 3.toByte()..9.toByte()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for 3.toByte()..9.toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 3.toShort()..9.toShort()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for 3.toShort()..9.toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 3.toLong()..9.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for 3.toLong()..9.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'c'..'g') {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('c', 'd', 'e', 'f', 'g')) {
+        return "Wrong elements for 'c'..'g': $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/simpleRangeWithNonConstantEnds.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in (1 + 2)..(10 - 1)) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for (1 + 2)..(10 - 1): $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in (1.toByte() + 2.toByte()).toByte()..(10.toByte() - 1.toByte()).toByte()) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for (1.toByte() + 2.toByte()).toByte()..(10.toByte() - 1.toByte()).toByte(): $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in (1.toShort() + 2.toShort()).toShort()..(10.toShort() - 1.toShort()).toShort()) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for (1.toShort() + 2.toShort()).toShort()..(10.toShort() - 1.toShort()).toShort(): $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in (1.toLong() + 2.toLong())..(10.toLong() - 1.toLong())) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(3, 4, 5, 6, 7, 8, 9)) {
+        return "Wrong elements for (1.toLong() + 2.toLong())..(10.toLong() - 1.toLong()): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in ("ace"[1])..("age"[1])) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('c', 'd', 'e', 'f', 'g')) {
+        return "Wrong elements for (\"ace\"[1])..(\"age\"[1]): $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/simpleSteppedDownTo.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 9 downTo 3 step 2) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for 9 downTo 3 step 2: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 9.toByte() downTo 3.toByte() step 2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for 9.toByte() downTo 3.toByte() step 2: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 9.toShort() downTo 3.toShort() step 2) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(9, 7, 5, 3)) {
+        return "Wrong elements for 9.toShort() downTo 3.toShort() step 2: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 9.toLong() downTo 3.toLong() step 2.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(9, 7, 5, 3)) {
+        return "Wrong elements for 9.toLong() downTo 3.toLong() step 2.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'g' downTo 'c' step 2) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('g', 'e', 'c')) {
+        return "Wrong elements for 'g' downTo 'c' step 2: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/literal/simpleSteppedRange.kt

@@ -0,0 +1,52 @@
+// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT!
+// WITH_RUNTIME
+
+
+fun box(): String {
+    val list1 = ArrayList<Int>()
+    for (i in 3..9 step 2) {
+        list1.add(i)
+        if (list1.size > 23) break
+    }
+    if (list1 != listOf<Int>(3, 5, 7, 9)) {
+        return "Wrong elements for 3..9 step 2: $list1"
+    }
+
+    val list2 = ArrayList<Int>()
+    for (i in 3.toByte()..9.toByte() step 2) {
+        list2.add(i)
+        if (list2.size > 23) break
+    }
+    if (list2 != listOf<Int>(3, 5, 7, 9)) {
+        return "Wrong elements for 3.toByte()..9.toByte() step 2: $list2"
+    }
+
+    val list3 = ArrayList<Int>()
+    for (i in 3.toShort()..9.toShort() step 2) {
+        list3.add(i)
+        if (list3.size > 23) break
+    }
+    if (list3 != listOf<Int>(3, 5, 7, 9)) {
+        return "Wrong elements for 3.toShort()..9.toShort() step 2: $list3"
+    }
+
+    val list4 = ArrayList<Long>()
+    for (i in 3.toLong()..9.toLong() step 2.toLong()) {
+        list4.add(i)
+        if (list4.size > 23) break
+    }
+    if (list4 != listOf<Long>(3, 5, 7, 9)) {
+        return "Wrong elements for 3.toLong()..9.toLong() step 2.toLong(): $list4"
+    }
+
+    val list5 = ArrayList<Char>()
+    for (i in 'c'..'g' step 2) {
+        list5.add(i)
+        if (list5.size > 23) break
+    }
+    if (list5 != listOf<Char>('c', 'e', 'g')) {
+        return "Wrong elements for 'c'..'g' step 2: $list5"
+    }
+
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/multiAssignmentIterationOverIntRange.kt

@@ -0,0 +1,23 @@
+// WITH_RUNTIME
+
+operator fun Int.component1(): String {
+    return arrayListOf("zero", "one", "two", "three")[this]
+}
+
+operator fun Int.component2(): Int {
+    return arrayListOf(0, 1, 4, 9)[this]
+}
+
+fun box(): String {
+    val strings = arrayListOf<String>()
+    val squares = arrayListOf<Int>()
+
+    for ((str, sq) in 1..3) {
+        strings.add(str)
+        squares.add(sq)
+    }
+
+    if (strings != arrayListOf("one", "two", "three")) return "FAIL: $strings"
+    if (squares != arrayListOf(1, 4, 9)) return "FAIL: $squares"
+    return "OK"
+}

backend.native/tests/external/codegen/blackbox/ranges/nullableLoopParameter/progressionExpression.kt

@@ -0,0 +1,12 @@
+fun box(): String {
+    var result = 0
+    val intRange: IntProgression = 1..3
+    for (i: Int? in intRange) {
+        result = sum(result, i)
+    }
+    return if (result == 6) "OK" else "fail: $result"
+}
+
+fun sum(i: Int, z: Int?): Int {
+    return i + z!!
+}

backend.native/tests/external/codegen/blackbox/ranges/nullableLoopParameter/rangeExpression.kt

@@ -0,0 +1,12 @@
+fun box(): String {
+    var result = 0
+    val intRange = 1..3
+    for (i: Int? in intRange) {
+        result = sum(result, i)
+    }
+    return if (result == 6) "OK" else "fail: $result"
+}
+
+fun sum(i: Int, z: Int?): Int {
+    return i + z!!
+}

backend.native/tests/external/codegen/blackbox/ranges/nullableLoopParameter/rangeLiteral.kt

@@ -0,0 +1,11 @@
+fun box(): String {
+    var result = 0
+    for (i: Int? in 1..3) {
+        result = sum(result, i)
+    }
+    return if (result == 6) "OK" else "fail: $result"
+}
+
+fun sum(i: Int, z: Int?): Int {
+    return i + z!!
+}

backend.native/tests/external/codegen/blackbox/ranges/safeCallRangeTo.kt

@@ -0,0 +1,31 @@
+// TODO: muted automatically, investigate should it be ran for JS or not
+// IGNORE_BACKEND: JS
+
+// WITH_RUNTIME
+
+fun charRange(x: Char?, y: Char) = x?.rangeTo(y)
+fun byteRange(x: Byte?, y: Byte) = x?.rangeTo(y)
+fun shortRange(x: Short?, y: Short) = x?.rangeTo(y)
+fun intRange(x: Int?, y: Int) = x?.rangeTo(y)
+fun longRange(x: Long?, y: Long) = x?.rangeTo(y)
+fun floatRange(x: Float?, y: Float) = x?.rangeTo(y)
+fun dougleRange(x: Double?, y: Double) = x?.rangeTo(y)
+
+inline fun <reified T, R> testSafeRange(x: T, y: T, expectStr: String, safeRange: (T?, T) -> R?) {
+    val rNull = safeRange(null, y)
+    assert (rNull == null) { "${T::class.simpleName}: Expected: null, got $rNull" }
+
+    val rxy = safeRange(x, y)
+    assert (rxy?.toString() == expectStr) { "${T::class.simpleName}: Expected: $expectStr, got $rxy" }
+}
+
+fun box(): String {
+    testSafeRange('0', '1', "0..1", ::charRange)
+    testSafeRange(0, 1, "0..1", ::byteRange)
+    testSafeRange(0, 1, "0..1", ::shortRange)
+    testSafeRange(0, 1, "0..1", ::intRange)
+    testSafeRange(0L, 1L, "0..1", ::longRange)
+    testSafeRange(0.0f, 1.0f, "0.0..1.0", ::floatRange)
+    testSafeRange(0.0, 1.0, "0.0..1.0", ::dougleRange)
+    return "OK"
+}