KT-5044 implement missing Range#contains tests and move it to separate package

compiler/testData/codegen/box/collections/inSetWithSmartCast.kt

@@ -0,0 +1,15 @@
+// WITH_RUNTIME
+
+fun contains(set: Set<Any>, x: Int): Boolean = when {
+    set.size == 0 -> false
+    else -> x in set as Set<Int>
+}
+
+fun box(): String {
+    val set = setOf(1)
+    if (contains(set, 1)) {
+        return "OK"
+    }
+
+    return "Fail"
+}

compiler/testData/codegen/box/ranges/contains/inComparableRange.kt

@@ -0,0 +1,18 @@
+// 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 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))
+
+    return "OK"
+}

compiler/testData/codegen/box/ranges/contains/inExtensionRange.kt

@@ -0,0 +1,18 @@
+// 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"
+}

compiler/testData/codegen/box/ranges/contains/inOptimizableDoubleRange.kt

@@ -0,0 +1,33 @@
+// WITH_RUNTIME
+
+fun check(x: Double, left: Double, right: Double): Boolean {
+    val result = x in left..right
+    assert(result == checkUnoptimized(x, left..right))
+    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"
+}

compiler/testData/codegen/box/ranges/contains/inOptimizableFloatRange.kt

@@ -0,0 +1,33 @@
+// WITH_RUNTIME
+
+fun check(x: Float, left: Float, right: Float): Boolean {
+    val result = x in left..right
+    assert(result == checkUnoptimized(x, left..right))
+    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"
+}

compiler/testData/codegen/box/ranges/contains/inOptimizableIntRange.kt

@@ -0,0 +1,26 @@
+// WITH_RUNTIME
+
+fun check(x: Int, left: Int, right: Int): Boolean {
+    val result = x in left..right
+    assert(result == checkUnoptimized(x, left..right))
+    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"
+}

compiler/testData/codegen/box/ranges/contains/inOptimizableLongRange.kt

@@ -0,0 +1,26 @@
+// WITH_RUNTIME
+
+fun check(x: Long, left: Long, right: Long): Boolean {
+    val result = x in left..right
+    assert(result == checkUnoptimized(x, left..right))
+    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"
+}

compiler/testData/codegen/box/ranges/contains/inRangeWithCustomContains.kt

@@ -0,0 +1,24 @@
+// 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"
+}

compiler/testData/codegen/box/ranges/contains/inRangeWithImplicitReceiver.kt

@@ -0,0 +1,19 @@
+// 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"
+}

compiler/testData/codegen/box/ranges/contains/inRangeWithNonmatchingArguments.kt

@@ -0,0 +1,12 @@
+// 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"
+}