[FE 1.0] Fix some diagnostic tests

compiler/testData/diagnostics/tests/Bounds.kt

@@ -6,7 +6,7 @@ package boundsWithSubstitutors
     class C : A<C>()
 
     val a = B<C>()
-    val a1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
+    val a1 = B<<!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Int<!>>()
 
     class X<A, B : A>()
 

compiler/testData/diagnostics/tests/generics/kt9985.kt

@@ -27,15 +27,15 @@ fun foo(l: A<String>?) {
     foo(l?.bar()) checkType { _<String?>() }
     foo(l?.gav()) checkType { _<String?>() }
     if (l != null) {
-        foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>bar()) checkType { _<String>() }
+        foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>bar()) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
-        foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>gav()) checkType { _<String>() }
+        foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>gav()) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
     }
 }
 
 fun fooNotNull(l: A<String>) {
     // No errors should be here
-    foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>bar()) checkType { _<String>() }
+    foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>bar()) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
-    foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>gav()) checkType { _<String>() }
+    foo(l<!UNNECESSARY_SAFE_CALL!>?.<!>gav()) checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
 }
 
 fun bar() {

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

@@ -20,7 +20,7 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
 
     a.foo2(Inv())
     a.foo2(<!TYPE_MISMATCH!>Inv<CharSequence>()<!>)
-    a.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!TYPE_MISMATCH!>Inv()<!>)
+    a.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Inv()<!>)
 
     a.foo3(In())
     a.foo3(In<CharSequence>())
@@ -32,7 +32,7 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
 
     b.foo2(Inv())
     b.foo2(<!TYPE_MISMATCH!>Inv<CharSequence>()<!>)
-    b.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!TYPE_MISMATCH!>Inv()<!>)
+    b.foo2<<!UPPER_BOUND_VIOLATED!>Inv<CharSequence><!>>(<!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>Inv()<!>)
 
 
     b.foo3(<!TYPE_MISMATCH!>In<CharSequence>()<!>)

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt

@@ -39,7 +39,7 @@ fun <R> select(vararg x: R) = x[0]
 fun poll0(): Flow<String> {
     return flow {
         val inv = select(::bar, ::foo)
-        inv()
+        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
     }
 }
 
