[IR] add testdata for dumpKotlinLike

compiler/testData/ir/irText/expressions/floatingPointComparisons/comparableWithDoubleOrFloat.kt.txt

@@ -0,0 +1,20 @@
+fun testD(x: Comparable<Double>, y: Comparable<Double>): Boolean {
+  return when {
+    when {
+      x is Double -> y is Double
+      true -> false
+    } -> less(arg0 = x /*as Double */, arg1 = y /*as Double */)
+    true -> false
+  }
+}
+
+fun testF(x: Comparable<Float>, y: Comparable<Float>): Boolean {
+  return when {
+    when {
+      x is Float -> y is Float
+      true -> false
+    } -> less(arg0 = x /*as Float */, arg1 = y /*as Float */)
+    true -> false
+  }
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/eqeqRhsConditionPossiblyAffectingLhs.kt.txt

@@ -0,0 +1,7 @@
+fun test(x: Any): Boolean {
+  return EQEQ(arg0 = x, arg1 = when {
+    x !is Double -> CHECK_NOT_NULL<Nothing>(arg0 = null)
+    true -> x /*as Double */
+  })
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointCompareTo.kt.txt

@@ -0,0 +1,80 @@
+fun test1d(x: Double, y: Double): Int {
+  return x.compareTo(other = y)
+}
+
+fun test2d(x: Double, y: Any): Boolean {
+  return when {
+    y is Double -> EQEQ(arg0 = x.compareTo(other = y /*as Double */), arg1 = 0)
+    true -> false
+  }
+}
+
+fun test3d(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Double
+      true -> false
+    } -> EQEQ(arg0 = x /*as Double */.compareTo(other = y /*as Double */), arg1 = 0)
+    true -> false
+  }
+}
+
+fun test1f(x: Float, y: Float): Int {
+  return x.compareTo(other = y)
+}
+
+fun test2f(x: Float, y: Any): Boolean {
+  return when {
+    y is Float -> EQEQ(arg0 = x.compareTo(other = y /*as Float */), arg1 = 0)
+    true -> false
+  }
+}
+
+fun test3f(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Float
+      true -> false
+    } -> EQEQ(arg0 = x /*as Float */.compareTo(other = y /*as Float */), arg1 = 0)
+    true -> false
+  }
+}
+
+fun testFD(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Double
+      true -> false
+    } -> EQEQ(arg0 = x /*as Float */.compareTo(other = y /*as Double */), arg1 = 0)
+    true -> false
+  }
+}
+
+fun testDF(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Float
+      true -> false
+    } -> EQEQ(arg0 = x /*as Double */.compareTo(other = y /*as Float */), arg1 = 0)
+    true -> false
+  }
+}
+
+fun Float.test1fr(x: Float): Int {
+  return <this>.compareTo(other = x)
+}
+
+fun Float.test2fr(x: Any): Boolean {
+  return when {
+    x is Float -> EQEQ(arg0 = <this>.compareTo(other = x /*as Float */), arg1 = 0)
+    true -> false
+  }
+}
+
+fun Float.test3fr(x: Any): Boolean {
+  return when {
+    x is Double -> EQEQ(arg0 = <this>.compareTo(other = x /*as Double */), arg1 = 0)
+    true -> false
+  }
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointEqeq.kt.txt

@@ -0,0 +1,86 @@
+fun test1d(x: Double, y: Double): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y)
+}
+
+fun test2d(x: Double, y: Double?): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y)
+}
+
+fun test3d(x: Double, y: Any): Boolean {
+  return EQEQ(arg0 = x, arg1 = y)
+}
+
+fun test4d(x: Double, y: Number): Boolean {
+  return EQEQ(arg0 = x, arg1 = y)
+}
+
+fun test5d(x: Double, y: Any): Boolean {
+  return when {
+    y is Double -> ieee754equals(arg0 = x, arg1 = y /*as Double */)
+    true -> false
+  }
+}
+
+fun test6d(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Double
+      true -> false
+    } -> ieee754equals(arg0 = x /*as Double */, arg1 = y /*as Double */)
+    true -> false
+  }
+}
+
+fun test1f(x: Float, y: Float): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y)
+}
+
+fun test2f(x: Float, y: Float?): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y)
+}
+
+fun test3f(x: Float, y: Any): Boolean {
+  return EQEQ(arg0 = x, arg1 = y)
+}
+
+fun test4f(x: Float, y: Number): Boolean {
+  return EQEQ(arg0 = x, arg1 = y)
+}
+
+fun test5f(x: Float, y: Any): Boolean {
+  return when {
+    y is Float -> ieee754equals(arg0 = x, arg1 = y /*as Float */)
+    true -> false
+  }
+}
+
+fun test6f(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Float
+      true -> false
+    } -> ieee754equals(arg0 = x /*as Float */, arg1 = y /*as Float */)
+    true -> false
+  }
+}
+
+fun testFD(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Double
+      true -> false
+    } -> ieee754equals(arg0 = x /*as Float */.toDouble(), arg1 = y /*as Double */)
+    true -> false
+  }
+}
+
+fun testDF(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Float
+      true -> false
+    } -> ieee754equals(arg0 = x /*as Double */, arg1 = y /*as Float */.toDouble())
+    true -> false
+  }
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointEquals.kt.txt

