[IR] add testdata for dumpKotlinLike

compiler/testData/ir/irText/declarations/parameters/class.kt.txt

@@ -0,0 +1,48 @@
+interface TestInterface<T : Any?> {
+  interface TestNestedInterface<TT : Any?> {
+
+
+
+  }
+
+
+
+
+}
+
+class Test<T0 : Any?> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  class TestNested<T1 : Any?> {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+  inner class TestInner<T2 : Any?> {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/constructor.kt.txt

@@ -0,0 +1,96 @@
+class Test1<T1 : Any?, T2 : Any?> {
+  constructor(x: T1, y: T2) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: T1
+    field = x
+    get
+
+  val y: T2
+    field = y
+    get
+
+
+
+
+}
+
+class Test2 {
+  constructor(x: Int, y: String) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val y: String
+    field = y
+    get
+
+  inner class TestInner<Z : Any?> {
+    constructor(z: Z) /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    val z: Z
+      field = z
+      get
+
+    constructor(z: Z, i: Int) {
+      TODO("IrDelegatingConstructorCall")
+    }
+
+
+
+
+  }
+
+
+
+
+}
+
+class Test3 {
+  constructor(x: Int, y: String = "") /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: String
+    field = y
+    get
+
+
+
+
+}
+
+class Test4<T : Any?> {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  constructor(x: Int, y: Int = 42) {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/dataClassMembers.kt.txt

@@ -0,0 +1,63 @@
+data class Test<T : Any?> {
+  constructor(x: T, y: String = "") /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  val y: String
+    field = y
+    get
+
+  operator fun component1(): T {
+    return #x
+  }
+
+  operator fun component2(): String {
+    return #y
+  }
+
+  fun copy(x: T = #x, y: String = #y): Test<T> {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test(" + 
+"x=" + 
+#x + 
+", " + 
+"y=" + 
+#y + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = #x, arg1 = null) -> 0
+      true -> #x.hashCode()
+    }.times(other = 31).plus(other = #y.hashCode())
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test<T> -> return false
+    }
+    val tmp0_other_with_cast: Test<T> = other as Test<T>
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #y, arg1 = #y).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/declarations/parameters/defaultPropertyAccessors.kt.txt

@@ -0,0 +1,51 @@
+val test1: Int
+  field = 42
+  get
+
+var test2: Int
+  field = 42
+  get
+  set
+
+class Host {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val testMember1: Int
+    field = 42
+    get
+
+  var testMember2: Int
+    field = 42
+    get
+    set
+
+
+
+
+}
+
+class InPrimaryCtor<T : Any?> {
+  constructor(testInPrimaryCtor1: T, testInPrimaryCtor2: Int = 42) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val testInPrimaryCtor1: T
+    field = testInPrimaryCtor1
+    get
+
+  var testInPrimaryCtor2: Int
+    field = testInPrimaryCtor2
+    get
+    set
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/delegatedMembers.kt.txt

@@ -0,0 +1,37 @@
+interface IBase<T : Any?> {
+  abstract fun foo(x: Int) 
+  abstract val bar: Int
+    abstract get
+
+  abstract fun <X : Any?> qux(t: T, x: X) 
+
+
+
+}
+
+class Test<TT : Any?> : IBase<TT> {
+  constructor(impl: IBase<TT>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: IBase<TT> = impl
+  override fun <X : Any?> qux(t: TT, x: X) {
+    #$$delegate_0.qux<X>(t = t, x = x)
+  }
+
+  override fun foo(x: Int) {
+    #$$delegate_0.foo(x = x)
+  }
+
+  override val bar: Int
+    override get(): Int {
+      return #$$delegate_0.<get-bar>()
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/fun.kt.txt

@@ -0,0 +1,30 @@
+fun <T : Any?> test1(i: Int, j: T) {
+}
+
+fun test2(i: Int = 0, j: String = "") {
+}
+
+fun test3(vararg args: String) {
+}
+
+fun String.textExt1(i: Int, j: String) {
+}
+
+class Host {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun String.testMembetExt1(i: Int, j: String) {
+  }
+
+  fun <T : Any?> String.testMembetExt2(i: Int, j: T) {
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/genericInnerClass.kt.txt

@@ -0,0 +1,27 @@
+class Outer<T1 : Any?> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  inner class Inner<T2 : Any?> {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    fun foo(x1: T1, x2: T2) {
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/lambdas.kt.txt

@@ -0,0 +1,27 @@
+val test1: Function1<String, String>
+  field =   local fun <anonymous>(it: String): String {
+    return it
+  }
+
+  get
+
+val test2: @ExtensionFunctionType Function2<Any, Any, Any>
+  field =   local fun Any.<anonymous>(it: Any): Int {
+    return it.hashCode()
+  }
+
+  get
+
+val test3: Function2<Int, Int, Unit>
+  field =   local fun <anonymous>(i: Int, j: Int) {
+    return Unit
+  }
+
+  get
+
+val test4: Function2<Int, Int, Unit>
+  field =   local fun <no name provided>(i: Int, j: Int) {
+  }
+
+  get
+

compiler/testData/ir/irText/declarations/parameters/localFun.kt.txt

@@ -0,0 +1,19 @@
+fun <TT : Any?> outer() {
+  local fun <T : Any?> test1(i: Int, j: T) {
+  }
+
+
+  local fun test2(i: Int = 0, j: String = "") {
+  }
+
+
+  local fun test3(vararg args: String) {
+  }
+
+
+  local fun String.textExt1(i: Int, j: TT) {
+  }
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/propertyAccessors.kt.txt

@@ -0,0 +1,84 @@
+val test1: Int
+  get(): Int {
+    return 42
+  }
+
+var test2: Int
+  get(): Int {
+    return 42
+  }
+  set(value: Int) {
+  }
+
+val String.testExt1: Int
+  get(): Int {
+    return 42
+  }
+
+var String.testExt2: Int
+  get(): Int {
+    return 42
+  }
+  set(value: Int) {
+  }
+
+val <T : Any?> T.testExt3: Int
+  get(): Int {
+    return 42
+  }
+
+var <T : Any?> T.testExt4: Int
+  get(): Int {
+    return 42
+  }
+  set(value: Int) {
+  }
+
+class Host<T : Any?> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val testMem1: Int
+    get(): Int {
+      return 42
+    }
+
+  var testMem2: Int
+    get(): Int {
+      return 42
+    }
+    set(value: Int) {
+    }
+
+  val String.testMemExt1: Int
+    get(): Int {
+      return 42
+    }
+
+  var String.testMemExt2: Int
+    get(): Int {
+      return 42
+    }
+    set(value: Int) {
+    }
+
+  val <TT : Any?> TT.testMemExt3: Int
+    get(): Int {
+      return 42
+    }
+
+  var <TT : Any?> TT.testMemExt4: Int
+    get(): Int {
+      return 42
+    }
+    set(value: Int) {
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/typeParameterBeforeBound.kt.txt

@@ -0,0 +1,21 @@
+class Test1<T : U, U : Any?> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+fun <T : U, U : Any?> test2() {
+}
+
+var <T : U, U : Any?> Test1<T, U>.test3: Unit
+  get() {
+  }
+  set(value: Unit) {
+  }
+

compiler/testData/ir/irText/declarations/parameters/typeParameterBoundedBySubclass.kt.txt

@@ -0,0 +1,52 @@
+abstract class Base1<T : Derived1> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class Derived1 : Base1<Derived1> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+abstract class Base2 {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun <T : Derived2> foo(x: T) {
+  }
+
+
+
+
+}
+
+class Derived2 : Base2 {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/useNextParamInLambda.kt.txt

@@ -0,0 +1,28 @@
+fun f(f1: Function0<String> = local fun <anonymous>(): String {
+  return f2.invoke()
+}
+, f2: Function0<String> = local fun <anonymous>(): String {
+  return "FAIL"
+}
+): String {
+  return f1.invoke()
+}
+
+fun box(): String {
+  var result: String = "fail"
+  try { //BLOCK
+    f() /*~> Unit */
+  }
+  catch (...) { //BLOCK
+    result = "OK"
+  }
+
+  return f(, f2 =   local fun <anonymous>(): String {
+    return "O"
+  }
+).plus(other = f(f1 =   local fun <anonymous>(): String {
+    return "K"
+  }
+))
+}
+