[NI] Avoid constraints from expected type for effectively empty system

Expression will be checked against expected type later.

 Theoretically, this is not very good, but it aligns with the old
 inference, plus it helps avoiding multiple type mismatch diagnostics.

compiler/testData/diagnostics/tests/generics/capturedParameters/innerLocalClass.kt

@@ -20,7 +20,7 @@ private class Outer<E> {
         private var doubleStringInt = Outer<Double>().Inner<String>().foo<Int>()()
 
         private fun bar() {
-            doubleCharSequenceInt = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>doubleStringNumber<!>
+            doubleCharSequenceInt = <!TYPE_MISMATCH!>doubleStringNumber<!>
             doubleCharSequenceInt = doubleStringInt
 
             doubleStringInt = Outer<Double>().Inner<String>().foo<Int>()()

compiler/testData/diagnostics/tests/generics/capturedParameters/localClass.kt

@@ -15,7 +15,7 @@ class Q {
     private var y = <!DEBUG_INFO_LEAKING_THIS!>foo<!><String>()()
 
     fun bar() {
-        x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        x = <!TYPE_MISMATCH!>y<!>
         x = foo<CharSequence>()()
         y = foo<String>()()
 

compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.kt

@@ -13,7 +13,7 @@ class Q {
     private var y = <!DEBUG_INFO_LEAKING_THIS!>foo<!><String>()
 
     fun bar() {
-        x = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        x = <!TYPE_MISMATCH!>y<!>
         x = foo<CharSequence>()
         y = foo<String>()
 

compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt

@@ -29,7 +29,7 @@ fun <E> commonSupertype(x: E, y: E): E = x
 
 fun foo() {
     var myIt = A<String>().iterator()
-    myIt = <!TYPE_MISMATCH!>A<Int>().<!NI;TYPE_MISMATCH!>iterator()<!><!>
+    myIt = <!TYPE_MISMATCH!>A<Int>().iterator()<!>
 
     val csIt: Iterator<CharSequence> = A<String>().iterator()
 

compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt

@@ -11,7 +11,7 @@ class Outer<T> {
         z.checkType { _<Inner>() }
         z.checkType { _<Outer<T>.Inner>() }
 
-        inner = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        inner = <!TYPE_MISMATCH!>x<!>
     }
 
     class Nested

compiler/testData/diagnostics/tests/generics/nullability/considerTypeNotNullOnlyIfItHasNotNullBound.kt

@@ -1,6 +1,6 @@
 // !LANGUAGE: +NewInference
 
 inline fun <T, reified S> foo(x: T?, y: T): T {
-    if (x is S) return <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+    if (x is S) return <!TYPE_MISMATCH!>x<!>
     return y
 }

compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt

@@ -12,7 +12,7 @@ fun <T : CharSequence?> foo(x: T) {
         if (<!SENSELESS_COMPARISON!>x != null<!>) {}
 
         y1 = <!DEBUG_INFO_SMARTCAST!>x<!>
-        y2 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        y2 = <!TYPE_MISMATCH!>x<!>
 
         <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>bar1<!>(<!NI;DEBUG_INFO_SMARTCAST!>x<!>)
         bar1<CharSequence>(<!DEBUG_INFO_SMARTCAST!>x<!>)
@@ -31,7 +31,7 @@ fun <T : CharSequence?> foo(x: T) {
 
     if (x is CharSequence) {
         y1 = <!DEBUG_INFO_SMARTCAST!>x<!>
-        y2 = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        y2 = <!TYPE_MISMATCH!>x<!>
 
         bar1(<!DEBUG_INFO_SMARTCAST!>x<!>)
         bar2(<!DEBUG_INFO_SMARTCAST!>x<!>)

compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt

@@ -24,10 +24,10 @@ class A<T : CharSequence?, E1 : T, E2: T?> {
         }
 
         if (1 == 1) {
-            t = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>tN<!>
+            t = <!TYPE_MISMATCH!>tN<!>
         }
 
-        t = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+        t = <!TYPE_MISMATCH!>y<!>
 
         if (y != null) {
             t = <!DEBUG_INFO_SMARTCAST!>y<!>

compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.kt

@@ -9,7 +9,7 @@ fun main() {
     val a : ArrayList<ArrayList<String>> = ArrayList()
     val b : ListOfLists<String> = ListOfLists(a)
     val c : ListOfLists<*> = b
-    val d : ArrayList<ArrayList<*>> = <!TYPE_MISMATCH!>c.<!NI;TYPE_MISMATCH!>x<!><!>
+    val d : ArrayList<ArrayList<*>> = <!TYPE_MISMATCH!>c.x<!>
 
     c.x checkType { _<ArrayList<out ArrayList<*>>>() }
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt

@@ -18,7 +18,7 @@ fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
     }
     a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>Out<CharSequence>()<!> }
     a.bar { <!NI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER, OI;IMPLICIT_NOTHING_AS_TYPE_PARAMETER!>Out<!>() }
-    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.<!NI;TYPE_MISMATCH!>id()<!><!> }
+    a.bar { <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>z.id()<!> }
 
     a.foo {
         z.foobar(if (1 > 2) return@foo <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>""<!> else "")

compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt

@@ -5,6 +5,6 @@ interface Tr<T> {
 }
 
 fun test(t: Tr<*>) {
-    <!SETTER_PROJECTED_OUT!>t.v<!> = <!NI;TYPE_MISMATCH!>t<!>
+    <!SETTER_PROJECTED_OUT!>t.v<!> = t
     t.v checkType { _<Tr<*>>() }
 }