FIR: more exact nullability determination in potential UNSAFE_CALL check

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt

@@ -100,6 +100,16 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
         reporter.report(coneDiagnostic)
     }
 
+    private fun ConeKotlinType.isEffectivelyNotNull(): Boolean {
+        return when (this) {
+            is ConeClassLikeType -> !isMarkedNullable
+            is ConeTypeParameterType -> !isMarkedNullable && lookupTag.typeParameterSymbol.fir.bounds.any {
+                it.coneTypeSafe<ConeKotlinType>()?.isEffectivelyNotNull() == true
+            }
+            else -> false
+        }
+    }
+
     private fun mapInapplicableCandidateError(
         diagnostic: ConeInapplicableCandidateError,
         source: FirSourceElement,
@@ -107,16 +117,19 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
         // TODO: Need to distinguish SMARTCAST_IMPOSSIBLE
         // TODO: handle other UNSAFE_* variants: invoke, infix, operator
         val rootCause = diagnostic.diagnostics.find { it.applicability == diagnostic.applicability }
-        return if (rootCause != null &&
+        if (rootCause != null &&
             rootCause is InapplicableWrongReceiver &&
             rootCause.actualType?.isNullable == true &&
             (rootCause.expectedType == null || !rootCause.expectedType!!.isMarkedNullable)
         ) {
             // TODO: report on call operation node, e.g., x<!>.<!>length instead of x.<!>length<!>
-            FirErrors.UNSAFE_CALL.on(source, rootCause.actualType!!)
+            val expectedType = rootCause.expectedType
-        } else {
+
-            FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidateSymbol)
+            if (expectedType == null || expectedType.isEffectivelyNotNull()) {
+                return FirErrors.UNSAFE_CALL.on(source, rootCause.actualType!!)
+            }
         }
+        return FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidateSymbol)
     }
 
     private fun ConeSimpleDiagnostic.getFactory(): FirDiagnosticFactory0<FirSourceElement, *> {

compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.fir.kt

@@ -14,11 +14,11 @@ fun test() {
 }
 
 fun check() {
-    [1, 2] <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Int>>() }
+    [1, 2] <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Int>>() }
-    [""] <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<String>>() }
+    [""] <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<String>>() }
 
     val f: IntArray = [1]
-    [f] <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<IntArray>>() }
+    [f] <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<IntArray>>() }
 
-    [1, ""] <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Any>>() }
+    [1, ""] <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Any>>() }
 }

compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt

@@ -5,7 +5,7 @@ fun foo(block: () -> (() -> Int)) {}
 
 fun test() {
     val x = <!EXPRESSION_REQUIRED!>fun named1(x: Int): Int { return 1 }<!>
-    x <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Int, Int>>() }
+    x <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Int, Int>>() }
 
     foo { fun named2(): Int {return 1} }
     foo({ fun named3() = 1 })

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt

@@ -24,24 +24,24 @@ fun bar(aInstance: A, bInstance: B) {
 
     foo(bInstance) {
         (a, b): A, (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        <!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
         d checkType { _<Short>() }
     }
 
     foo(bInstance) {
         (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        <!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
         d checkType { _<Short>() }
     }
 
     foo<A, B>(bInstance) {
         (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        <!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
         d checkType { _<Short>() }
     }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.fir.kt

@@ -23,7 +23,7 @@ fun bar() {
     }
 
     foo { (a, b), (c, b) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
         b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { <!INAPPLICABLE_CANDIDATE!>_<!><B>() }
     }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.fir.kt

@@ -36,8 +36,8 @@ fun bar() {
     }
 
     foobar { (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-        <!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
         d checkType { _<Short>() }
     }

compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unusedParameters.fir.kt

@@ -32,12 +32,12 @@ fun bar() {
     }
 
     foobar { (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+        <!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
         d checkType { _<Short>() }
     }
 
     foobar { (a, b), (c, d) ->
-        <!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        <!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         c checkType { _<Double>() }
     }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClasses.fir.kt

@@ -20,7 +20,7 @@ class A : Outer<Double, Short>() {
 
 fun foo() {
     Derived().foo() checkType { _<Outer<String, Int>.Inner<Char>>() }
-    Derived().baz() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, String>>() }
+    Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, String>>() }
     A.B().bar() checkType { _<Outer<Float, Long>.Inner<String>>() }
-    A.B().x() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<String, Float>>() }
+    A.B().x() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<String, Float>>() }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.fir.kt

@@ -43,7 +43,7 @@ fun test() {
     x = foobar<String>()
 
     x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Long>>() }
-    x().bar() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Char>>() }
+    x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Char>>() }
 
     x = foobar<Int>()
 
@@ -51,5 +51,5 @@ fun test() {
     y = noParameters()
 
     y().foo().a() checkType { _<A<Any, Double, Short, Long>>() }
-    y().bar() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any, Double, Short, Char>>() }
+    y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any, Double, Short, Char>>() }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.fir.kt

@@ -44,7 +44,7 @@ class Outer<T> {
             x = foobar<String>()
 
             x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Long>>() }
-            x().bar() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Char>>() }
+            x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Char>>() }
 
             x = foobar<Int>()
             x = z.foobar<String>()