@@ -0,0 +1,116 @@
+fun test1d(x: Double, y: Double): Boolean {
+  return x.equals(other = y)
+}
+
+fun test2d(x: Double, y: Double?): Boolean {
+  return x.equals(other = y)
+}
+
+fun test3d(x: Double, y: Any): Boolean {
+  return x.equals(other = y)
+}
+
+fun test4d(x: Double, y: Number): Boolean {
+  return x.equals(other = y)
+}
+
+fun test5d(x: Double, y: Any): Boolean {
+  return when {
+    y is Double -> x.equals(other = y)
+    true -> false
+  }
+}
+
+fun test6d(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Double
+      true -> false
+    } -> x.equals(other = y)
+    true -> false
+  }
+}
+
+fun test1f(x: Float, y: Float): Boolean {
+  return x.equals(other = y)
+}
+
+fun test2f(x: Float, y: Float?): Boolean {
+  return x.equals(other = y)
+}
+
+fun test3f(x: Float, y: Any): Boolean {
+  return x.equals(other = y)
+}
+
+fun test4f(x: Float, y: Number): Boolean {
+  return x.equals(other = y)
+}
+
+fun test5f(x: Float, y: Any): Boolean {
+  return when {
+    y is Float -> x.equals(other = y)
+    true -> false
+  }
+}
+
+fun test6f(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Float
+      true -> false
+    } -> x.equals(other = y)
+    true -> false
+  }
+}
+
+fun testFD(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Double
+      true -> false
+    } -> x.equals(other = y)
+    true -> false
+  }
+}
+
+fun testDF(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Float
+      true -> false
+    } -> x.equals(other = y)
+    true -> false
+  }
+}
+
+fun Float.test1fr(x: Float): Boolean {
+  return <this>.equals(other = x)
+}
+
+fun Float.test2fr(x: Float?): Boolean {
+  return <this>.equals(other = x)
+}
+
+fun Float.test3fr(x: Any): Boolean {
+  return <this>.equals(other = x)
+}
+
+fun Float.test4fr(x: Number): Boolean {
+  return <this>.equals(other = x)
+}
+
+fun Float.test5fr(x: Any): Boolean {
+  return when {
+    x is Float -> <this>.equals(other = x)
+    true -> false
+  }
+}
+
+fun Float.test6fr(x: Any): Boolean {
+  return when {
+    x is Double -> <this>.equals(other = x)
+    true -> false
+  }
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointExcleq.kt.txt

@@ -0,0 +1,86 @@
+fun test1d(x: Double, y: Double): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y).not()
+}
+
+fun test2d(x: Double, y: Double?): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y).not()
+}
+
+fun test3d(x: Double, y: Any): Boolean {
+  return EQEQ(arg0 = x, arg1 = y).not()
+}
+
+fun test4d(x: Double, y: Number): Boolean {
+  return EQEQ(arg0 = x, arg1 = y).not()
+}
+
+fun test5d(x: Double, y: Any): Boolean {
+  return when {
+    y is Double -> ieee754equals(arg0 = x, arg1 = y /*as Double */).not()
+    true -> false
+  }
+}
+
+fun test6d(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Double
+      true -> false
+    } -> ieee754equals(arg0 = x /*as Double */, arg1 = y /*as Double */).not()
+    true -> false
+  }
+}
+
+fun test1f(x: Float, y: Float): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y).not()
+}
+
+fun test2f(x: Float, y: Float?): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y).not()
+}
+
+fun test3f(x: Float, y: Any): Boolean {
+  return EQEQ(arg0 = x, arg1 = y).not()
+}
+
+fun test4f(x: Float, y: Number): Boolean {
+  return EQEQ(arg0 = x, arg1 = y).not()
+}
+
+fun test5f(x: Float, y: Any): Boolean {
+  return when {
+    y is Float -> ieee754equals(arg0 = x, arg1 = y /*as Float */).not()
+    true -> false
+  }
+}
+
+fun test6f(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Float
+      true -> false
+    } -> ieee754equals(arg0 = x /*as Float */, arg1 = y /*as Float */).not()
+    true -> false
+  }
+}
+
+fun testFD(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Double
+      true -> false
+    } -> ieee754equals(arg0 = x /*as Float */.toDouble(), arg1 = y /*as Double */).not()
+    true -> false
+  }
+}
+
+fun testDF(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Float
+      true -> false
+    } -> ieee754equals(arg0 = x /*as Double */, arg1 = y /*as Float */.toDouble()).not()
+    true -> false
+  }
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointLess.kt.txt

