FIR checker: differentiate UNSAFE_CALL from INAPPLICABLE_CANDIDATE

To do so, inside the root cause of inapplicable candidate errors,
we will record expected/actual type of receiver, if any.
That will help identifying inapplicable calls on nullable receiver.

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

@@ -12,21 +12,21 @@ fun test(x : Int?, a : A?) {
     x.<!NONE_APPLICABLE!>plus<!>(1)
     x?.plus(1)
     x <!NONE_APPLICABLE!>+<!> 1
-    <!INAPPLICABLE_CANDIDATE!>-<!>x
-    x.<!INAPPLICABLE_CANDIDATE!>unaryMinus<!>()
+    <!UNSAFE_CALL!>-<!>x
+    x.<!UNSAFE_CALL!>unaryMinus<!>()
     x?.unaryMinus()
 
-    a.<!INAPPLICABLE_CANDIDATE!>plus<!>(1)
+    a.<!UNSAFE_CALL!>plus<!>(1)
     a?.plus(1)
-    a <!INAPPLICABLE_CANDIDATE!>plus<!> 1
-    a <!INAPPLICABLE_CANDIDATE!>+<!> 1
-    <!INAPPLICABLE_CANDIDATE!>-<!>a
-    a.<!INAPPLICABLE_CANDIDATE!>unaryMinus<!>()
+    a <!UNSAFE_CALL!>plus<!> 1
+    a <!UNSAFE_CALL!>+<!> 1
+    <!UNSAFE_CALL!>-<!>a
+    a.<!UNSAFE_CALL!>unaryMinus<!>()
     a?.unaryMinus()
 
-    a.<!INAPPLICABLE_CANDIDATE!>div<!>(1)
-    a <!INAPPLICABLE_CANDIDATE!>/<!> 1
-    a <!INAPPLICABLE_CANDIDATE!>div<!> 1
+    a.<!UNSAFE_CALL!>div<!>(1)
+    a <!UNSAFE_CALL!>/<!> 1
+    a <!UNSAFE_CALL!>div<!> 1
     a?.div(1)
 
     a.times(1)
@@ -34,8 +34,8 @@ fun test(x : Int?, a : A?) {
     a times 1
     a?.times(1)
 
-    1 <!INAPPLICABLE_CANDIDATE!>in<!> a
-    a <!INAPPLICABLE_CANDIDATE!>contains<!> 1
-    a.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
+    1 <!UNSAFE_CALL!>in<!> a
+    a <!UNSAFE_CALL!>contains<!> 1
+    a.<!UNSAFE_CALL!>contains<!>(1)
     a?.contains(1)
 }

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

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

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

@@ -6,8 +6,8 @@ fun A.bar() {}
 fun A?.buzz() {}
 
 fun test(a : A?) {
-    a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // error
-    a.<!INAPPLICABLE_CANDIDATE!>bar<!>() // error
+    a.<!UNSAFE_CALL!>foo<!>() // error
+    a.<!UNSAFE_CALL!>bar<!>() // error
     a.buzz()
 
     a?.foo()
@@ -30,12 +30,12 @@ fun A.test2() {
 }
 
 fun A?.test3() {
-    <!INAPPLICABLE_CANDIDATE!>foo<!>() // error
-    <!INAPPLICABLE_CANDIDATE!>bar<!>() // error
+    <!UNSAFE_CALL!>foo<!>() // error
+    <!UNSAFE_CALL!>bar<!>() // error
     buzz()
 
-    this.<!INAPPLICABLE_CANDIDATE!>foo<!>() // error
-    this.<!INAPPLICABLE_CANDIDATE!>bar<!>() // error
+    this.<!UNSAFE_CALL!>foo<!>() // error
+    this.<!UNSAFE_CALL!>bar<!>() // error
     this.buzz()
 
     this?.foo()

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

@@ -5,7 +5,7 @@ package kt1270
 
 fun foo() {
     val sc = java.util.HashMap<String, SomeClass>()[""]
-    val value = sc.<!INAPPLICABLE_CANDIDATE!>value<!>
+    val value = sc.<!UNSAFE_CALL!>value<!>
 }
 
 private class SomeClass() {

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

@@ -5,7 +5,7 @@ package e
 fun main() {
     val compareTo = 1
     val s: String? = null
-    s.<!INAPPLICABLE_CANDIDATE!>compareTo<!>("")
+    s.<!UNSAFE_CALL!>compareTo<!>("")
 
     val bar = 2
     s.<!UNRESOLVED_REFERENCE!>bar<!>()