[Test] KT-61360: add tests for the IrFakeOverrideBuilder

Add tests for fake overrides with focus on java interoperability

Co-authored-by: Aleksandra Arsenteva <aleksandra.arsenteva@jetbrains.com>

compiler/testData/ir/irText/fakeOverrides/generics/intersectionWildcardsOverride.kt

@@ -0,0 +1,197 @@
+// TARGET_BACKEND: JVM
+// FULL_JDK
+// WITH_STDLIB
+// SEPARATE_SIGNATURE_DUMP_FOR_K2
+// ^ ISSUE: KT-66120
+
+// FILE: Java1.java
+import java.util.*;
+public class Java1 {
+    public void foo(List<? extends Number> a) { }
+    public List<? extends Number> bar(){
+        return null;
+    }
+    public void foo2(List<? super Number> a) { }
+    public List<? super Number> bar2(){
+        return null;
+    }
+
+    public void foo3(List<?> a) {}
+    public List<?> bar3(){
+        return null;
+    }
+}
+
+// FILE: Java2.java
+import java.util.List;
+
+public interface Java2  {
+    public List<Integer> bar();
+    public List<Number> bar2();
+    public List<Integer> bar3();
+}
+
+// FILE: Java3.java
+import java.util.List;
+
+public interface Java3  {
+    public List<? extends Object> bar();
+    public void foo3(List<?> a);
+    public List<?> bar3();
+}
+
+// FILE: 1.kt
+class A : Java1(), Java2 {   //Kotlin ← Java1, Java2
+    override fun bar(): MutableList<Int> {
+        return mutableListOf(1)
+    }
+    override fun bar2(): MutableList<Number> {
+        return mutableListOf(1.1)
+    }
+    override fun bar3(): MutableList<Int> {
+        return mutableListOf(1)
+    }
+}
+
+class B : Java1() , KotlinInterface //Kotlin ← Java, Kotlin2
+
+class C : Java1() , KotlinInterface {
+    override fun foo(a: MutableList<out Number>) { }
+    override fun bar(): MutableList<out Number> {
+        return mutableListOf(1)
+    }
+}
+
+class D : Java1(), Java2, KotlinInterface {     //Kotlin ← Java1, Java2, Kotlin2
+    override fun bar(): MutableList<Int> {
+        return mutableListOf(1)
+    }
+    override fun bar2(): MutableList<Number> {
+        return mutableListOf(1.1)
+    }
+    override fun bar3(): MutableList<Int> {
+        return mutableListOf(1)
+    }
+}
+
+class E : Java1(), KotlinInterface, KotlinInterface2   //Kotlin ← Java, Kotlin1, Kotlin2
+
+class F : Java1(), KotlinInterface, KotlinInterface2 {
+    override fun bar2(): MutableList<in Number> {
+        return mutableListOf(1)
+    }
+    override fun foo2(a: MutableList<in Number>) { }
+}
+
+abstract class G : Java1(), Java2, Java3 {  //Kotlin ← Java1, Java2, Java3
+    override fun bar(): MutableList<Int> {
+        return mutableListOf(1)
+    }
+    override fun bar2(): MutableList<Number> {
+        return mutableListOf(1.1)
+    }
+    override fun bar3(): MutableList<Int> {
+        return mutableListOf(1)
+    }
+}
+
+class H : G() {
+    override fun foo(a: MutableList<out Number>) { }
+    override fun foo2(a: MutableList<in Number>) { }
+    override fun foo3(a: MutableList<*>) { }
+}
+
+
+interface KotlinInterface {
+    fun foo(a: MutableList<out Number>)
+    fun bar(): MutableList<out Number>
+
+    fun foo2(a: MutableList<in Number>)
+    fun bar2(): MutableList<in Number>
+
+    fun foo3(a: MutableList<*>)
+    fun bar3(): MutableList<*>
+}
+
+interface KotlinInterface2 {
+    fun foo(a: List<Number>)
+    fun bar(): List<Number>
+}
+
+fun test(a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H){
+    a.foo(null)
+    a.foo(mutableListOf(1))
+    a.foo(listOf(1))
+    a.bar()
+    a.foo2(null)
+    a.foo2(mutableListOf(null))
+    a.foo2(mutableListOf(1.1))
+    a.bar2()
+    a.foo3(null)
+    a.foo3(mutableListOf(null))
+    a.foo3(listOf(null))
+    a.foo3(listOf(""))
+    a.bar3()
+
+    b.foo(null)
+    b.foo(mutableListOf(1))
+    b.bar()
+    b.foo2(null)
+    b.foo2(mutableListOf(null))
+    b.foo2(mutableListOf(1.1))
+    b.bar2()
+    b.foo3(null)
+    b.foo3(mutableListOf(null))
+    b.foo3(mutableListOf(""))
+    b.bar3()
+
+    c.foo(mutableListOf(1))
+    c.bar()
+
+    d.foo(null)
+    d.foo(mutableListOf(1))
+    d.bar()
+    d.foo2(null)
+    d.foo2(mutableListOf(null))
+    d.foo2(mutableListOf(1.1))
+    d.bar2()
+    d.foo3(null)
+    d.foo3(mutableListOf(null))
+    d.foo3(mutableListOf(""))
+    d.bar3()
+
+    e.foo(null)
+    e.foo(mutableListOf(1))
+    e.foo(listOf(1))
+    e.bar()
+    e.foo2(null)
+    e.foo2(mutableListOf(null))
+    e.foo2(mutableListOf(1.1))
+    e.bar2()
+    e.foo3(null)
+    e.foo3(mutableListOf(null))
+    e.foo3(listOf(null))
+    e.foo3(listOf(""))
+    e.bar3()
+
+    f.foo2(mutableListOf(null))
+    f.bar2()
+
+    g.foo(null)
+    g.foo(mutableListOf(1))
+    g.foo(listOf(1))
+    g.bar()
+    g.foo2(null)
+    g.foo2(mutableListOf(null))
+    g.foo2(mutableListOf(1.1))
+    g.bar2()
+    g.foo3(null)
+    g.foo3(mutableListOf(null))
+    g.foo3(listOf(null))
+    g.foo3(listOf(""))
+    g.bar3()
+
+    h.foo(mutableListOf(1))
+    h.foo2(mutableListOf(1))
+    h.foo3(mutableListOf(""))
+}