[FIR] Harden check of argument type properly

Before this commit, nullable argument could match not null parameter.
Now we require also correct nullability that breaks some cases

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt

@@ -254,9 +254,7 @@ private fun checkApplicabilityForArgumentType(
     }
     if (!csBuilder.addSubtypeConstraintIfCompatible(argumentType, expectedType, position)) {
         if (!isReceiver) {
-            if (!csBuilder.addSubtypeConstraintIfCompatible(argumentType, nullableExpectedType, position)) {
+            csBuilder.addSubtypeConstraint(argumentType, expectedType, position)
-                csBuilder.addSubtypeConstraint(argumentType, expectedType, position)
-            }
             return
         }
         if (csBuilder.addSubtypeConstraintIfCompatible(argumentType, nullableExpectedType, position)) {

compiler/fir/resolve/testData/resolve/stdlib/factoryFunctionOverloads.txt

@@ -27,5 +27,5 @@ FILE: factoryFunctionOverloads.kt
     public final fun foo(c: R|C|, b: R|B|, bn: R|B?|): R|kotlin/Unit| {
         lval x: R|A| = R|/A|(R|<local>/c|)
         lval y: R|A| = R|/A.A|(R|<local>/b|)
-        lval z: R|A| = R|/A.A|(R|<local>/bn|)
+        lval z: R|A| = R|/A|(R|<local>/bn|)
     }

compiler/testData/diagnostics/tests/ExtensionCallInvoke.fir.kt

@@ -2,6 +2,6 @@ fun bar(doIt: Int.() -> Int) {
     1.doIt()
     1?.doIt()
     val i: Int? = 1
-    i.doIt()
+    i.<!INAPPLICABLE_CANDIDATE!>doIt<!>()
     i?.doIt()
 }

compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt

@@ -23,8 +23,8 @@ fun <T> test(x: T) {
 
     baz<Int?, String?>(null, null, ::foo)
 
-    baz<Int, String?>(null, null, ::foo)
+    <!INAPPLICABLE_CANDIDATE!>baz<!><Int, String?>(null, null, ::foo)
-    baz<Int?, String>(null, null, ::foo)
+    <!INAPPLICABLE_CANDIDATE!>baz<!><Int?, String>(null, null, ::foo)
     baz(null, "", ::foo)
     baz(1, null, ::foo)
     baz(null, null, ::foo)

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.fir.kt

@@ -5,9 +5,9 @@ fun foo() {
     val x: Int? = null
 
     if (x != null && bar(x) == 0) bar(bar(x))
-    bar(x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
-    if (x == null || bar(x) == 0) bar(bar(x))
+    if (x == null || bar(x) == 0) bar(<!INAPPLICABLE_CANDIDATE!>bar<!>(x))
-    bar(x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     if (x is Int && bar(x)*bar(x) == bar(x)) bar(x)
-    bar(x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.fir.kt

@@ -4,10 +4,10 @@ fun foo() {
     val x: Int? = null
     val a = Array<Int>(3, {0})
 
-    if (x != null) bar(a[x]) else bar(a[x])
+    if (x != null) bar(a[x]) else bar(<!INAPPLICABLE_CANDIDATE!>a[x]<!>)
     bar(a[if (x == null) 0 else x])
-    bar(a[x])
+    bar(<!INAPPLICABLE_CANDIDATE!>a[x]<!>)
     
-    "123"[x];
+    <!INAPPLICABLE_CANDIDATE!>"123"[x]<!>;
     if (x != null) "123"[x];
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.fir.kt

@@ -6,6 +6,6 @@ fun foo() {
     val x: Int? = null
 
     bar(1 + (if (x == null) 0 else x))
-    bar(if (x == null) x else x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (x == null) x else x)
     if (x != null) bar(x + x/(x-x*x))
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.fir.kt

@@ -17,14 +17,14 @@ fun foo() {
         if (x == null) bar(x) else bar(x)
         bar(bar(x))
     } else if (x == null) {
-        bar(x)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
         if (x != null) {
             bar(x)
             if (x == null) bar(x)
             if (x == null) bar(x) else bar(x)
             bar(bar(x) + bar(x))
         } else if (x == null) {
-            bar(x)
+            <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
         }
     }
 

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.fir.kt

@@ -4,13 +4,13 @@ fun foo() {
     val x: Int? = null
 
     do {
-        bar(x)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     } while (x == null)
     bar(x)
     
     val y: Int? = null
     do {
-        bar(y)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
     } while (y != null)
-    bar(y)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhileCondition.fir.kt

@@ -16,5 +16,5 @@ fun doWhileWithBreak(x: Int?, y0: Int) {
         y++
         if (y > 0) break
     } while (x!! == y)
-    checkSubtype<Int>(x)
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Elvis.fir.kt

@@ -5,5 +5,5 @@ fun foo() {
 
     bar(x ?: 0)
     if (x != null) bar(x ?: x)
-    bar(x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.fir.kt

@@ -1,7 +1,7 @@
 fun bar(x: Int) = x + 1
 
 fun f1(x: Int?) {
-    bar(x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     if (x != null) bar(x!!)
     if (x == null) bar(x!!)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.fir.kt

@@ -5,7 +5,7 @@ fun foo() {
     val a = Array<Int>(3, {0})
 
     for (p in a) {
-        bar(x)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
         if (x == null) continue
         bar(x)
         for (q in a) {
@@ -15,7 +15,7 @@ fun foo() {
     }
 
     for (p in a) {
-        bar(x)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
         if (x == null) break
         bar(x)
     }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/FunctionLiteral.fir.kt

@@ -3,7 +3,7 @@ fun bar(x: Int) = x + 1
 fun foo() {
     val x: Int? = null
 
-    fun baz() = bar(x)
+    fun baz() = <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     fun quux() = if (x != null) bar(x) else baz()
     fun quuux() = bar(if (x == null) 0 else x)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfStatement.fir.kt

@@ -25,7 +25,7 @@ fun ifThenElse(x: Int?) {
 
 fun ifIs(x: Int?, cond: Boolean) {
     if ((x is Int) == cond) {
-        checkSubtype<Int>(x)
+        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
     }
-    checkSubtype<Int>(x)
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(x)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.fir.kt

@@ -6,7 +6,7 @@ fun foo() {
     bar(if (x == null) 0 else x)
 
     if (x == null) {
-        bar(x)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
         return
     } else {
         bar(x)
@@ -17,14 +17,14 @@ fun foo() {
     if (y is Int) {
         bar(y)
     } else {
-        bar(y)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
         return
     }
     bar(y)
 
     val z: Int? = null
     if (z != null) bar(z)
-    bar(z)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
     bar(z!!)
     if (z != null) bar(z!!)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.fir.kt

@@ -3,7 +3,7 @@ fun bar(x: Int): Int = x + 1
 fun foo() {
     val x: Int? = null
 
-    bar(x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     if (x != 2) {
         if (x == null) return
         2<!AMBIGUITY!>+<!><!SYNTAX!><!>

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/QualifiedExpression.fir.kt

@@ -7,7 +7,7 @@ class A {
 fun foo() {
     val x: Int? = null
 
-    A().bar(x)
+    A().<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     if (x == null) return
     A().bar(x)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.fir.kt

@@ -5,7 +5,7 @@ fun bar(x: Int): Int = x + 1
 fun foo(): Int {
     val x: Int? = null
 
-    bar(x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     if (x != null) return x
     
     val y: Int? = null

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.fir.kt

@@ -8,14 +8,14 @@ class Derived : Base() {
     fun foo() {
         val x: Int? = null
 
-        super.bar(x)
+        super.<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
-        this.baz(x)
+        this.<!INAPPLICABLE_CANDIDATE!>baz<!>(x)
         if (x == null) return
         super.bar(x)
         this.baz(x)
 
         val y: Int? = null
         if (y != null) super.bar(this.baz(y))
-        else this.baz(super.bar(y))
+        else this.baz(super.<!INAPPLICABLE_CANDIDATE!>bar<!>(y))
     }
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.fir.kt

@@ -3,7 +3,7 @@ fun bar(x: Int): RuntimeException = RuntimeException(x.toString())
 fun foo() {
     val x: Int? = null
 
-    if (x == null) throw bar(x)
+    if (x == null) throw <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     throw bar(x)
     throw bar(x)
 }

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.fir.kt

@@ -3,7 +3,7 @@ fun bar(x: Int): Int = x + 1
 fun foo() {
     val x: Int? = null
     
-    bar(x)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     if (x == null) return
     try {
         bar(x)

compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.fir.kt

@@ -3,7 +3,7 @@ fun bar(x: Int): Int = x + 1
 fun foo() {
     val x: Int? = null
     while (x == null) {
-        bar(x)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(x)
     }
     bar(x)
     
@@ -15,8 +15,8 @@ fun foo() {
     
     val z: Int? = null
     while (z == null) {
-        bar(z)
+        <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
         break
     }
-    bar(z)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(z)
 }

compiler/testData/diagnostics/tests/extensions/kt1875.fir.kt

@@ -3,7 +3,7 @@
 
 package kt1875
 
-fun foo(a : Int?, b : Int.(Int)->Int) = a?.b(1) //unnecessary safe call warning
+fun foo(a : Int?, b : Int.(Int)->Int) = a?.<!INAPPLICABLE_CANDIDATE!>b<!>(1) //unnecessary safe call warning
 
 interface T {
     val f : ((i: Int) -> Unit)?

compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.fir.kt

@@ -7,10 +7,10 @@ fun <E : CharSequence> foo1(x: E) {}
 fun <E : CharSequence> E.foo2() {}
 
 fun <F : String?> bar(x: F) {
-    A(x)
+    <!INAPPLICABLE_CANDIDATE!>A<!>(x)
     <!INAPPLICABLE_CANDIDATE!>A<!><F>(x)
 
-    foo1(x)
+    <!INAPPLICABLE_CANDIDATE!>foo1<!>(x)
     <!INAPPLICABLE_CANDIDATE!>foo1<!><F>(x)
 
     x.<!INAPPLICABLE_CANDIDATE!>foo2<!>()

compiler/testData/diagnostics/tests/generics/nullability/functionalBound.fir.kt

@@ -5,7 +5,7 @@ fun <E : String?, T : ((CharSequence) -> Unit)?> foo(x: E, y: T) {
     }
 
     if (y != null) {
-        y(x)
+        <!INAPPLICABLE_CANDIDATE!>y<!>(x)
     }
 
     if (x != null && y != null) {

compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt

@@ -6,7 +6,7 @@ fun <T> foo(): T {
     val x1: T = null
     val x2: T? = null
 
-    bar<T>(null)
+    <!INAPPLICABLE_CANDIDATE!>bar<!><T>(null)
     bar<T?>(null)
 
     return null
@@ -23,7 +23,7 @@ class A<F> {
         val x1: F = null
         val x2: F? = null
 
-        xyz(null)
+        <!INAPPLICABLE_CANDIDATE!>xyz<!>(null)
         bar<F?>(null)
 
         return null

compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt

@@ -18,14 +18,14 @@ class A<F> {
         x2.checkType { _<F>() }
 
         <!INAPPLICABLE_CANDIDATE!>foo1<!><F?>(y)
-        foo1(y)
+        <!INAPPLICABLE_CANDIDATE!>foo1<!>(y)
         foo2<F?>(y)
 
         val x3 = foo2(y)
         x3.checkType { _<F?>() }
 
-        foo1<F>(y)
+        <!INAPPLICABLE_CANDIDATE!>foo1<!><F>(y)
-        foo2<F>(y)
+        <!INAPPLICABLE_CANDIDATE!>foo2<!><F>(y)
 
         foo1<Z>(z)
 
@@ -38,7 +38,7 @@ class A<F> {
         x4.checkType { _<Z>() }
 
         <!INAPPLICABLE_CANDIDATE!>foo1<!><W>(w)
-        foo1(w)
+        <!INAPPLICABLE_CANDIDATE!>foo1<!>(w)
         foo2<W>(w)
 
         val x6 = foo2(w)

compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt

@@ -13,6 +13,6 @@ fun <T : String?> foo(x: T) {
     bar1(x)
     bar2(x)
 
-    bar3(x)
+    <!INAPPLICABLE_CANDIDATE!>bar3<!>(x)
-    bar4(x)
+    <!INAPPLICABLE_CANDIDATE!>bar4<!>(x)
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.fir.kt

@@ -12,5 +12,5 @@ fun acceptA(a: A) {
 
 fun main(i: I<*>) {
     i.foo() checkType { <!UNRESOLVED_REFERENCE!>_<!><A?>() }
-    acceptA(i.foo()) // i.foo() should be nullable but isn't
+    <!INAPPLICABLE_CANDIDATE!>acceptA<!>(i.foo()) // i.foo() should be nullable but isn't
 }

compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt

@@ -7,7 +7,7 @@ interface A<T>
 fun <T> infer(a: A<T>) : T {}
 
 fun test(nothing: Nothing?) {
-    val i = infer(nothing)
+    val i = <!INAPPLICABLE_CANDIDATE!>infer<!>(nothing)
 }
 
 fun sum(a : IntArray) : Int {

compiler/testData/diagnostics/tests/inference/kt1293.fir.kt

@@ -6,7 +6,7 @@ package kt1293
 fun main() {
     val intArray = arrayOfNulls<Int>(10)
     val i : Int = intArray[0]
-    requiresInt(intArray[0])
+    <!INAPPLICABLE_CANDIDATE!>requiresInt<!>(intArray[0])
 }
 
 fun requiresInt(i: Int) {}

compiler/testData/diagnostics/tests/inference/nestedCalls/kt3461checkTypes.fir.kt

@@ -10,6 +10,6 @@ fun foo(s: String) {}
 fun r(): Int? = null
 
 fun test() {
-    foo(F().p())
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(F().p())
     <!INAPPLICABLE_CANDIDATE!>foo<!>(r())
 }

compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt

@@ -8,7 +8,7 @@ fun <T> bar(a: T, b: Map<T, String>) = b.get(a)
 
 fun test(a: Int) {
     foo(a, null)
-    bar(a, null)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(a, null)
 }
 fun test1(a: Int) {
     foo(a, throw Exception())

compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.fir.kt

@@ -19,5 +19,5 @@ public class Y extends X<String> {
 
 fun main() {
     checkSubtype<Any>(Y().fooN())
-    Y().barN(null);
+    Y().<!INAPPLICABLE_CANDIDATE!>barN<!>(null);
 }

compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.fir.kt

@@ -19,5 +19,5 @@ public class Y extends X<A> {
 
 fun main() {
     checkSubtype<Any>(Y().fooN())
-    Y().barN(null);
+    Y().<!INAPPLICABLE_CANDIDATE!>barN<!>(null);
 }

compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.fir.kt

@@ -109,5 +109,5 @@ fun foo(x: SpecializedMap) {
     x.remove(null)
 
     x.<!AMBIGUITY!>put<!>(4, 5.0)
-    x.<!AMBIGUITY!>put<!>(4, null)
+    x.put(4, null)
 }

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

@@ -20,5 +20,5 @@ class In<in F> {
 
 fun test() {
     A.foo().x() checkType { <!UNRESOLVED_REFERENCE!>_<!><Any?>() }
-    A.bar().y(null)
+    A.bar().<!INAPPLICABLE_CANDIDATE!>y<!>(null)
 }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.fir.kt

@@ -8,7 +8,7 @@ fun main() {
     val y: Foo? = null
     
     x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
-    x!!.foo(y)
+    x!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
     x.foo(y!!)
     x!!.foo(y!!)
     
@@ -18,8 +18,8 @@ fun main() {
     
     a.<!INAPPLICABLE_CANDIDATE!>foo<!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
     a!!.foo(b.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
-    a.foo(b!!.foo(c))
+    a.foo(b!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
-    a!!.foo(b!!.foo(c))
+    a!!.foo(b!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
     a.foo(b.foo(c!!))
     a!!.foo(b.foo(c!!))
     a.foo(b!!.foo(c!!))

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.fir.kt

@@ -7,7 +7,7 @@ fun foo(x: Int): Int = x + 1
 fun main() {
     val x: Int? = null
 
-    foo(x)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(x)
 
     if (x != null) {
         foo(x)
@@ -15,14 +15,14 @@ fun main() {
         foo(x)
     }
 
-    foo(x)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(x)
 
     if (x != null) {
         foo(x)
         foo(x!!)
         foo(x)
     } else {
-        foo(x)
+        <!INAPPLICABLE_CANDIDATE!>foo<!>(x)
         foo(x!!)
         foo(x)
     }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.fir.kt

@@ -15,8 +15,8 @@ fun foo() {
 
     val y: Int? = 0
     val z: Int? = 0
-    bar(if (y != null) y else z, y)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (y != null) y else z, y)
     y <!INAPPLICABLE_CANDIDATE!>+<!> 2
-    baz(y, y, if (y == null) return else y, y)
+    <!INAPPLICABLE_CANDIDATE!>baz<!>(y, y, if (y == null) return else y, y)
     baz(y, z!!, z, y)
 }

compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentForIn.fir.kt

@@ -1,3 +1,3 @@
 fun test(x: Int?) {
-     x in 1..2
+     x <!INAPPLICABLE_CANDIDATE!>in<!> 1..2
 }

compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.fir.kt

@@ -13,6 +13,6 @@ public class J {
 
 fun test(j: J, nullStr: String?, nullByte: Byte?, nullDouble: Double?) {
     j.foo(nullStr)
-    j.foo(nullDouble)
+    j.<!INAPPLICABLE_CANDIDATE!>foo<!>(nullDouble)
     j.foo(nullByte)
 }

compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.fir.kt

@@ -6,8 +6,8 @@ fun foo(x: Int) {}
 fun foo(x: Int, y: String) {}
 
 fun bar(nullX: Int?, nullY: String?, notNullY: String) {
-    foo(nullX)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(nullX)
-    foo(nullX, notNullY)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(nullX, notNullY)
-    foo(nullX, nullY)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(nullX, nullY)
     <!INAPPLICABLE_CANDIDATE!>foo<!>()
 }

compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.fir.kt

@@ -8,5 +8,5 @@ fun foo(i: Int) = i
 
 fun test(a: A?) {
     a?.b(1) //should be no warning
-    foo(a?.b(1)) //no warning, only error
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(a?.b(1)) //no warning, only error
 }

compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.fir.kt

@@ -27,9 +27,9 @@ fun test(i: Int, ni: Int?) {
     checkSubtype<C>(foo(2))
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><J.A>(J.<!AMBIGUITY!>foo<!>(2))
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><J.A>(J.<!AMBIGUITY!>foo<!>(i))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><J.B>(J.<!AMBIGUITY!>foo<!>(ni))
+    checkSubtype<J.B>(J.foo(ni))
     checkSubtype<C>(foo(ni))
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><J.B>(J.<!AMBIGUITY!>foo<!>(ni))
+    checkSubtype<J.B>(J.foo(ni))
 
     foo(J.getInteger())
     J.<!AMBIGUITY!>foo<!>(J.getInteger())

compiler/testData/diagnostics/tests/platformTypes/methodCall/int.fir.kt

@@ -12,5 +12,5 @@ import p.*
 
 fun test() {
     J()._int(1)
-    J()._int(null)
+    J().<!INAPPLICABLE_CANDIDATE!>_int<!>(null)
 }

compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.fir.kt

@@ -13,7 +13,7 @@ public class A {
 fun test() {
     A.bar(null, "")
 
-    A.bar<String>(null, "")
+    A.<!INAPPLICABLE_CANDIDATE!>bar<!><String>(null, "")
     A.bar<String?>(null, "")
     A.bar(null, A.platformString())
 }

compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceValueParameter.fir.kt

@@ -17,10 +17,10 @@ public class A<T> {
 // FILE: k.kt
 
 fun test() {
-    A.create().bar(null)
+    A.create().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
     A.create().bar("")
 
-    A<String>().bar(null)
+    A<String>().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
-    A<String?>().bar(null)
+    A<String?>().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
     A<String?>().bar("")
 }

compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/substitutionInSuperType.fir.kt

@@ -33,9 +33,9 @@ class C2 : A<String?>() {
 }
 
 fun test() {
-    B1().bar(null)
+    B1().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
-    B2().bar(null)
+    B2().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
 
-    C1().bar(null)
+    C1().<!INAPPLICABLE_CANDIDATE!>bar<!>(null)
 }
 

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.fir.kt

@@ -34,7 +34,7 @@ fun test() {
     platformJ++
 
     1 + platformNN
-    1 + platformN
+    1 <!INAPPLICABLE_CANDIDATE!>+<!> platformN
     1 + platformJ
 
     platformNN + 1
@@ -42,7 +42,7 @@ fun test() {
     platformJ + 1
 
     1 plus platformNN
-    1 plus platformN
+    1 <!INAPPLICABLE_CANDIDATE!>plus<!> platformN
     1 plus platformJ
 
     platformNN plus 1

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.fir.kt

@@ -15,7 +15,7 @@ public class J {
 
 fun test() {
     val n = J.staticN
-    foo(n)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(n)
     J.staticNN = n
     if (n != null) {
         foo(n)

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.fir.kt

@@ -23,7 +23,7 @@ fun test() {
     val platformJ = J.staticJ
 
     checkSubtype<J>(platformNN)
-    checkSubtype<J>(platformN)
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><J>(platformN)
     checkSubtype<J>(platformJ)
 
     checkSubtype<J?>(platformNN)

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.fir.kt

@@ -15,7 +15,7 @@ public class J {
 
 fun test() {
     foo(J.staticNN)
-    foo(J.staticN)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(J.staticN)
     foo(J.staticJ)
 
     bar(J.staticNN)

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.fir.kt

@@ -54,8 +54,8 @@ fun test(n: J?, nn: J) {
 
     J.staticSet(nn, nn, nn)
     J.staticSet(platformNN, platformNN, platformNN)
-    J.staticSet(n, n, n)
+    J.<!INAPPLICABLE_CANDIDATE!>staticSet<!>(n, n, n)
-    J.staticSet(platformN, platformN, platformN)
+    J.<!INAPPLICABLE_CANDIDATE!>staticSet<!>(platformN, platformN, platformN)
     J.staticSet(platformJ, platformJ, platformJ)
 
     J().nn = n
@@ -78,13 +78,13 @@ fun test(n: J?, nn: J) {
 
     J().set(nn, nn, nn)
     J().set(platformNN, platformNN, platformNN)
-    J().set(n, n, n)
+    J().<!INAPPLICABLE_CANDIDATE!>set<!>(n, n, n)
-    J().set(platformN, platformN, platformN)
+    J().<!INAPPLICABLE_CANDIDATE!>set<!>(platformN, platformN, platformN)
     J().set(platformJ, platformJ, platformJ)
 
     J(nn, nn, nn)
     J(platformNN, platformNN, platformNN)
-    J(n, n, n)
+    <!INAPPLICABLE_CANDIDATE!>J<!>(n, n, n)
-    J(platformN, platformN, platformN)
+    <!INAPPLICABLE_CANDIDATE!>J<!>(platformN, platformN, platformN)
     J(platformJ, platformJ, platformJ)
 }

compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.fir.kt

@@ -10,7 +10,7 @@ class E : B1() {
 
         x.<!INAPPLICABLE_CANDIDATE!>foo<!>(x)
         x.<!INAPPLICABLE_CANDIDATE!>foo<!>("")
-        x.bar(x)
+        x.<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
         x.bar("")
     }
 

compiler/testData/diagnostics/tests/regressions/kt1489_1728.fir.kt

@@ -19,7 +19,7 @@ class C {
     fun p() : Resource? = null
 
     fun bar() {
-        foo(p()) {
+        <!INAPPLICABLE_CANDIDATE!>foo<!>(p()) {
 
         }
     }

compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.fir.kt

@@ -5,5 +5,5 @@
 fun foo(i: Int) {}
 
 fun test(s: String?) {
-    foo(s?.length)
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(s?.length)
 }

compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.fir.kt

@@ -4,19 +4,19 @@ package b
 fun bar(i: Int) = i
 
 fun test(a: Int?, b: Int?) {
-    bar(if (a == null) return else b)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (a == null) return else b)
 }
 
 fun test(a: Int?, b: Int?, c: Int?) {
-    bar(if (a == null) return else if (b == null) return else c)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (a == null) return else if (b == null) return else c)
 }
 
 fun test(a: Any?, b: Any?, c: Int?) {
-    bar(if (a == null) if (b == null) c else return else return)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (a == null) if (b == null) c else return else return)
 }
 
 fun test(a: Int?, b: Any?, c: Int?) {
-    bar(if (a == null) {
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(if (a == null) {
         return
     } else {
         if (b == null) {

compiler/testData/diagnostics/tests/smartCasts/classObjectMember.fir.kt

@@ -15,7 +15,7 @@ class B {
 fun test() {
     if (A.x != null) {
         useInt(A.x)
-        useInt(B.x)
+        <!INAPPLICABLE_CANDIDATE!>useInt<!>(B.x)
     }
 }
 

compiler/testData/diagnostics/tests/smartCasts/elvisExclExclPlatform.fir.kt

@@ -19,7 +19,7 @@ fun bar(x: String) = x
 fun test(x: String?): Any {
     val y = My.create()
     val z = x ?: y!!
-    bar(y)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(y)
     // !! / ?. is necessary here, because y!! above may not be executed
     y?.hashCode()
     y!!.hashCode()

compiler/testData/diagnostics/tests/smartCasts/kt2422.fir.kt

@@ -6,10 +6,10 @@ class Test {
 
     fun bar(a: Test, b: Test) {
         if (a.foo != null) {
-            useInt(b.foo)
+            <!INAPPLICABLE_CANDIDATE!>useInt<!>(b.foo)
         }
         if (a.foo != null) {
-            useInt(foo)
+            <!INAPPLICABLE_CANDIDATE!>useInt<!>(foo)
         }
         if (this.foo != null) {
             useInt(foo)

compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt

@@ -7,6 +7,6 @@ fun foo(a: MutableMap<String, String>, x: String?) {
 }
 
 fun foo1(a: MutableMap<String, String>, x: String?) {
-    a[x] = x!!
+    <!INAPPLICABLE_CANDIDATE!>a[x] = x!!<!>
     a[x!!] = x
 }

compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.fir.kt

@@ -11,14 +11,14 @@ val i: Int? = 1
 class A(val i: Int?) {
     fun testUseFromClass() {
         if (foo.i != null) {
-            useInt(i)
+            <!INAPPLICABLE_CANDIDATE!>useInt<!>(i)
         }
     }
 }
 
 fun testUseFromOtherPackage() {
     if (bar.i != null) {
-        useInt(i)
+        <!INAPPLICABLE_CANDIDATE!>useInt<!>(i)
     }
 }
 

compiler/testData/diagnostics/tests/smartCasts/safecalls/simpleNullableReceiver.fir.kt

@@ -3,4 +3,4 @@ fun Any?.foo(my: My) = my === this
 class My(val x: Any)
 
 // my is nullable in brackets because Any?.foo has nullable receiver
-fun foo(my: My?) = my?.x.foo(my)
+fun foo(my: My?) = my?.x.<!INAPPLICABLE_CANDIDATE!>foo<!>(my)

compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt

@@ -7,5 +7,5 @@ fun bar(s: String): Int {
 
 fun foo(m: MyClass): Int {
     m.p = "xyz"
-    return bar(m.p)
+    return <!INAPPLICABLE_CANDIDATE!>bar<!>(m.p)
 }

compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.fir.kt

@@ -23,7 +23,7 @@ fun foo(k: KotlinClass) {
 
     k.setSomething4("")
     k.<!VARIABLE_EXPECTED!>something4<!> += ""
-    k.setSomething4(null)
+    k.<!INAPPLICABLE_CANDIDATE!>setSomething4<!>(null)
     k.something4 = null
 
     useString(k.getSomething5())

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.fir.kt

@@ -1,8 +1,8 @@
 // !WITH_NEW_INFERENCE
 // FILE: KotlinFile.kt
 fun foo(javaInterface: JavaInterface) {
-    javaInterface.doIt(null) { }
+    javaInterface.<!INAPPLICABLE_CANDIDATE!>doIt<!>(null) { }
-    javaInterface.doIt("", null)
+    javaInterface.<!INAPPLICABLE_CANDIDATE!>doIt<!>("", null)
 }
 
 // FILE: JavaInterface.java

compiler/testData/diagnostics/tests/targetedBuiltIns/forEachRemainingNullability.fir.kt

@@ -32,7 +32,7 @@ abstract class MyIt7 : Iterator<String> {
 
 
 fun foo(x: Iterator<String>, y: Iterator<String?>) {
-    x.forEachRemaining(null)
+    x.<!INAPPLICABLE_CANDIDATE!>forEachRemaining<!>(null)
 
     x.forEachRemaining { it -> it.length }
     x.forEachRemaining { it -> it?.length }

compiler/testData/diagnostics/tests/targetedBuiltIns/mutableMapRemove.fir.kt

@@ -19,7 +19,7 @@ class KotlinMap2 : java.util.AbstractMap<String, Int>() {
 fun foo(x: MutableMap<String, Int>, y: java.util.HashMap<String, Int>, z: java.util.AbstractMap<String, Int>) {
     x.remove("", 1)
     x.<!INAPPLICABLE_CANDIDATE!>remove<!>("", "")
-    x.remove("", null)
+    x.<!INAPPLICABLE_CANDIDATE!>remove<!>("", null)
 
     y.remove("", 1)
     y.remove("", "")

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.fir.kt

@@ -21,7 +21,7 @@ class Pair<X, Y>(val x: X, val y: Y)
 typealias PL<T> = Pair<T, List<T>>
 typealias PN<T> = Pair<T, Num<T>>
 
-val test5 = PL(1, null)
+val test5 = <!INAPPLICABLE_CANDIDATE!>PL<!>(1, null)
 
 
 class Foo<T>(val p: Pair<T, T>)

compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt

@@ -31,7 +31,7 @@ fun getArr(): Array<String>? = null
 
 fun f() {
     A().foo(1, *args)
-    bar(2, *args)
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(2, *args)
     <!INAPPLICABLE_CANDIDATE!>baz<!>(*args)
 }
 
@@ -55,7 +55,7 @@ fun h(b: B) {
 
 fun k() {
     A().foo(1, *getArr())
-    bar(2, *getArr())
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(2, *getArr())
     <!INAPPLICABLE_CANDIDATE!>baz<!>(*getArr())
 }
 

compiler/testData/diagnostics/testsWithStdLib/java/functionN.fir.kt

@@ -46,7 +46,7 @@ fun main() {
     a.bar()
     a.baz(listOf())
 
-    a.<!AMBIGUITY!>manyParams<!>(null)
+    a.manyParams(null)
     a.manyParams(any<kotlin.jvm.functions.FunctionN<Unit>>())
 
     // Potentially, this would have better to forbid calling manyParams, too.

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

@@ -6,12 +6,12 @@ fun bar(): String? = null
 
 fun foo() {
     var x = ArrayList<String>()
-    x.add(null)
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(null)
-    x.add(bar())
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(bar())
     x.add("")
 
-    x[0] = null
+    <!INAPPLICABLE_CANDIDATE!>x[0] = null<!>
-    x[0] = bar()
+    <!INAPPLICABLE_CANDIDATE!>x[0] = bar()<!>
     x[0] = ""
 
     val b1: MutableList<String?> = x

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

@@ -24,8 +24,8 @@ fun bar(): String? = null
 
 fun foo() {
     var x = A<String>()
-    x.add(null)
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(null)
-    x.add(bar())
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(bar())
     x.add("")
 
     val b1: Collection<String?> = x

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

@@ -24,12 +24,12 @@ fun bar(): String? = null
 
 fun foo() {
     var x = A<String>()
-    x.add(null)
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(null)
-    x.add(bar())
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(bar())
     x.add("")
 
-    x[0] = null
+    <!INAPPLICABLE_CANDIDATE!>x[0] = null<!>
-    x[0] = bar()
+    <!INAPPLICABLE_CANDIDATE!>x[0] = bar()<!>
     x[0] = ""
 
     val b1: MutableList<String?> = x

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

@@ -10,14 +10,14 @@ val nullableInt: Int? = null
 
 fun hashMapTest() {
     var x: HashMap<String, Int> = HashMap<String, Int>()
-    x.put(null, null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(null, null)
-    x.put("", null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>("", null)
-    x.put(bar(), 1)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(bar(), 1)
     x.put("", 1)
 
-    x[null] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[null] = 1<!>
-    x[bar()] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[bar()] = 1<!>
-    x[""] = nullableInt
+    <!INAPPLICABLE_CANDIDATE!>x[""] = nullableInt<!>
     x[""] = 1
 
     val b1: MutableMap<String, Int?> = x
@@ -34,14 +34,14 @@ fun hashMapTest() {
 
 fun treeMapTest() {
     var x: TreeMap<String, Int> = TreeMap<String, Int>()
-    x.put(null, null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(null, null)
-    x.put("", null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>("", null)
-    x.put(bar(), 1)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(bar(), 1)
     x.put("", 1)
 
-    x[null] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[null] = 1<!>
-    x[bar()] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[bar()] = 1<!>
-    x[""] = nullableInt
+    <!INAPPLICABLE_CANDIDATE!>x[""] = nullableInt<!>
     x[""] = 1
 
     val b1: MutableMap<String, Int?> = x
@@ -58,14 +58,14 @@ fun treeMapTest() {
 
 fun concurrentHashMapTest() {
     var x: ConcurrentHashMap<String, Int> = ConcurrentHashMap<String, Int>()
-    x.put(null, null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(null, null)
-    x.put("", null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>("", null)
-    x.put(bar(), 1)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(bar(), 1)
     x.put("", 1)
 
-    x[null] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[null] = 1<!>
-    x[bar()] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[bar()] = 1<!>
-    x[""] = nullableInt
+    <!INAPPLICABLE_CANDIDATE!>x[""] = nullableInt<!>
     x[""] = 1
 
     val b1: MutableMap<String, Int?> = x

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

@@ -9,14 +9,14 @@ val nullableInt: Int? = null
 
 fun hashMapTest() {
     var x: HashMap<String?, Int> = HashMap<String?, Int>()
-    x.put(null, null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(null, null)
-    x.put("", null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>("", null)
     x.put(bar(), 1)
     x.put("", 1)
 
     x[null] = 1
     x[bar()] = 1
-    x[""] = nullableInt
+    <!INAPPLICABLE_CANDIDATE!>x[""] = nullableInt<!>
     x[""] = 1
 
     val b1: MutableMap<String?, Int?> = x
@@ -34,14 +34,14 @@ fun hashMapTest() {
 
 fun treeMapTest() {
     var x: TreeMap<String?, Int> = TreeMap<String?, Int>()
-    x.put(null, null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(null, null)
-    x.put("", null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>("", null)
     x.put(bar(), 1)
     x.put("", 1)
 
     x[null] = 1
     x[bar()] = 1
-    x[""] = nullableInt
+    <!INAPPLICABLE_CANDIDATE!>x[""] = nullableInt<!>
     x[""] = 1
 
     val b1: MutableMap<String?, Int?> = x

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

@@ -9,13 +9,13 @@ val nullableInt: Int? = null
 
 fun hashMapTest() {
     var x: HashMap<String, Int?> = HashMap<String, Int?>()
-    x.put(null, null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(null, null)
     x.put("", null)
-    x.put(bar(), 1)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(bar(), 1)
     x.put("", 1)
 
-    x[null] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[null] = 1<!>
-    x[bar()] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[bar()] = 1<!>
     x[""] = nullableInt
     x[""] = 1
 
@@ -33,13 +33,13 @@ fun hashMapTest() {
 
 fun treeMapTest() {
     var x: TreeMap<String, Int?> = TreeMap<String, Int?>()
-    x.put(null, null)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(null, null)
     x.put("", null)
-    x.put(bar(), 1)
+    x.<!INAPPLICABLE_CANDIDATE!>put<!>(bar(), 1)
     x.put("", 1)
 
-    x[null] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[null] = 1<!>
-    x[bar()] = 1
+    <!INAPPLICABLE_CANDIDATE!>x[bar()] = 1<!>
     x[""] = nullableInt
     x[""] = 1
 

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

@@ -8,8 +8,8 @@ fun bar(): String? = null
 
 fun fooHashSet() {
     var x = HashSet<String>()
-    x.add(null)
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(null)
-    x.add(bar())
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(bar())
     x.add("")
 
     val b1: MutableSet<String?> = x
@@ -22,8 +22,8 @@ fun fooHashSet() {
 
 fun fooTreeSet() {
     var x = TreeSet<String>()
-    x.add(null)
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(null)
-    x.add(bar())
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(bar())
     x.add("")
 
     val b1: MutableSet<String?> = x
@@ -36,8 +36,8 @@ fun fooTreeSet() {
 
 fun fooLinkedHashSet() {
     var x = LinkedHashSet<String>()
-    x.add(null)
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(null)
-    x.add(bar())
+    x.<!INAPPLICABLE_CANDIDATE!>add<!>(bar())
     x.add("")
 
     val b1: MutableSet<String?> = x

compiler/testData/diagnostics/testsWithStdLib/regression/kt2082.fir.kt

@@ -2,7 +2,7 @@ fun foo(c : Collection<String>) = {
     c.filter{
         val s : String? = bar()
         if (s == null) false // here!
-        zoo(s)
+        <!INAPPLICABLE_CANDIDATE!>zoo<!>(s)
     }
 }
 

compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.fir.kt

@@ -3,7 +3,7 @@
 fun indexOfMax(a: IntArray): Int? {
     var maxI: Int? = 0
     a.forEachIndexed { i, value ->
-        if (value >= a[maxI]) {
+        if (value >= <!INAPPLICABLE_CANDIDATE!>a[maxI]<!>) {
             maxI = i
         }
         else if (value < 0) {