[IR] add testdata for dumpKotlinLike

compiler/testData/ir/irText/expressions/sam/arrayAsVarargAfterSamArgument.kt.txt

@@ -0,0 +1,45 @@
+fun test(fn: Function0<Unit>, r: Runnable, arr: Array<String>) {
+  foo1(r =   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> @FlexibleNullability Runnable? */, strs = arr) /*~> Unit */
+  foo1(r =   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> @FlexibleNullability Runnable? */, strs = [*arr]) /*~> Unit */
+  foo1(r = fn /*-> @FlexibleNullability Runnable? */, strs = arr) /*~> Unit */
+  foo1(r = fn /*-> @FlexibleNullability Runnable? */, strs = [*arr]) /*~> Unit */
+  foo1(r = r, strs = [""]) /*~> Unit */
+  foo1(r = fn /*-> @FlexibleNullability Runnable? */, strs = arr) /*~> Unit */
+  foo1(r = fn /*-> @FlexibleNullability Runnable? */, strs = [*arr]) /*~> Unit */
+  foo1(r = r, strs = [*arr]) /*~> Unit */
+  val i1: Test = TODO("IrConstructorCall")
+  val i2: Test = TODO("IrConstructorCall")
+  val i3: Test = TODO("IrConstructorCall")
+  val i4: Test = TODO("IrConstructorCall")
+  val i5: Test = TODO("IrConstructorCall")
+  val i6: Test = TODO("IrConstructorCall")
+  i1.foo2(r1 =   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> @FlexibleNullability Runnable? */, r2 =   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> @FlexibleNullability Runnable? */, strs = arr) /*~> Unit */
+  i1.foo2(r1 = r, r2 =   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> @FlexibleNullability Runnable? */, strs = [""]) /*~> Unit */
+  i1.foo2(r1 =   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> @FlexibleNullability Runnable? */, r2 =   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> @FlexibleNullability Runnable? */, strs = [*arr]) /*~> Unit */
+  i1.foo2(r1 = r, r2 =   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> @FlexibleNullability Runnable? */, strs = [*arr]) /*~> Unit */
+}
+

compiler/testData/ir/irText/expressions/sam/genericSamProjectedOut.kt.txt

@@ -0,0 +1,15 @@
+fun test(a: SomeJavaClass<out String>) {
+  a.someFunction(hello =   local fun <anonymous>(it: @FlexibleNullability String?) {
+    return Unit
+  }
+ /*-> @FlexibleNullability Hello<Nothing>? */)
+  a.plus(hello =   local fun <anonymous>(it: @FlexibleNullability String?) {
+    return Unit
+  }
+ /*-> @FlexibleNullability Hello<Nothing>? */)
+  a.get(hello =   local fun <anonymous>(it: @FlexibleNullability String?) {
+    return Unit
+  }
+ /*-> @FlexibleNullability Hello<Nothing>? */)
+}
+

compiler/testData/ir/irText/expressions/sam/samByProjectedType.kt.txt

@@ -0,0 +1,7 @@
+fun test1() {
+  bar(j =   local fun <anonymous>(x: Any): @FlexibleNullability Any? {
+    return x
+  }
+ /*-> @FlexibleNullability J<@FlexibleNullability Any?>? */)
+}
+

compiler/testData/ir/irText/expressions/sam/samConstructors.kt.txt

@@ -0,0 +1,25 @@
+fun test1(): Runnable {
+  return   local fun <anonymous>() {
+    return Unit
+  }
+ /*-> Runnable */
+}
+
+fun test2(a: Function0<Unit>): Runnable {
+  return a /*-> Runnable */
+}
+
+fun foo() {
+}
+
+fun test3(): Runnable {
+  return ::foo /*-> Runnable */
+}
+
+fun test4(): Comparator<Int> {
+  return   local fun <anonymous>(a: @FlexibleNullability Int?, b: @FlexibleNullability Int?): Int {
+    return a /*!! Int */.minus(other = b /*!! Int */)
+  }
+ /*-> Comparator<Int> */
+}
+

compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall.kt.txt