@@ -0,0 +1,62 @@
+fun test1d(x: Double, y: Double): Boolean {
+  return less(arg0 = x, arg1 = y)
+}
+
+fun test2d(x: Double, y: Any): Boolean {
+  return when {
+    y is Double -> less(arg0 = x, arg1 = y /*as Double */)
+    true -> false
+  }
+}
+
+fun test3d(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Double
+      true -> false
+    } -> less(arg0 = x /*as Double */, arg1 = y /*as Double */)
+    true -> false
+  }
+}
+
+fun test1f(x: Float, y: Float): Boolean {
+  return less(arg0 = x, arg1 = y)
+}
+
+fun test2f(x: Float, y: Any): Boolean {
+  return when {
+    y is Float -> less(arg0 = x, arg1 = y /*as Float */)
+    true -> false
+  }
+}
+
+fun test3f(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Float
+      true -> false
+    } -> less(arg0 = x /*as Float */, arg1 = y /*as Float */)
+    true -> false
+  }
+}
+
+fun testFD(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Double
+      true -> false
+    } -> less(arg0 = x /*as Float */.toDouble(), arg1 = y /*as Double */)
+    true -> false
+  }
+}
+
+fun testDF(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Float
+      true -> false
+    } -> less(arg0 = x /*as Double */, arg1 = y /*as Float */.toDouble())
+    true -> false
+  }
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableAnyAsIntToDouble.kt.txt

