FIR: Refine inference constraints when type variable in flexible position

That issue might be fixed via changing
TypeVariableMarker.shouldBeFlexible at ConeConstraintSystemUtilContext
but this and some other tricks have been added because of incorrect
handling of constraints where type variable has a flexible bound

^KT-51168 Fixed

compiler/testData/diagnostics/testsWithStdLib/java/assertThatOnMap.kt

@@ -0,0 +1,36 @@
+// FIR_IDENTICAL
+// SKIP_TXT
+// FILE: AbstractMapAssert.java
+
+import java.util.Map;
+
+public abstract class AbstractMapAssert<SELF extends AbstractMapAssert<SELF, ACTUAL, K, V>, ACTUAL extends Map<K, V>, K, V> {
+    public SELF isNotNull() {
+        return (SELF) this;
+    }
+}
+
+// FILE: MapAssert.java
+
+import java.util.Map;
+
+public class MapAssert<KEY, VALUE> extends AbstractMapAssert<MapAssert<KEY, VALUE>, Map<KEY, VALUE>, KEY, VALUE> {
+
+    public MapAssert(Map<KEY, VALUE> actual) {}
+}
+
+// FILE: Assertions.java
+
+import java.util.Map;
+
+public class Assertions {
+    public static <K, V> MapAssert<K, V> assertThat(Map<K, V> actual) {
+        return new MapAssert<>(actual);
+    }
+}
+
+// FILE: test.kt
+
+fun <S : Map<*,*>> S?.must() {
+    Assertions.assertThat(this).isNotNull
+}

compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.fir.kt

@@ -5,18 +5,18 @@ fun bar(): String? = null
 
 fun foo() {
     var x = ArrayList<String>()
-    x.add(null)
-    x.add(bar())
+    x.add(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.add(<!ARGUMENT_TYPE_MISMATCH!>bar()<!>)
     x.add("")
 
-    x[0] = null
-    x[0] = bar()
+    x[0] = <!NULL_FOR_NONNULL_TYPE!>null<!>
+    x[0] = <!ARGUMENT_TYPE_MISMATCH!>bar()<!>
     x[0] = ""
 
-    val b1: MutableList<String?> = x
+    val b1: MutableList<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
     val b2: MutableList<String> = x
     val b3: List<String?> = x
 
     val b4: Collection<String?> = x
-    val b6: MutableCollection<String?> = x
-}
+    val b6: MutableCollection<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
+}

compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.fir.kt

@@ -14,7 +14,7 @@ fun foo() {
     x[0] = ""
 
     val b1: MutableList<String?> = x
-    val b2: MutableList<String> = x
+    val b2: MutableList<String> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
     val b3: List<String?> = x
 
     val b4: Collection<String?> = x

compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.fir.kt

@@ -28,5 +28,5 @@ fun foo() {
     x.add("")
 
     val b1: Collection<String?> = x
-    val b2: MutableCollection<String?> = x
+    val b2: MutableCollection<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
 }

compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.fir.kt

@@ -31,10 +31,10 @@ fun foo() {
     x[0] = bar()
     x[0] = ""
 
-    val b1: MutableList<String?> = x
+    val b1: MutableList<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
     val b2: MutableList<String> = x
     val b3: List<String?> = x
 
     val b4: Collection<String?> = x
-    val b6: MutableCollection<String?> = x
+    val b6: MutableCollection<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
 }

compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.fir.kt

@@ -7,30 +7,30 @@ fun bar(): String? = null
 
 fun fooHashSet() {
     var x = HashSet<String>()
-    x.add(null)
-    x.add(bar())
+    x.add(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.add(<!ARGUMENT_TYPE_MISMATCH!>bar()<!>)
     x.add("")
 
-    val b1: MutableSet<String?> = x
+    val b1: MutableSet<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
     val b2: MutableSet<String> = x
     val b3: Set<String?> = x
 
     val b4: Collection<String?> = x
-    val b6: MutableCollection<String?> = x
+    val b6: MutableCollection<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
 }
 
 fun fooTreeSet() {
     var x = TreeSet<String>()
-    x.add(null)
-    x.add(bar())
+    x.add(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    x.add(<!ARGUMENT_TYPE_MISMATCH!>bar()<!>)
     x.add("")
 
-    val b1: MutableSet<String?> = x
+    val b1: MutableSet<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
     val b2: MutableSet<String> = x
     val b3: Set<String?> = x
 
     val b4: Collection<String?> = x
-    val b6: MutableCollection<String?> = x
+    val b6: MutableCollection<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
 }
 
 fun fooLinkedHashSet() {
@@ -39,10 +39,10 @@ fun fooLinkedHashSet() {
     x.add(bar())
     x.add("")
 
-    val b1: MutableSet<String?> = x
+    val b1: MutableSet<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
     val b2: MutableSet<String> = x
     val b3: Set<String?> = x
 
     val b4: Collection<String?> = x
-    val b6: MutableCollection<String?> = x
+    val b6: MutableCollection<String?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
 }