[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/smartCasts/elvisExprNotNull.kt

@@ -33,5 +33,5 @@ fun baz(s: String?, r: String?): String {
 fun withNull(s: String?): String {
     val t = s <!USELESS_ELVIS_RIGHT_IS_NULL!>?: null<!>
     // Error: nullable
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>t<!>
+    return <!TYPE_MISMATCH!>t<!>
 }

compiler/testData/diagnostics/tests/smartCasts/explicitDefaultGetter.kt

@@ -5,7 +5,7 @@ class ExplicitAccessorForAnnotation {
 
     fun foo(): String {
         if (tt is String) {
-            return <!NI;TYPE_MISMATCH, SMARTCAST_IMPOSSIBLE!>tt<!>
+            return <!SMARTCAST_IMPOSSIBLE!>tt<!>
         }
         return ""
     }

compiler/testData/diagnostics/tests/smartCasts/propertyToNotNull.kt

@@ -8,7 +8,7 @@ class Immutable(val x: String?) {
 
 class Mutable(var y: String?) {
     fun foo(): String {
-        if (y != null) return <!NI;TYPE_MISMATCH, SMARTCAST_IMPOSSIBLE!>y<!>
+        if (y != null) return <!SMARTCAST_IMPOSSIBLE!>y<!>
         return ""
     }
 }

compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.kt

@@ -3,6 +3,6 @@
 fun calc(x: List<String>?, y: Int?): Int {
     x?.get(y!! - 1) 
     // y!! above should not provide smart cast here
-    val yy: Int = <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    val yy: Int = <!TYPE_MISMATCH!>y<!>
     return  yy + (x?.size ?: 0)
 }

compiler/testData/diagnostics/tests/smartCasts/safecalls/falseSecondArgument.kt

@@ -3,5 +3,5 @@
 fun calc(x: List<String>?, y: Int?): Int {
     x?.subList(y!! - 1, <!DEBUG_INFO_SMARTCAST!>y<!>)
     // y!! above should not provide smart cast here
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    return <!TYPE_MISMATCH!>y<!>
 }

compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChainFalse.kt

@@ -6,5 +6,5 @@ fun calc(x: String?, y: Int?): Int {
     // Smart cast because of x!! in receiver
     foo(x!!)?.subSequence(y!!, <!DEBUG_INFO_SMARTCAST!>x<!>.length)?.length
     // No smart cast possible
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>y<!>
+    return <!TYPE_MISMATCH!>y<!>
 }

compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.kt

@@ -13,5 +13,5 @@ fun list(start: SomeObject): SomeObject {
         e = e<!UNSAFE_CALL!>.<!>next()
     }
     // Smart cast is not possible here due to next()
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }

compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.kt

@@ -14,5 +14,5 @@ fun list(start: SomeObject): SomeObject {
         <!DEBUG_INFO_SMARTCAST!>e<!>.doSomething()
         e = <!DEBUG_INFO_SMARTCAST!>e<!>.next()
     }
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }

compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.kt

@@ -14,5 +14,5 @@ fun list(start: SomeObject): SomeObject {
         <!DEBUG_INFO_SMARTCAST!>e<!>.doSomething()
         e = <!DEBUG_INFO_SMARTCAST!>e<!>.next()
     }
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>e<!>
+    return <!TYPE_MISMATCH!>e<!>
 }

compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt

@@ -2,5 +2,5 @@
 fun foo(): Int {
     var i: Int? = <!VARIABLE_WITH_REDUNDANT_INITIALIZER!>42<!>
     i = null
-    return <!NI;TYPE_MISMATCH, TYPE_MISMATCH!><!OI;DEBUG_INFO_CONSTANT!>i<!> + 1<!>
+    return <!TYPE_MISMATCH!><!OI;DEBUG_INFO_CONSTANT!>i<!> + 1<!>
 }