@@ -53,7 +53,7 @@ fun poll01(): Flow<String> {
 fun poll02(): Flow<String> {
     return flow {
         val inv = select(::bar3, ::foo3)
-        inv()
+        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
     }
 }
 
@@ -67,7 +67,7 @@ fun poll03(): Flow<String> {
 fun poll04(): Flow<String> {
     return flow {
         val inv = select(::bar5, ::foo5)
-        inv
+        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
     }
 }
 
@@ -81,7 +81,7 @@ fun poll05(): Flow<String> {
 fun poll06(): Flow<String> {
     return flow {
         val inv = select(foo7(), <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!>)
-        inv
+        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
     }
 }
 
@@ -101,14 +101,14 @@ fun poll11(flag: Boolean): Flow<String> {
 
 fun poll12(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!> } else { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> }
+        val inv = if (flag) { ::bar3 } else { ::foo3 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
 fun poll13(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { ::bar2 } else { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> }
+        val inv = if (flag) { ::bar2 } else { ::foo3 }
         inv()
     }
 }
@@ -122,8 +122,8 @@ fun poll14(flag: Boolean): Flow<String> {
 
 fun poll15(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!> } else { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo5<!> }
+        val inv = if (flag) { ::bar5 } else { ::foo5 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -137,14 +137,14 @@ fun poll16(flag: Boolean): Flow<String> {
 fun poll17(flag: Boolean): Flow<String> {
     return flow {
         val inv = if (flag) { foo7() } else { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!> }
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }
 
 fun poll2(flag: Boolean): Flow<String> {
     return flow {
         val inv = when (flag) { true -> ::bar else -> ::foo }
-        inv()
+        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>inv<!>()
     }
 }
 
@@ -158,7 +158,7 @@ fun poll21(flag: Boolean): Flow<String> {
 fun poll22(flag: Boolean): Flow<String> {
     return flow {
         val inv = when (flag) { true -> ::bar3 else -> ::foo3 }
-        inv()
+        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>inv<!>()
     }
 }
 
@@ -193,7 +193,7 @@ fun poll26(flag: Boolean): Flow<String> {
 fun poll3(flag: Boolean): Flow<String> {
     return flow {
         val inv = when (flag) { true -> ::bar false -> ::foo }
-        inv()
+        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>inv<!>()
     }
 }
 
@@ -207,7 +207,7 @@ fun poll31(flag: Boolean): Flow<String> {
 fun poll32(flag: Boolean): Flow<String> {
     return flow {
         val inv = when (flag) { true -> ::bar3 false -> ::foo3 }
-        inv()
+        <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>inv<!>()
     }
 }
 
@@ -241,8 +241,8 @@ fun poll36(flag: Boolean): Flow<String> {
 
 fun poll4(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo<!> }
+        val inv = try { ::bar } finally { ::foo }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -255,8 +255,8 @@ fun poll41(): Flow<String> {
 
 fun poll42(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> }
+        val inv = try { ::bar3 } finally { ::foo3 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -269,8 +269,8 @@ fun poll43(): Flow<String> {
 
 fun poll44(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo5<!> }
+        val inv = try { ::bar5 } finally { ::foo5 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -290,8 +290,8 @@ fun poll46(): Flow<String> {
 
 fun poll5(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar<!> } catch (e: Exception) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo<!> }
+        val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -304,8 +304,8 @@ fun poll51(): Flow<String> {
 
 fun poll52(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!> } catch (e: Exception) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> }
+        val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::foo3 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -318,8 +318,8 @@ fun poll53(): Flow<String> {
 
 fun poll54(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!> } catch (e: Exception) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo5<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo5<!> }
+        val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -333,14 +333,14 @@ fun poll55(): Flow<String> {
 fun poll56(): Flow<String> {
     return flow {
         val inv = try { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!> } catch (e: Exception) { foo7() } finally { foo7() }
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }
 
 fun poll6(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar<!>
+        val inv = ::bar
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }
 
@@ -353,8 +353,8 @@ fun poll61(): Flow<String> {
 
 fun poll62(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!>
+        val inv = ::bar3
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }
 
@@ -367,8 +367,8 @@ fun poll63(): Flow<String> {
 
 fun poll64(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!>
+        val inv = ::bar5
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }
 
@@ -388,8 +388,8 @@ fun poll66(): Flow<String> {
 
 fun poll7(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar<!><!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = ::bar<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -402,8 +402,8 @@ fun poll71(): Flow<String> {
 
 fun poll72(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!><!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = ::bar3<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -416,8 +416,8 @@ fun poll73(): Flow<String> {
 
 fun poll74(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!><!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = ::bar5<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }
 
@@ -437,7 +437,7 @@ fun poll76(): Flow<String> {
 
 fun poll8(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar<!> in setOf(<!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!><!>)
+        val inv = ::bar in setOf(::foo)
         <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>inv<!>()
     }
 }
@@ -451,7 +451,7 @@ fun poll81(): Flow<String> {
 
 fun poll82(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!> in setOf(<!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo3<!><!>)
+        val inv = ::bar3 in setOf(::foo3)
         <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>inv<!>()
     }
 }
@@ -465,7 +465,7 @@ fun poll83(): Flow<String> {
 
 fun poll84(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!> in setOf(<!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo5<!><!>)
+        val inv = ::bar5 in setOf(::foo5)
         inv
     }
 }
@@ -486,8 +486,8 @@ fun poll86(): Flow<String> {
 
 fun poll87(): Flow<String> {
     return flow {
-        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> setOf(foo7())
+        val inv = <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::<!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>Foo7<!><!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>in<!> <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>setOf<!>(<!TYPE_INFERENCE_ONLY_INPUT_TYPES!>foo7<!>())
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        <!TYPE_INFERENCE_ONLY_INPUT_TYPES!>inv<!>
     }
 }
 

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt

@@ -50,14 +50,14 @@ fun poll11(flag: Boolean): Flow<String> {
 
 fun poll12(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!> } else { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> }
+        val inv = if (flag) { ::bar3 } else { ::foo3 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
 fun poll13(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { ::bar2 } else { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> }
+        val inv = if (flag) { ::bar2 } else { ::foo3 }
         inv()
     }
 }
@@ -71,8 +71,8 @@ fun poll14(flag: Boolean): Flow<String> {
 
 fun poll15(flag: Boolean): Flow<String> {
     return flow {
-        val inv = if (flag) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!> } else { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo5<!> }
+        val inv = if (flag) { ::bar5 } else { ::foo5 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -86,14 +86,14 @@ fun poll16(flag: Boolean): Flow<String> {
 fun poll17(flag: Boolean): Flow<String> {
     return flow {
         val inv = if (flag) { foo7() } else { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!> }
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }
 
 fun poll4(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo<!> }
+        val inv = try { ::bar } finally { ::foo }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -106,8 +106,8 @@ fun poll41(): Flow<String> {
 
 fun poll42(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> }
+        val inv = try { ::bar3 } finally { ::foo3 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -120,8 +120,8 @@ fun poll43(): Flow<String> {
 
 fun poll44(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo5<!> }
+        val inv = try { ::bar5 } finally { ::foo5 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -141,8 +141,8 @@ fun poll46(): Flow<String> {
 
 fun poll5(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar<!> } catch (e: Exception) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo<!> }
+        val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -155,8 +155,8 @@ fun poll51(): Flow<String> {
 
 fun poll52(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!> } catch (e: Exception) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo3<!> }
+        val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::foo3 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -169,8 +169,8 @@ fun poll53(): Flow<String> {
 
 fun poll54(): Flow<String> {
     return flow {
-        val inv = try { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!> } catch (e: Exception) { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo5<!> } finally { <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::foo5<!> }
+        val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 }
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -184,6 +184,6 @@ fun poll55(): Flow<String> {
 fun poll56(): Flow<String> {
     return flow {
         val inv = try { <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>::Foo7<!> } catch (e: Exception) { foo7() } finally { foo7() }
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }

compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt

@@ -37,8 +37,8 @@ class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
 
 fun poll7(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar<!><!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = ::bar<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -51,8 +51,8 @@ fun poll71(): Flow<String> {
 
 fun poll72(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar3<!><!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = ::bar3<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
-        <!DEBUG_INFO_MISSING_UNRESOLVED!>inv()<!>
+        inv()
     }
 }
 
@@ -65,8 +65,8 @@ fun poll73(): Flow<String> {
 
 fun poll74(): Flow<String> {
     return flow {
-        val inv = <!TYPE_INFERENCE_POSTPONED_VARIABLE_IN_RECEIVER_TYPE!>::bar5<!><!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
+        val inv = ::bar5<!NOT_NULL_ASSERTION_ON_CALLABLE_REFERENCE!>!!<!>
-        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>inv<!>
+        inv
     }
 }
 

compiler/testData/diagnostics/tests/inference/kt47316.kt

@@ -30,7 +30,7 @@ fun String.asFsdAddress(): String {
 fun box(): String {
     val state = Test().state
     if (state is GoBuildingRunningState<*>) {
-        <!DEBUG_INFO_SMARTCAST, TYPE_MISMATCH_WARNING!>state<!>.buildingWorkingDirectory.asFsdAddress()
+        state.<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>buildingWorkingDirectory<!>.<!DEBUG_INFO_MISSING_UNRESOLVED!>asFsdAddress<!>()
     }
     return "OK"
 }

compiler/testData/diagnostics/tests/typealias/boundsViolationInDeepTypeAliasExpansion.kt

@@ -14,4 +14,4 @@ fun test4(x: <!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION!>TC2<Number, List<Any
 val test5 = TC2<Number, Collection<Number>>()
 val test6 = TC2<Number, Collection<Int>>()
 val test7 = TC2<Number, List<Int>>()
-val test8 = TC2<Number, <!UPPER_BOUND_VIOLATED!>List<Any><!>>()
+val test8 = TC2<Number, <!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>List<Any><!>>()

compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt

@@ -28,4 +28,4 @@ fun test12(x: TC<Number, <!UPPER_BOUND_VIOLATED!>List<Any><!>>) {}
 val test13 = TC<Number, Collection<Number>>()
 val test14 = TC<Number, Collection<Int>>()
 val test15 = TC<Number, List<Int>>()
-val test16 = TC<Number, <!UPPER_BOUND_VIOLATED!>List<Any><!>>()
+val test16 = TC<Number, <!UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>List<Any><!>>()

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt

@@ -1,3 +1,4 @@
+// !LANGUAGE: -TypeEnhancementImprovementsInStrictMode
 // FULL_JDK
 
 // FILE: MapLike.java

compiler/testData/diagnostics/testsWithStdLib/builderInference/incorrectCallsWithRestrictions.txt

@@ -2,14 +2,8 @@ package
 
 public val test1: kotlin.collections.List<kotlin.Int>
 public val test2: kotlin.collections.List<kotlin.Int>
-public val test3: [ERROR : Type for generate {
+public val test3: kotlin.collections.List<kotlin.Int>
-    yield(3)
+public val test4: kotlin.collections.List<kotlin.Int>
-    yieldBarReturnType(3)
-}]
-public val test4: [ERROR : Type for generate {
-    yield(3)
-    barReturnType()
-}]
 public fun </*0*/ S> generate(/*0*/ @kotlin.BuilderInference g: suspend GenericController<S>.() -> kotlin.Unit): kotlin.collections.List<S>
 
 public final class GenericController</*0*/ T> {

compiler/testData/diagnostics/testsWithStdLib/builderInference/useInferenceInformationFromExtensionWithRestrictions.txt

@@ -1,8 +1,6 @@
 package
 
-public val extension: [ERROR : Type for generate {
+public val extension: kotlin.collections.List<kotlin.String>
-    extensionYield("foo")
-}]
 public val normal: kotlin.collections.List<kotlin.Int>
 public val safeExtension: kotlin.collections.List<kotlin.String>
 public fun </*0*/ S> generate(/*0*/ @kotlin.BuilderInference g: suspend GenericController<S>.() -> kotlin.Unit): kotlin.collections.List<S>

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35684.kt

@@ -21,7 +21,7 @@ fun test_2() {
 fun test_3() {
     sequence {
         yield(materialize<Int>())
-        <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>materialize<!>()
+        <!TYPE_MISMATCH, TYPE_MISMATCH!>materialize()<!>
     }
 }
 

compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41308.kt

@@ -1,10 +1,10 @@
 // FIR_IDENTICAL
-// ISSUE: KT-41308
+// ISSUE: KT-41308, KT-47830
 
 fun main() {
-    sequence {
+    <!NEW_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>sequence<!> {
         val list: List<String>? = null
         val outputList = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.List<kotlin.String>")!>list ?: listOf()<!>
-        yieldAll(outputList)
+        <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE, NONE_APPLICABLE!>yieldAll<!>(outputList)
     }
 }

compiler/testData/diagnostics/testsWithStdLib/coroutines/kt41430.kt

@@ -1,4 +1,4 @@
-// ISSUE: KT-41430
+// ISSUE: KT-41430, KT-47830
 
 class A
 
@@ -14,7 +14,7 @@ fun test_2(list: List<Set<A>>) {
 
 fun test_3(list: List<Set<A>>) {
     sequence {
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableSet<A>")!>list.flatMapTo(mutableSetOf()) { it }<!>
+        <!DEBUG_INFO_EXPRESSION_TYPE("Type is unknown")!>list.flatMapTo(mutableSetOf()) { it }<!>
         yield(A())
     }
 }
@@ -22,6 +22,6 @@ fun test_3(list: List<Set<A>>) {
 fun test_4(list: List<Set<A>>) {
     sequence {
         yield(A())
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableSet<A>")!>list.flatMapTo(mutableSetOf()) { it }<!>
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.collections.MutableSet<A>"), TYPE_MISMATCH, TYPE_MISMATCH!>list.flatMapTo(mutableSetOf()) { it }<!>
     }
 }

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/notNullAnnotation.kt

@@ -1,4 +1,4 @@
-// !LANGUAGE: +NewInference
+// !LANGUAGE: -TypeEnhancementImprovementsInStrictMode
 
 // FILE: SmartFMap.java
 

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

@@ -1,4 +1,5 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !LANGUAGE: -TypeEnhancementImprovementsInStrictMode
 // FULL_JDK
 
 // FILE: MapLike.java