@@ -0,0 +1,13 @@
+fun test(x: Any?, y: Double): Boolean {
+  return when {
+    x is Int -> less(arg0 = { //BLOCK
+      val tmp0_safe_receiver: Any? = x
+      when {
+        EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+        true -> tmp0_safe_receiver /*as Int */.toDouble()
+      }
+    }, arg1 = y)
+    true -> false
+  }
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableFloatingPointEqeq.kt.txt

@@ -0,0 +1,46 @@
+fun testDD(x: Double?, y: Double?): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y)
+}
+
+fun testDF(x: Double?, y: Any?): Boolean {
+  return when {
+    y is Float? -> ieee754equals(arg0 = x, arg1 = { //BLOCK
+      val tmp0_safe_receiver: Any? = y
+      when {
+        EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+        true -> tmp0_safe_receiver /*as Float */.toDouble()
+      }
+    })
+    true -> false
+  }
+}
+
+fun testDI(x: Double?, y: Any?): Boolean {
+  return when {
+    y is Int? -> ieee754equals(arg0 = x, arg1 = { //BLOCK
+      val tmp0_safe_receiver: Any? = y
+      when {
+        EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+        true -> tmp0_safe_receiver /*as Int */.toDouble()
+      }
+    })
+    true -> false
+  }
+}
+
+fun testDI2(x: Any?, y: Any?): Boolean {
+  return when {
+    when {
+      x is Int? -> y is Double
+      true -> false
+    } -> ieee754equals(arg0 = { //BLOCK
+      val tmp0_safe_receiver: Any? = x
+      when {
+        EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+        true -> tmp0_safe_receiver /*as Int */.toDouble()
+      }
+    }, arg1 = y /*as Double? */)
+    true -> false
+  }
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/typeParameterWithPrimitiveNumericSupertype.kt.txt

@@ -0,0 +1,68 @@
+fun <T : Any?> test0(x: Any, y: T): Boolean {
+  return when {
+    x is Int -> EQEQ(arg0 = x, arg1 = y)
+    true -> false
+  }
+}
+
+fun <T : Float> test1(x: Any, y: T): Boolean {
+  return when {
+    x is Float -> ieee754equals(arg0 = x /*as Float */, arg1 = y)
+    true -> false
+  }
+}
+
+fun <T : Double> test2(x: Any, y: T): Boolean {
+  return when {
+    x is Float -> ieee754equals(arg0 = x /*as Float */.toDouble(), arg1 = y)
+    true -> false
+  }
+}
+
+fun <T : Float> test3(x: Any, y: T): Boolean {
+  return when {
+    x is Int -> ieee754equals(arg0 = x /*as Int */.toFloat(), arg1 = y)
+    true -> false
+  }
+}
+
+fun <T : Float?> test4(x: Any, y: T): Boolean {
+  return when {
+    x is Int -> ieee754equals(arg0 = x /*as Int */.toFloat(), arg1 = y)
+    true -> false
+  }
+}
+
+fun <T : Float?, R : T> test5(x: Any, y: R): Boolean {
+  return when {
+    x is Int -> ieee754equals(arg0 = x /*as Int */.toFloat(), arg1 = y)
+    true -> false
+  }
+}
+
+fun <T : Number> test6(x: Any, y: T): Boolean {
+  return when {
+    x is Int -> EQEQ(arg0 = x, arg1 = y)
+    true -> false
+  }
+}
+
+class F<T : Float> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun testCapturedType(x: T, y: Any): Boolean {
+    return when {
+      y is Double -> ieee754equals(arg0 = x.toDouble(), arg1 = y /*as Double */)
+      true -> false
+    }
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/expressions/floatingPointComparisons/whenByFloatingPoint.kt.txt

@@ -0,0 +1,80 @@
+fun testSimple(x: Double): Int {
+  return { //BLOCK
+    val tmp0_subject: Double = x
+    when {
+      ieee754equals(arg0 = tmp0_subject, arg1 = 0.0D) -> 0
+      true -> 1
+    }
+  }
+}
+
+fun testSmartCastInWhenSubject(x: Any): Int {
+  when {
+    x !is Double -> return -1
+  }
+  return { //BLOCK
+    val tmp0_subject: Any = x
+    when {
+      ieee754equals(arg0 = tmp0_subject /*as Double */, arg1 = 0.0D) -> 0
+      true -> 1
+    }
+  }
+}
+
+fun testSmartCastInWhenCondition(x: Double, y: Any): Int {
+  when {
+    y !is Double -> return -1
+  }
+  return { //BLOCK
+    val tmp0_subject: Double = x
+    when {
+      ieee754equals(arg0 = tmp0_subject, arg1 = y /*as Double */) -> 0
+      true -> 1
+    }
+  }
+}
+
+fun testSmartCastInWhenConditionInBranch(x: Any): Int {
+  return { //BLOCK
+    val tmp0_subject: Any = x
+    when {
+      tmp0_subject is Double.not() -> -1
+      ieee754equals(arg0 = tmp0_subject /*as Double */, arg1 = 0.0D) -> 0
+      true -> 1
+    }
+  }
+}
+
+fun testSmartCastToDifferentTypes(x: Any, y: Any): Int {
+  when {
+    x !is Double -> return -1
+  }
+  when {
+    y !is Float -> return -1
+  }
+  return { //BLOCK
+    val tmp0_subject: Any = x
+    when {
+      ieee754equals(arg0 = tmp0_subject /*as Double */, arg1 = y /*as Float */.toDouble()) -> 0
+      true -> 1
+    }
+  }
+}
+
+fun foo(x: Double): Double {
+  return x
+}
+
+fun testWithPrematureExitInConditionSubexpression(x: Any): Int {
+  return { //BLOCK
+    val tmp0_subject: Any = x
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = foo(x = when {
+        x !is Double -> return 42
+        true -> x /*as Double */
+      })) -> 0
+      true -> 1
+    }
+  }
+}
+