@@ -0,0 +1,9 @@
+fun test1(f: Function1<String, String>): C<@FlexibleNullability String?> {
+  return TODO("IrConstructorCall")
+}
+
+fun test2(x: Any) {
+  x as Function1<String, String> /*~> Unit */
+  TODO("IrConstructorCall") /*~> Unit */
+}
+

compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall_NI.kt.txt

@@ -0,0 +1,49 @@
+fun test3(f1: Function1<String, String>, f2: Function1<Int, String>): D<@FlexibleNullability Int?, @FlexibleNullability String?> {
+  return TODO("IrConstructorCall")
+}
+
+class Outer<T1 : Any?> {
+  constructor(j11: J<T1, T1>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val j11: J<T1, T1>
+    field = j11
+    get
+
+  inner class Inner<T2 : Any?> {
+    constructor(j12: J<T1, T2>) /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    val j12: J<T1, T2>
+      field = j12
+      get
+
+
+
+
+  }
+
+
+
+
+}
+
+fun test4(f: Function1<String, String>, g: Function1<Any, String>): Inner<@FlexibleNullability Any?, @FlexibleNullability String?> {
+  return TODO("IrConstructorCall")
+}
+
+fun testGenericJavaCtor1(f: Function1<String, Int>): G<@FlexibleNullability String?> {
+  return TODO("IrConstructorCall")
+}
+
+fun testGenericJavaCtor2(x: Any) {
+  x as Function1<String, Int> /*~> Unit */
+  TODO("IrConstructorCall") /*~> Unit */
+}
+

compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.kt.txt

@@ -0,0 +1,52 @@
+fun test1(): J<String> {
+  return   local fun <anonymous>(x: @FlexibleNullability String?): @FlexibleNullability String? {
+    return x
+  }
+ /*-> J<String> */
+}
+
+fun test2(): J<@FlexibleNullability String?> {
+  return   local fun <anonymous>(x: String): @FlexibleNullability String? {
+    return x
+  }
+ /*-> J<@FlexibleNullability String?> */
+}
+
+fun test3() {
+  return bar<@FlexibleNullability String?>(j =   local fun <anonymous>(x: String): @FlexibleNullability String? {
+    return x
+  }
+ /*-> @FlexibleNullability J<@FlexibleNullability String?>? */)
+}
+
+fun test4(a: Any) {
+  a as J<String> /*~> Unit */
+  bar<@FlexibleNullability String?>(j = a /*as J<@FlexibleNullability String?> */)
+}
+
+fun test5(a: Any) {
+  a as Function1<String, String> /*~> Unit */
+  bar<@FlexibleNullability String?>(j = a /*as Function1<@ParameterName(...) @FlexibleNullability String?, @FlexibleNullability String?> */ /*-> @FlexibleNullability J<@FlexibleNullability String?>? */)
+}
+
+fun <T : Any?> test6(a: Function1<T, T>) {
+  bar<T?>(j = a /*-> @FlexibleNullability J<T?>? */)
+}
+
+fun <T : Any?> test7(a: Any) {
+  a as Function1<T, T> /*~> Unit */
+  bar<T?>(j = a /*as Function1<@ParameterName(...) T?, T?> */ /*-> @FlexibleNullability J<T?>? */)
+}
+
+fun test8(efn: @ExtensionFunctionType Function1<String, String>): J<@FlexibleNullability String?> {
+  return efn /*-> J<@FlexibleNullability String?> */
+}
+
+fun test9(efn: @ExtensionFunctionType Function1<String, String>) {
+  bar<@FlexibleNullability String?>(j = efn /*-> @FlexibleNullability J<@FlexibleNullability String?>? */)
+}
+
+fun test10(fn: Function1<Int, String>) {
+  bar2x<@FlexibleNullability Int?>(j2x = fn /*-> @FlexibleNullability J2X<@FlexibleNullability Int?>? */)
+}
+

compiler/testData/ir/irText/expressions/sam/samConversions.kt.txt

@@ -0,0 +1,30 @@
+fun J.test0(a: Runnable) {
+  runStatic(r = a)
+  <this>.runIt(r = a)
+}
+
+fun test1() {
+  runStatic(r =   local fun <anonymous>() {
+    test1()
+  }
+ /*-> @FlexibleNullability Runnable? */)
+}
+
+fun J.test2() {
+  <this>.runIt(r =   local fun <anonymous>() {
+    test1()
+  }
+ /*-> @FlexibleNullability Runnable? */)
+}
+
+fun J.test3(a: Function0<Unit>) {
+  <this>.run2(r1 = a /*-> @FlexibleNullability Runnable? */, r2 = a /*-> @FlexibleNullability Runnable? */)
+}
+
+fun J.test4(a: Function0<Unit>, b: Function0<Unit>, flag: Boolean) {
+  <this>.runIt(r = when {
+    flag -> a
+    true -> b
+  } /*-> @FlexibleNullability Runnable? */)
+}
+

compiler/testData/ir/irText/expressions/sam/samConversionsWithSmartCasts.kt.txt

@@ -0,0 +1,67 @@
+fun test1(a: Function0<Unit>) {
+  when {
+    a is Runnable -> { //BLOCK
+      runStatic(r = a /*as Runnable */)
+    }
+  }
+}
+
+fun test2(a: Function0<Unit>) {
+  when {
+    a is Runnable -> { //BLOCK
+      TODO("IrConstructorCall").run1(r = a /*as Runnable */)
+    }
+  }
+}
+
+fun test3(a: Function0<Unit>) {
+  when {
+    a is Runnable -> { //BLOCK
+      TODO("IrConstructorCall").run2(r1 = a /*as Runnable */, r2 = a /*as Runnable */)
+    }
+  }
+}
+
+fun test4(a: Function0<Unit>, b: Function0<Unit>) {
+  when {
+    a is Runnable -> { //BLOCK
+      TODO("IrConstructorCall").run2(r1 = a /*-> @FlexibleNullability Runnable? */, r2 = b /*-> @FlexibleNullability Runnable? */)
+    }
+  }
+}
+
+fun test5(a: Any) {
+  when {
+    a is Runnable -> { //BLOCK
+      TODO("IrConstructorCall").run1(r = a /*as Runnable */)
+    }
+  }
+}
+
+fun test5x(a: Any) {
+  when {
+    a is Runnable -> { //BLOCK
+      a as Function0<Unit> /*~> Unit */
+      TODO("IrConstructorCall").run1(r = a /*as Runnable */)
+    }
+  }
+}
+
+fun test6(a: Any) {
+  a as Function0<Unit> /*~> Unit */
+  TODO("IrConstructorCall").run1(r = a /*as Function0<Unit> */ /*-> @FlexibleNullability Runnable? */)
+}
+
+fun test7(a: Function1<Int, Int>) {
+  a as Function0<Unit> /*~> Unit */
+  TODO("IrConstructorCall").run1(r = a /*as Function0<Unit> */ /*-> @FlexibleNullability Runnable? */)
+}
+
+fun test8(a: Function0<Unit>) {
+  TODO("IrConstructorCall").run1(r = id<@FlexibleNullability Function0<Unit>?>(x = a) /*!! Function0<Unit> */ /*-> @FlexibleNullability Runnable? */)
+}
+
+fun test9() {
+  TODO("IrConstructorCall").run1(r = ::test9 /*-> @FlexibleNullability Runnable? */)
+}
+

compiler/testData/ir/irText/expressions/sam/samOperators.kt.txt

@@ -0,0 +1,18 @@
+fun f() {
+}
+
+fun J.test1() {
+  <this>.get(k = ::f /*-> @FlexibleNullability Runnable? */)
+  <this>.get(k = ::f /*-> @FlexibleNullability Runnable? */, m = ::f /*-> @FlexibleNullability Runnable? */)
+}
+
+fun J.test2() {
+  <this>.set(k = ::f /*-> @FlexibleNullability Runnable? */, v = ::f /*-> @FlexibleNullability Runnable? */)
+  <this>.set(k = ::f /*-> @FlexibleNullability Runnable? */, m = ::f /*-> @FlexibleNullability Runnable? */, v = ::f /*-> @FlexibleNullability Runnable? */)
+}
+
+fun J.test3() {
+  <this>.plusAssign(i = ::f /*-> @FlexibleNullability Runnable? */)
+  <this>.minusAssign(i = ::f /*-> @FlexibleNullability Runnable? */)
+}
+