Introduce initial version of FIR Java type enhancement

Java type enhancement is performed by a special scope kind
Java FIR dump was added for multiplatform tests to look at enhancements
Overrides, J2K mapping, special cases does not work yet

Related to KT-29937

idea/testData/fir/multiModule/basicWithAnnotatedJava/extraDump.java.txt

@@ -0,0 +1,4 @@
+public open class Annotated : R|java/lang/Object| {
+    @R|org/jetbrains/annotations/NotNull|() public open operator function foo(@R|org/jetbrains/annotations/Nullable|() param: R|ft<java/lang/String?, java/lang/String?>|?): R|ft<java/lang/String, java/lang/String>|
+
+}

idea/testData/fir/multiModule/basicWithAnnotatedJava/jvm/Annotated.java

@@ -0,0 +1,10 @@
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class Annotated {
+    @NotNull
+    public String foo(@Nullable String param) {
+        if (param != null) return param;
+        else return "";
+    }
+}

idea/testData/fir/multiModule/basicWithAnnotatedJava/jvm/jvm.kt

@@ -0,0 +1,6 @@
+class User : Annotated() {
+    fun test() {
+        val x = foo("123")
+        val y = foo(null)
+    }
+}

idea/testData/fir/multiModule/basicWithAnnotatedJava/jvm/jvm.txt

@@ -0,0 +1,10 @@
+FILE: jvm.kt
+    public final class User : R|Annotated| {
+        public constructor(): super<R|Annotated|>()
+
+        public final function test(): R|kotlin/Unit| {
+            val x: R|error: Not supported: FirImplicitTypeRefImpl| = R|/Annotated.foo|(String(123))
+            val y: R|error: Not supported: FirImplicitTypeRefImpl| = R|/Annotated.foo|(Null(null))
+        }
+
+    }

idea/testData/fir/multiModule/basicWithAnnotatedOverriddenJava/extraDump.java.txt

@@ -0,0 +1,8 @@
+public open class Annotated : R|java/lang/Object| {
+    @R|org/jetbrains/annotations/NotNull|() public open operator function foo(@R|org/jetbrains/annotations/Nullable|() param: R|ft<java/lang/String?, java/lang/String?>|?): R|ft<java/lang/String, java/lang/String>|
+
+}
+public open class AnnotatedDerived : R|Annotated| {
+    public open operator function foo(param: R|ft<java/lang/String?, java/lang/String?>|?): R|ft<java/lang/String, java/lang/String>|
+
+}

idea/testData/fir/multiModule/basicWithAnnotatedOverriddenJava/jvm/Annotated.java

@@ -0,0 +1,10 @@
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class Annotated {
+    @NotNull
+    public String foo(@Nullable String param) {
+        if (param != null) return param;
+        else return "";
+    }
+}

idea/testData/fir/multiModule/basicWithAnnotatedOverriddenJava/jvm/AnnotatedDerived.java

@@ -0,0 +1,5 @@
+public class AnnotatedDerived extends Annotated {
+    public String foo(String param) {
+        return super.foo(param);
+    }
+}

idea/testData/fir/multiModule/basicWithAnnotatedOverriddenJava/jvm/jvm.kt

@@ -0,0 +1,6 @@
+class User : AnnotatedDerived() {
+    fun test() {
+        val x = foo("123")
+        val y = foo(null)
+    }
+}

idea/testData/fir/multiModule/basicWithAnnotatedOverriddenJava/jvm/jvm.txt

@@ -0,0 +1,10 @@
+FILE: jvm.kt
+    public final class User : R|AnnotatedDerived| {
+        public constructor(): super<R|AnnotatedDerived|>()
+
+        public final function test(): R|kotlin/Unit| {
+            val x: R|error: Not supported: FirImplicitTypeRefImpl| = <Ambiguity: foo, [/AnnotatedDerived.foo, /Annotated.foo]>#(String(123))
+            val y: R|error: Not supported: FirImplicitTypeRefImpl| = <Ambiguity: foo, [/AnnotatedDerived.foo, /Annotated.foo]>#(Null(null))
+        }
+
+    }

idea/testData/fir/multiModule/basicWithJava/extraDump.java.txt

@@ -0,0 +1,2 @@
+public open class Some : R|java/lang/Object| {
+}

idea/testData/fir/multiModule/basicWithJavaFakeOverride/extraDump.java.txt

@@ -0,0 +1,4 @@
+<T> public open class A : R|java/lang/Object| {
+    public open operator function foo(t: R|ft<T, T?>|!): R|ft<T, T?>|!
+
+}

idea/testData/fir/multiModule/basicWithJavaFakeOverride/jvm/simpleFakeOverride.txt

@@ -7,7 +7,7 @@ FILE: simpleFakeOverride.kt
         public constructor(): super<R|A<Some>|>()
 
         public final function test(): R|kotlin/Unit| {
-            R|FakeOverride</A.foo: R|ft<T, T>|!>|(<Unresolved name: Some>#())
+            R|FakeOverride</A.foo: R|ft<T, T?>|!>|(<Unresolved name: Some>#())
         }
 
     }

idea/testData/fir/multiModule/basicWithPrimitiveJava/extraDump.java.txt

@@ -0,0 +1,6 @@
+public open class Some : R|java/lang/Object| {
+    public open operator function foo(param: R|kotlin/Int|): R|kotlin/Boolean|
+
+    public open operator function bar(arr: R|kotlin/IntArray|): R|kotlin/Array<ft<java/lang/String, java/lang/String?>>|
+
+}

idea/testData/fir/multiModule/basicWithPrimitiveJava/jvm/Some.java

@@ -0,0 +1,14 @@
+public class Some {
+    public boolean foo(int param) {
+        return param > 0;
+    }
+
+    public String[] bar(int[] arr) {
+        String[] result = new String[arr.length];
+        int i = 0;
+        for (int elem: arr) {
+            result[i++] = elem;
+        }
+        return result;
+    }
+}

idea/testData/fir/multiModule/basicWithPrimitiveJava/jvm/jvm.kt

@@ -0,0 +1,7 @@
+class A : Some() {
+    fun test() {
+        val res1 = foo(1)
+        val res2 = foo(-1)
+        val res3 = bar(intArrayOf(0, 2, -2))
+    }
+}

idea/testData/fir/multiModule/basicWithPrimitiveJava/jvm/jvm.txt

@@ -0,0 +1,11 @@
+FILE: jvm.kt
+    public final class A : R|Some| {
+        public constructor(): super<R|Some|>()
+
+        public final function test(): R|kotlin/Unit| {
+            val res1: R|error: Not supported: FirImplicitTypeRefImpl| = R|/Some.foo|(Int(1))
+            val res2: R|error: Not supported: FirImplicitTypeRefImpl| = R|/Some.foo|(<Unresolved name: unaryMinus>#(Int(1)))
+            val res3: R|error: Not supported: FirImplicitTypeRefImpl| = R|/Some.bar|(<Unresolved name: intArrayOf>#(Int(0), Int(2), <Unresolved name: unaryMinus>#(Int(2))))
+        }
+
+    }

idea/testData/fir/multiModule/overrideWithJava/extraDump.java.txt

@@ -0,0 +1,6 @@
+public open class A : R|java/lang/Object| {
+    public open operator function foo(): R|ft<A, A?>|!
+
+    public open operator function bar(): R|ft<A, A?>|!
+
+}