[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/fieldmodifiers/javaModifiersOverride.kt.txt

@@ -0,0 +1,120 @@
+class A : Java1 {
+  constructor() /* primary */ {
+    super/*Java1*/()
+    /* <init>() */
+
+  }
+
+}
+
+class B : Java2 {
+  constructor() /* primary */ {
+    super/*Java2*/()
+    /* <init>() */
+
+  }
+
+}
+
+class C : Java3 {
+  constructor() /* primary */ {
+    super/*Java3*/()
+    /* <init>() */
+
+  }
+
+}
+
+class D : Java1, Java4 {
+  constructor() /* primary */ {
+    super/*Java1*/()
+    /* <init>() */
+
+  }
+
+}
+
+abstract class E : Java1, KotlinInterface {
+  constructor() /* primary */ {
+    super/*Java1*/()
+    /* <init>() */
+
+  }
+
+}
+
+class F : Java1, KotlinInterface {
+  override val a: Int
+    field = a
+    override get
+
+  override val b: Int
+    field = b
+    override get
+
+  override val c: Int
+    field = c
+    override get
+
+  override val d: Int
+    field = d
+    override get
+
+  constructor(a: Int, b: Int, c: Int, d: Int) /* primary */ {
+    super/*Java1*/()
+    /* <init>() */
+
+  }
+
+}
+
+open class KotlinClass : Java1 {
+  constructor() /* primary */ {
+    super/*Java1*/()
+    /* <init>() */
+
+  }
+
+}
+
+interface KotlinInterface {
+  abstract val a: Int
+    abstract get
+
+  abstract val b: Int
+    abstract get
+
+  abstract val c: Int
+    abstract get
+
+  abstract val d: Int
+    abstract get
+
+}
+
+fun test(a: A, b: B, c: C, d: D, e: E, f: F) {
+  a(super<A>).#a /*~> Unit */
+  a(super<A>).#b /*~> Unit */
+  a(super<A>).#c /*~> Unit */
+  a(super<A>).#d /*~> Unit */
+  b(super<B>).#a /*~> Unit */
+  b(super<B>).#b /*~> Unit */
+  b(super<B>).#c /*~> Unit */
+  b(super<B>).#d /*~> Unit */
+  c(super<C>).#a /*~> Unit */
+  c(super<C>).#b /*~> Unit */
+  c(super<C>).#c /*~> Unit */
+  c(super<C>).#d /*~> Unit */
+  d(super<D>).#a /*~> Unit */
+  d(super<D>).#b /*~> Unit */
+  d(super<D>).#c /*~> Unit */
+  d(super<D>).#d /*~> Unit */
+  e(super<E>).#a /*~> Unit */
+  e(super<E>).#b /*~> Unit */
+  e(super<E>).#c /*~> Unit */
+  e(super<E>).#d /*~> Unit */
+  f(super<F>).#a /*~> Unit */
+  f(super<F>).#b /*~> Unit */
+  f(super<F>).#c /*~> Unit */
+  f(super<F>).#d /*~> Unit */
+}