@@ -53,7 +53,7 @@ class Outer<T> {
             y = noParameters()
 
             y().foo().a() checkType { _<A<T, F, Any, Double, Short, Long>>() }
-            y().bar() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Char>>() }
+            y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Char>>() }
         }
     }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesTransitive.fir.kt

@@ -15,5 +15,5 @@ class Derived : BaseDerived2<Int>() {
 
 fun foo() {
     Derived().foo() checkType { _<Outer<Int, String>.Inner<Char>>() }
-    Derived().baz() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, Int>>() }
+    Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, Int>>() }
 }

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloads.fir.kt

@@ -19,9 +19,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
 // FILE: main.kt
 
 fun main(c: CollectionWithSize) {
-    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
+    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
-    c.<!AMBIGUITY!>size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
-    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
+    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
-    <!UNRESOLVED_REFERENCE!>c::size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
+    <!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
 }

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsDisabled.fir.kt

@@ -20,9 +20,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
 // FILE: main.kt
 
 fun main(c: CollectionWithSize) {
-    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
+    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
-    c.<!AMBIGUITY!>size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
-    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
+    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
-    <!UNRESOLVED_REFERENCE!>c::size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
+    <!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
 }

compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsNI.fir.kt

@@ -19,9 +19,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
 // FILE: main.kt
 
 fun main(c: CollectionWithSize) {
-    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
+    CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
-    c.<!AMBIGUITY!>size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 
-    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
+    <!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
-    <!UNRESOLVED_REFERENCE!>c::size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
+    <!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
 }

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

@@ -11,6 +11,6 @@ public class A {
 // FILE: main.kt
 
 fun foo(a: A) {
-    a.<!AMBIGUITY!>foo<!>() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    a.<!AMBIGUITY!>foo<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    A.<!AMBIGUITY!>bar<!>() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    A.<!AMBIGUITY!>bar<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 }

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/primaryConstructorParameter.fir.kt

@@ -19,5 +19,5 @@ class C(p: Any, val v: Any) {
 
     var test5
         get() { return <!UNRESOLVED_REFERENCE!>p<!> }
-        set(nv) { <!UNRESOLVED_REFERENCE!>p<!>.<!UNSAFE_CALL!>let<!> {} }
+        set(nv) { <!UNRESOLVED_REFERENCE!>p<!>.<!INAPPLICABLE_CANDIDATE!>let<!> {} }
 }

compiler/testData/diagnostics/tests/samConversions/OverloadPriority.fir.kt

@@ -22,9 +22,9 @@ public interface J {
 
 // FILE: 1.kt
 fun test(j: J) {
-    j.<!AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    j.<!AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
-    j.<!AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    j.<!AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
     // NI: TODO
     j.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }

compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.fir.kt

@@ -21,9 +21,9 @@ interface K {
 }
 
 fun test(k: K) {
-    k.<!AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    k.<!AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
-    k.<!AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> <!UNSAFE_CALL!>checkType<!> { _<Any?>() }; "" } <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    k.<!AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Any?>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 
     // NI: TODO
     k.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }

compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.fir.kt

@@ -33,6 +33,6 @@ fun test() {
         x.baz(1).checkType { _<Unit>() }
         x.<!INAPPLICABLE_CANDIDATE!>baz<!>(1, 2)
 
-        x.<!UNRESOLVED_REFERENCE!>foobar<!>().<!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        x.<!UNRESOLVED_REFERENCE!>foobar<!>().<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
     }
 }

compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.fir.kt

@@ -7,7 +7,7 @@ interface A : MutableCollection<String> {
 }
 
 fun foo(x: MutableCollection<Int>, y: Collection<String>, z: A) {
-    x.<!UNRESOLVED_REFERENCE!>nonExistingMethod<!>(1).<!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    x.<!UNRESOLVED_REFERENCE!>nonExistingMethod<!>(1).<!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
     y.<!UNRESOLVED_REFERENCE!>nonExistingMethod<!>("")
     z.nonExistingMethod("")
 }

compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt

@@ -14,7 +14,7 @@ fun foo() {
     <!INAPPLICABLE_CANDIDATE!>takeUByte<!>(id(1))
 
     1 <!NONE_APPLICABLE!>+<!> 1u
-    (1u <!NONE_APPLICABLE!>+<!> 1) <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><UInt>() }
+    (1u <!NONE_APPLICABLE!>+<!> 1) <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><UInt>() }
 
     <!INAPPLICABLE_CANDIDATE!>id<!><UInt>(1)
 }

compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.fir.kt

@@ -21,7 +21,7 @@ fun test() {
     foo(1) checkType { _<Int>() }
     foo(1u) checkType { _<String>() }
 
-    <!NONE_APPLICABLE!>foo<!>(2147483648) <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    <!NONE_APPLICABLE!>foo<!>(2147483648) <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
     foo(2147483647 + 1) checkType { _<Int>() }
 
     fooByte(1) checkType { _<Int>() }

compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.fir.kt

@@ -24,7 +24,7 @@ public class StaticOverrides {
 // FILE: test.kt
 
 fun test() {
-    StaticOverrides.A.<!AMBIGUITY!>foo<!> {} <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Boolean>() }
+    StaticOverrides.A.<!AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Boolean>() }
     StaticOverrides.B.foo {} checkType { _<String>() }
-    StaticOverrides.C.<!AMBIGUITY!>foo<!> {} <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Boolean>() }
+    StaticOverrides.C.<!AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Boolean>() }
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.fir.kt

@@ -20,6 +20,6 @@ class Foo {
 
 // FILE: 1.kt
 fun test() {
-    Foo().<!AMBIGUITY!>foo<!> {} <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    Foo().<!AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-    Foo().<!AMBIGUITY!>bar<!> {} <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    Foo().<!AMBIGUITY!>bar<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenericsWithoutRefinedSams.fir.kt

@@ -21,6 +21,6 @@ class Foo {
 
 // FILE: 1.kt
 fun test() {
-    Foo().<!AMBIGUITY!>foo<!> {} <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    Foo().<!AMBIGUITY!>foo<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
-    Foo().<!AMBIGUITY!>bar<!> {} <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    Foo().<!AMBIGUITY!>bar<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.fir.kt

@@ -16,5 +16,5 @@ public class Foo {
 
 // FILE: 1.kt
 fun bar() {
-    Foo().<!AMBIGUITY!>test<!> {} <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    Foo().<!AMBIGUITY!>test<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
 }

compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunctionWithoutRefinedSams.fir.kt

@@ -18,5 +18,5 @@ public class Foo {
 
 // FILE: 1.kt
 fun bar() {
-    Foo().<!AMBIGUITY!>test<!> {} <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    Foo().<!AMBIGUITY!>test<!> {} <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
 }

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.3.fir.kt

@@ -105,8 +105,8 @@ fun case_6() {
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Short>(<!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!>)
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(<!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!>)
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!>)
-    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Byte>() }
+    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Byte>() }
-    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Short>() }
+    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Short>() }
-    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Int>() }
+    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Int>() }
-    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 }

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.4.fir.kt

@@ -3,23 +3,23 @@
 // TESTCASE NUMBER: 1
 fun case_1() {
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!>)
-    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!>)
-    <!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 }
 
 // TESTCASE NUMBER: 2
 fun case_2() {
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!>)
-    <!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!>)
-    <!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!>)
-    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Long>(<!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!>)
-    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!> <!UNSAFE_CALL!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 }

compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/52.fir.kt

@@ -89,7 +89,7 @@ fun <T : String?> T.case_9() = this
 fun case_9() {
     var x: Int? = 10
     x = null
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int?")!>x<!>.<!UNSAFE_CALL!>case_9<!>()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>case_9<!>()
 }
 
 /*