K2: Imitate K1 behavior for case of captured types with a raw supertype

See the comments in the code, but mostly the motivation is that once
it was decided to stick with such a legacy thing as raw types,
we are ok with some corner-cases hacks for them
(if there are not too many of them) and they don't break anything
when there are no raw types in the code.

^KT-56616 Fixed

compiler/testData/diagnostics/tests/j+k/rawTypesFromCaptured.fir.kt

@@ -0,0 +1,25 @@
+// ISSUE: KT-56616
+
+// FILE: StubElement.java
+
+public interface StubElement<T> {
+    <E> E bar(E v);
+}
+
+// FILE: StubBasedPsiElement.java
+
+public interface StubBasedPsiElement<T extends StubElement> {
+    T foo1();
+
+    StubElement foo2();
+}
+
+// FILE: test.kt
+
+fun StubBasedPsiElement<*>.foo(): String? {
+    if ("".hashCode() == 0) {
+        return foo1().bar("")
+    }
+
+    return <!RETURN_TYPE_MISMATCH!>foo2().bar("")<!>
+}

compiler/testData/diagnostics/tests/j+k/rawTypesFromCaptured.kt

@@ -0,0 +1,25 @@
+// ISSUE: KT-56616
+
+// FILE: StubElement.java
+
+public interface StubElement<T> {
+    <E> E bar(E v);
+}
+
+// FILE: StubBasedPsiElement.java
+
+public interface StubBasedPsiElement<T extends StubElement> {
+    T foo1();
+
+    StubElement foo2();
+}
+
+// FILE: test.kt
+
+fun StubBasedPsiElement<*>.foo(): String? {
+    if ("".hashCode() == 0) {
+        return foo1().bar("")
+    }
+
+    return <!TYPE_MISMATCH!>foo2().<!TYPE_MISMATCH!>bar("")<!><!>
+}

compiler/testData/diagnostics/tests/j+k/rawTypesFromCapturedOriginal.kt

@@ -0,0 +1,37 @@
+// FIR_IDENTICAL
+// WITH_STDLIB
+// ISSUE: KT-56616
+
+// FILE: StubElement.java
+
+import org.jetbrains.annotations.NotNull;
+
+public interface StubElement<T extends PsiElement> {
+    <E extends PsiElement> E @NotNull [] getChildrenByType(@NotNull String filter, final E[] array);
+}
+
+// FILE: PsiElement.java
+
+public interface PsiElement
+
+// FILE: StubBasedPsiElement.java
+
+public interface StubBasedPsiElement<Stub extends StubElement> extends PsiElement {
+    Stub getStub();
+}
+
+// FILE: test.kt
+
+private val STRING_TEMPLATE_EMPTY_ARRAY = emptyArray<KtStringTemplateExpression>()
+
+open class KtStringTemplateExpression : PsiElement
+
+fun StubBasedPsiElement<*>.foo(): KtStringTemplateExpression? {
+    stub?.let {
+        // K1: Array<KtStringTemplateExpression>, was K2: Array<PsiElement>
+        val expressions = it.getChildrenByType("", STRING_TEMPLATE_EMPTY_ARRAY)
+        // Ok in K1, Should not be error in K2
+        return expressions.firstOrNull()
+    }
+    return null
+}

compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.fir.kt

@@ -1,42 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_VARIABLE
-// FILE: A.java
-
-import java.util.List;
-
-public class A<T> {
-    List<String> getChildrenStubs() { return null; }
-    void consume(T x) {}
-
-    T produce() { return null; }
-}
-
-// FILE: B.java
-
-public class B<E extends A> {
-    public E foo() { return null;}
-    E field;
-}
-
-// FILE: Test.java
-
-public class Test {
-    static B rawB = null;
-}
-
-// FILE: main.kt
-
-fun foo(x: B<*>) {
-    // TODO: In K1, x.foo() now is flexible type instead of raw, because of captured type approximation
-    // Works in K2 as expected: x.foo() returns raw `A`, thus it's `getChildrenStubs` has a type `MutableList<Any!>..List<*>?`
-    val q: MutableList<String> = <!INITIALIZER_TYPE_MISMATCH, TYPE_MISMATCH!>x.foo().getChildrenStubs()<!>
-
-    // Raw(B).field erased to A<Any!>..A<out Any!>?
-    Test.rawB.field = A<String>()
-    val anyA: A<Any> = Test.rawB.field
-
-    // FIR doesn't work here, because
-    // field has a type of just 'A' and it's not clear why should it accept 'String' at consume
-    // NB: some kind of BareTypeScope should be in use here
-    Test.rawB.field.consume("")
-    val y: Any = Test.rawB.field.produce()
-}

compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 // FILE: A.java
 
@@ -26,8 +27,7 @@ public class Test {
 // FILE: main.kt
 
 fun foo(x: B<*>) {
-    // TODO: In K1, x.foo() now is flexible type instead of raw, because of captured type approximation
-    // Works in K2 as expected: x.foo() returns raw `A`, thus it's `getChildrenStubs` has a type `MutableList<Any!>..List<*>?`
+    // x.foo()  is flexible type instead of raw, because of captured type approximation
     val q: MutableList<String> = x.foo().getChildrenStubs()
 
     // Raw(B).field erased to A<Any!>..A<out Any!>?