[FIR] Don't assume types with not found symbol as error types

compiler/fir/analysis-tests/testData/resolveWithStdlib/getOrPutAmbiguity.kt

@@ -0,0 +1,5 @@
+// !FULL_JDK
+
+fun test(map: MutableMap<Int, MutableMap<Int, Int>>) {
+    map.getOrPut(1, ::mutableMapOf)
+}

compiler/fir/analysis-tests/testData/resolveWithStdlib/getOrPutAmbiguity.txt

@@ -0,0 +1,4 @@
+FILE: getOrPutAmbiguity.kt
+    public final fun test(map: R|kotlin/collections/MutableMap<kotlin/Int, kotlin/collections/MutableMap<kotlin/Int, kotlin/Int>>|): R|kotlin/Unit| {
+        R|<local>/map|.R|kotlin/collections/getOrPut|<R|kotlin/Int|, R|kotlin/collections/MutableMap<kotlin/Int, kotlin/Int>|>(Int(1), ::R|kotlin/collections/mutableMapOf<kotlin/Int, kotlin/Int>|)
+    }

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithStdlibTestGenerated.java

@@ -128,6 +128,11 @@ public class FirDiagnosticsWithStdlibTestGenerated extends AbstractFirDiagnostic
         runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/getOnKProperty.kt");
     }
 
+    @TestMetadata("getOrPutAmbiguity.kt")
+    public void testGetOrPutAmbiguity() throws Exception {
+        runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/getOrPutAmbiguity.kt");
+    }
+
     @TestMetadata("hashMapTypeAlias.kt")
     public void testHashMapTypeAlias() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/hashMapTypeAlias.kt");

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt

@@ -236,7 +236,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
                 when (val symbol = toClassLikeSymbol().also { it?.ensureResolved(FirResolvePhase.TYPES, session) }) {
                     is FirClassSymbol<*> -> symbol.fir.superConeTypes
                     is FirTypeAliasSymbol -> listOfNotNull(symbol.fir.expandedConeType)
-                    else -> emptyList()
+                    else -> listOf(session.builtinTypes.anyType.type)
                 }
             }
             is ConeCapturedTypeConstructor -> supertypes!!
@@ -518,7 +518,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
     }
 
     override fun TypeConstructorMarker.isError(): Boolean {
-        return this is ErrorTypeConstructor || (this is ConeClassLikeLookupTag && this.toSymbol(session) == null)
+        return this is ErrorTypeConstructor
     }
 }
 

compiler/testData/codegen/box/arrays/primitiveArrays.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // KJS_WITH_FULL_RUNTIME
 // WITH_RUNTIME
 

compiler/testData/codegen/box/operatorConventions/plusAssignWithComplexRHS.kt

@@ -1,6 +1,5 @@
 // KJS_WITH_FULL_RUNTIME
 // WITH_RUNTIME
-// IGNORE_BACKEND_FIR: JVM_IR
 
 var map: Map<Any, Set<Any>> = emptyMap()
 

compiler/testData/codegen/box/regressions/kt3442.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // KJS_WITH_FULL_RUNTIME
 // WITH_RUNTIME
 

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectingInfo.fir.kt

@@ -31,12 +31,12 @@ fun intersectingInfo(x: Any?, y: Any?) {
     if ((isString(x) && y is String) || (!notIsString(x) && !notIsInt(y))) {
         x.length
         y.<!UNRESOLVED_REFERENCE!>length<!>
-        y.<!AMBIGUITY!>inc<!>()
+        y.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
     else {
         x.<!UNRESOLVED_REFERENCE!>length<!>
         y.<!UNRESOLVED_REFERENCE!>length<!>
-        y.<!AMBIGUITY!>inc<!>()
+        y.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
 }
 
@@ -49,13 +49,13 @@ fun intersectingInfo2(x: Any?, y: Any?) {
         (!notIsString(x) && isString(y) && y is Int) ||
         (x is String && !notIsInt(y) && x is Int)) {
         x.length
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
         y.<!UNRESOLVED_REFERENCE!>length<!>
-        y.<!AMBIGUITY!>inc<!>()
+        y.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
     x.<!UNRESOLVED_REFERENCE!>length<!>
-    x.<!AMBIGUITY!>inc<!>()
+    x.<!UNRESOLVED_REFERENCE!>inc<!>()
     y.<!UNRESOLVED_REFERENCE!>length<!>
-    y.<!AMBIGUITY!>inc<!>()
+    y.<!UNRESOLVED_REFERENCE!>inc<!>()
 }
 

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectionTypes.fir.kt

@@ -28,7 +28,7 @@ fun testDeMorgan(x: Any?) {
     }
     else {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
 }
 
@@ -36,7 +36,7 @@ fun testDeMorgan2(x: Any?) {
         // x !is String || x !is Int
     if (notIsString(x) || notIsInt(x)) {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
     else {
         x.length

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/nullabilitySmartcastWhenNullability.fir.kt

@@ -14,7 +14,7 @@ fun nullWhenNull(x: Int?): Int? {
 
 fun testNullWhenNull(x: Int?) {
     if (nullWhenNull(x) == null) {
-        x.<!AMBIGUITY!>dec<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>dec<!>()
     }
     else {
         x.dec()
@@ -24,10 +24,10 @@ fun testNullWhenNull(x: Int?) {
         x.dec()
     }
     else {
-        x.<!AMBIGUITY!>dec<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>dec<!>()
     }
 
-    x.<!AMBIGUITY!>dec<!>()
+    x.<!INAPPLICABLE_CANDIDATE!>dec<!>()
 }
 
 // NB. it is the same function as `nullWhenNull`, but annotations specifies other facet of the function behaviour
@@ -43,15 +43,15 @@ fun testNotNullWhenNotNull (x: Int?) {
         x == null
     }
     else {
-        x.<!AMBIGUITY!>dec<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>dec<!>()
     }
 
     if (notNullWhenNotNull(x) != null) {
-        x.<!AMBIGUITY!>dec<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>dec<!>()
     }
     else {
         x == null
     }
 
-    x.<!AMBIGUITY!>dec<!>()
+    x.<!INAPPLICABLE_CANDIDATE!>dec<!>()
 }

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperator.fir.kt

@@ -42,17 +42,17 @@ fun truetrue(x: Any?) {
         x.inc()
     }
     x.<!UNRESOLVED_REFERENCE!>length<!>
-    x.<!AMBIGUITY!>inc<!>()
+    x.<!UNRESOLVED_REFERENCE!>inc<!>()
 }
 
 fun truefalse(x: Any?) {
     if (trueWhenString(x) && falseWhenInt(x)) {
         x.length
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
     else {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
 }
 
@@ -63,19 +63,19 @@ fun falsetrue(x: Any?) {
     }
     else {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
 }
 
 fun falsefalse(x: Any?) {
     if (falseWhenString(x) && falseWhenInt(x)) {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
     else {
         // Note that we can't argue that we have any of smartcasts here,
         // because we don't know which one of both arguments was 'false' to bring us here
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!NONE_APPLICABLE!>inc<!>()
     }
 }

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/equalsOperator.fir.kt

@@ -20,28 +20,28 @@ fun myEqualsNotNull(x: Int?): Boolean {
 }
 
 fun testBasicEquals(x: Int?) {
-    x.<!AMBIGUITY!>inc<!>()
+    x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 
     if (myEqualsNull(x)) {
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
     }
     else {
         x.inc()
     }
 
-    x.<!AMBIGUITY!>inc<!>()
+    x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 }
 
 fun testBasicNotEquals(x: Int?) {
-    x.<!AMBIGUITY!>inc<!>()
+    x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 
     if (myEqualsNotNull(x)) {
         x.inc()
     }
     else {
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
     }
 
-    x.<!AMBIGUITY!>inc<!>()
+    x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 }
 

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperator.fir.kt

@@ -36,18 +36,18 @@ fun falseWhenInt(x: Any?): Boolean {
 fun truetrue(x: Any?) {
     if (trueWhenString(x) || trueWhenInt(x)) {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!NONE_APPLICABLE!>inc<!>()
     }
     else {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
 }
 
 fun truefalse(x: Any?) {
     if (trueWhenString(x) || falseWhenInt(x)) {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
     else {
         x.<!UNRESOLVED_REFERENCE!>length<!>
@@ -58,18 +58,18 @@ fun truefalse(x: Any?) {
 fun falsetrue(x: Any?) {
     if (falseWhenString(x) || trueWhenInt(x)) {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
     else {
         x.length
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
 }
 
 fun falsefalse(x: Any?) {
     if (falseWhenString(x) || falseWhenInt(x)) {
         x.<!UNRESOLVED_REFERENCE!>length<!>
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!UNRESOLVED_REFERENCE!>inc<!>()
     }
     else {
         x.length

compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/receiver.fir.kt

@@ -14,7 +14,7 @@ fun Any?.isNull(): Boolean {
 
 fun smartcastOnReceiver(x: Int?) {
     if (x.isNull()) {
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
     }
     else {
         x.dec()
@@ -26,10 +26,10 @@ class UnstableReceiver {
 
     fun smartcastOnUnstableReceiver() {
         if (x.isNull()) {
-            x.<!AMBIGUITY!>inc<!>()
+            x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
         }
         else {
-            x.<!AMBIGUITY!>dec<!>()
+            x.<!INAPPLICABLE_CANDIDATE!>dec<!>()
         }
     }
 }

compiler/testData/diagnostics/testsWithStdLib/hugeUnresolvedKotlinxHtml.fir.kt

@@ -1,28 +1,28 @@
 class A {
     fun bar() {
-        <!AMBIGUITY!>div<!> {
+        <!UNRESOLVED_REFERENCE!>div<!> {
-            <!AMBIGUITY!>div<!> {
+            <!UNRESOLVED_REFERENCE!>div<!> {
-                <!AMBIGUITY!>div<!> {
+                <!UNRESOLVED_REFERENCE!>div<!> {
-                    <!AMBIGUITY!>div<!> {
+                    <!UNRESOLVED_REFERENCE!>div<!> {
-                        <!AMBIGUITY!>div<!> {
+                        <!UNRESOLVED_REFERENCE!>div<!> {
-                            <!AMBIGUITY!>div<!> {
+                            <!UNRESOLVED_REFERENCE!>div<!> {
-                                <!AMBIGUITY!>div<!> {
+                                <!UNRESOLVED_REFERENCE!>div<!> {
-                                    <!AMBIGUITY!>div<!> {
+                                    <!UNRESOLVED_REFERENCE!>div<!> {
-                                        <!AMBIGUITY!>div<!> {
+                                        <!UNRESOLVED_REFERENCE!>div<!> {
-                                            <!AMBIGUITY!>div<!> {
+                                            <!UNRESOLVED_REFERENCE!>div<!> {
-                                                <!AMBIGUITY!>div<!> {
+                                                <!UNRESOLVED_REFERENCE!>div<!> {
-                                                    <!AMBIGUITY!>div<!> {
+                                                    <!UNRESOLVED_REFERENCE!>div<!> {
-                                                        <!AMBIGUITY!>div<!> {
+                                                        <!UNRESOLVED_REFERENCE!>div<!> {
-                                                            <!AMBIGUITY!>div<!> {
+                                                            <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                <!AMBIGUITY!>div<!> {
+                                                                <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                    <!AMBIGUITY!>div<!> {
+                                                                    <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                        <!AMBIGUITY!>div<!> {
+                                                                        <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                            <!AMBIGUITY!>div<!> {
+                                                                            <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                                <!AMBIGUITY!>div<!> {
+                                                                                <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                                    <!AMBIGUITY!>div<!> {
+                                                                                    <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                                        <!AMBIGUITY!>div<!> {
+                                                                                        <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                                            <!AMBIGUITY!>div<!> {
+                                                                                            <!UNRESOLVED_REFERENCE!>div<!> {
-                                                                                                <!AMBIGUITY!>div<!> {
+                                                                                                <!UNRESOLVED_REFERENCE!>div<!> {
                                                                                                     <!UNRESOLVED_REFERENCE!>+<!>(<!UNRESOLVED_REFERENCE!>foo<!> ?: "")
                                                                                                     <!UNRESOLVED_REFERENCE!>+<!>(<!UNRESOLVED_REFERENCE!>foo<!> ?: "")
                                                                                                     <!UNRESOLVED_REFERENCE!>+<!>(<!UNRESOLVED_REFERENCE!>foo<!> ?: "")

compiler/testData/diagnostics/testsWithStdLib/inference/callableReferenceOnParameter.fir.kt

@@ -3,6 +3,6 @@
 internal class Z<K> {
     val map = HashMap<String, String>()
     inline fun compute(key: String, producer: () -> String): String {
-        return map.getOrPut(key, ::producer)
+        return map.<!INAPPLICABLE_CANDIDATE!>getOrPut<!>(key, <!UNRESOLVED_REFERENCE!>::producer<!>)
     }
 }

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

@@ -1,5 +0,0 @@
-fun test(): Int {
-    val sets = (1..100).associateWith { (it..10 * it).mapTo(java.util.TreeSet()) { i -> i } }
-    val set = sets[50] ?: emptySet()
-    return set.<!UNRESOLVED_REFERENCE!>size<!>
-}

compiler/testData/diagnostics/testsWithStdLib/regression/kt37706.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 fun test(): Int {
     val sets = (1..100).associateWith { (it..10 * it).mapTo(java.util.TreeSet()) { i -> i } }
     val set = sets[50] ?: emptySet()

compiler/testData/diagnostics/testsWithStdLib/tryCatch/boundedSmartcasts.fir.kt

@@ -13,11 +13,11 @@ fun test0(x: Int?) {
 
     if (x != null) {
         x.inc()
-        y.<!AMBIGUITY!>inc<!>()
+        y.<!INAPPLICABLE_CANDIDATE!>inc<!>()
     }
 
     if (y != null) {
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
         y.inc()
     }
 }
@@ -32,11 +32,11 @@ fun test1(x: Int?) {
 
     if (x != null) {
         x.inc()
-        y.<!AMBIGUITY!>inc<!>()
+        y.<!INAPPLICABLE_CANDIDATE!>inc<!>()
     }
 
     if (y != null) {
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
         y.inc()
     }
 }
@@ -51,11 +51,11 @@ fun test2(x: Int?) {
 
     if (x != null) {
         x.inc()
-        y.<!AMBIGUITY!>inc<!>()
+        y.<!INAPPLICABLE_CANDIDATE!>inc<!>()
     }
 
     if (y != null) {
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
         y.inc()
     }
 }
@@ -69,11 +69,11 @@ fun test3(x: Int?) {
 
     if (x != null) {
         x.inc()
-        y.<!AMBIGUITY!>inc<!>()
+        y.<!INAPPLICABLE_CANDIDATE!>inc<!>()
     }
 
     if (y != null) {
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
         y.inc()
     }
 }
@@ -91,11 +91,11 @@ fun test5(x: Int?) {
 
     if (x != null) {
         x.inc()
-        y.<!AMBIGUITY!>inc<!>()
+        y.<!INAPPLICABLE_CANDIDATE!>inc<!>()
     }
 
     if (y != null) {
-        x.<!AMBIGUITY!>inc<!>()
+        x.<!INAPPLICABLE_CANDIDATE!>inc<!>()
         y.inc()
     }
 }

compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors2.fir.kt

@@ -24,4 +24,4 @@ val test1 = R { }
 val test2 = C<String> { s -> println(s.length) }
 val test3 = CStr { s -> <!AMBIGUITY!>println<!>(s.<!UNRESOLVED_REFERENCE!>length<!>) }
 val test4 = CStrList { ss -> <!NONE_APPLICABLE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (s in ss) { <!AMBIGUITY!>println<!>(s.<!UNRESOLVED_REFERENCE!>length<!>) }<!> }
-val test5 = <!INAPPLICABLE_CANDIDATE!>C2<!><Int> { a, b -> val x: Int = a <!AMBIGUITY!>+<!> b; println(x)}
+val test5 = <!INAPPLICABLE_CANDIDATE!>C2<!><Int> { a, b -> val x: Int = a <!NONE_APPLICABLE!>+<!> b; println(x)}

compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg/1.1.fir.kt

@@ -15,7 +15,7 @@ class A() {
 
 fun case1() {
     var b: Case1? = Case1()
-    <!AMBIGUITY!>--<!>b?.a
+    <!INAPPLICABLE_CANDIDATE!>--<!>b?.a
 }
 
 

compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg/1.1.fir.kt

@@ -15,7 +15,7 @@ class A() {
 
 fun case1() {
     var b: Case1? = Case1()
-    <!AMBIGUITY!>++<!>b?.a
+    <!INAPPLICABLE_CANDIDATE!>++<!>b?.a
 }
 
 

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg/1.fir.kt

@@ -46,7 +46,7 @@ fun case_1(value_1: Int?) {
     if (contracts.case_1(value_1) { value_2 = 10 }) {
         println(<!UNINITIALIZED_VARIABLE!>value_2<!>)
     } else {
-        value_1.inv()
+        value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         println(<!UNINITIALIZED_VARIABLE!>value_2<!>)
     }
 }
@@ -56,10 +56,10 @@ fun case_2(value_1: Int?, value_2: Int?, value_3: Any?) {
     val value_4: Int
     when (value_1.case_2(value_2, value_3) { value_4 = 10 }) {
         true -> {
-            <!AMBIGUITY!>println<!>(value_3?.xor(true))
+            <!AMBIGUITY!>println<!>(value_3?.<!UNRESOLVED_REFERENCE!>xor<!>(true))
             println(<!UNINITIALIZED_VARIABLE!>value_4<!>)
-            <!AMBIGUITY!>println<!>(value_1.inv())
+            println(value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>())
-            <!AMBIGUITY!>println<!>(value_2.inv())
+            println(value_2.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
         false -> {
             println(<!UNINITIALIZED_VARIABLE!>value_4<!>)

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos/1.fir.kt

@@ -61,7 +61,7 @@ fun case_2(value_1: Int?, value_2: Int?, value_3: Any?) {
             println(value_2)
         }
         null -> {
-            <!AMBIGUITY!>println<!>(value_3?.xor(true))
+            <!AMBIGUITY!>println<!>(value_3?.<!UNRESOLVED_REFERENCE!>xor<!>(true))
             println(value_4)
             println(value_1)
             println(value_2)

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/1.fir.kt

@@ -11,13 +11,13 @@ fun case_1(value_1: Any?) {
 // TESTCASE NUMBER: 2
 fun case_2(value_1: Int?) {
     funWithReturnsAndInvertCondition(value_1 != null)
-    <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>inc<!>())
+    println(value_1.<!INAPPLICABLE_CANDIDATE!>inc<!>())
 }
 
 // TESTCASE NUMBER: 3
 fun case_3(value_1: Int?) {
     funWithReturns(value_1 == null)
-    <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>inc<!>())
+    println(value_1.<!INAPPLICABLE_CANDIDATE!>inc<!>())
 }
 
 // TESTCASE NUMBER: 4
@@ -44,7 +44,7 @@ object case_7_object {
 }
 fun case_7() {
     funWithReturns(case_7_object.prop_1 == null)
-    case_7_object.prop_1.<!AMBIGUITY!>inc<!>()
+    case_7_object.prop_1.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 }
 
 // TESTCASE NUMBER: 8

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/10.fir.kt

@@ -213,7 +213,7 @@ fun case_2(value_1: Any?) {
 
 // TESTCASE NUMBER: 3
 fun case_3(number: Int?) {
-    if (!funWithReturnsTrueAndNullCheck(number)) number.<!AMBIGUITY!>inc<!>()
+    if (!funWithReturnsTrueAndNullCheck(number)) number.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 }
 
 // TESTCASE NUMBER: 4
@@ -284,7 +284,7 @@ fun case_12(value_1: Any?, value_2: Any?) {
         <!AMBIGUITY!>println<!>(value_2?.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (funWithReturnsFalse(value_1 !is Float? || value_1 == null || value_2 == null)) {
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         <!AMBIGUITY!>println<!>(value_2?.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (funWithReturnsNotNull(value_1 !is String || value_2 !is Number) == null) {
@@ -300,7 +300,7 @@ fun case_12(value_1: Any?, value_2: Any?) {
 // TESTCASE NUMBER: 13
 fun case_13(value_1: Any?, value_2: Any?) {
     if (!funWithReturnsTrueAndInvertCondition(value_1 is Float? && value_1 != null && value_2 != null)) {
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         <!AMBIGUITY!>println<!>(value_2?.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (funWithReturnsFalseAndInvertCondition(value_1 is String && value_2 is Number)) {
@@ -320,7 +320,7 @@ fun case_13(value_1: Any?, value_2: Any?) {
         <!AMBIGUITY!>println<!>(value_2?.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (funWithReturnsNotNull(value_1 is Float? && value_1 != null && value_2 != null) == null) {
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         <!AMBIGUITY!>println<!>(value_2?.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (funWithReturnsNullAndInvertCondition(value_1 is String && value_2 is Number) != null) {
@@ -332,7 +332,7 @@ fun case_13(value_1: Any?, value_2: Any?) {
         <!AMBIGUITY!>println<!>(value_2?.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (funWithReturnsNull(value_1 is Float? && value_1 != null && value_2 != null) != null) {
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         <!AMBIGUITY!>println<!>(value_2?.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
 }
@@ -344,24 +344,24 @@ class case_14_class {
     fun case_14(value_1: Any?, value_2: Number?) {
         val o = case_14_class()
         if (!funWithReturnsTrueAndInvertCondition(value_1 is Float? && value_1 != null && value_2 != null && o.prop_1 != null)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (funWithReturnsFalse(value_1 !is Float? || value_1 == null || value_2 == null || o.prop_1 == null || this.prop_1 == null)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (funWithReturnsNotNull(value_1 !is Float? || value_1 == null || value_2 == null || o.prop_1 == null || this.prop_1 == null) == null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (funWithReturnsNull(value_1 !is Float? || value_1 == null || value_2 == null || o.prop_1 == null || this.prop_1 == null) != null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
     }
 }
@@ -413,28 +413,28 @@ class case_17_class {
     fun case_17(value_1: Any?, value_2: Number?) {
         val o = case_17_class()
         if (contracts.case_17_1(value_1, value_2, o.prop_1, this.prop_1)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
-            <!AMBIGUITY!>println<!>(this.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(this.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (contracts.case_17_2(value_1, value_2, o.prop_1, this.prop_1)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
-            <!AMBIGUITY!>println<!>(this.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(this.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (contracts.case_17_3(value_1, value_2, o.prop_1, this.prop_1) == null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
-            <!AMBIGUITY!>println<!>(this.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(this.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (contracts.case_17_4(value_1, value_2, o.prop_1, this.prop_1) != null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
-            <!AMBIGUITY!>println<!>(this.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(this.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
     }
 }
@@ -449,10 +449,10 @@ fun case_18(value_1: Any?) {
 
 // TESTCASE NUMBER: 19
 fun case_19(value_1: Number) {
-    when { !value_1.case_19_1() -> <!AMBIGUITY!>println<!>(value_1.inv()) }
+    when { !value_1.case_19_1() -> <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>()) }
-    when { value_1.case_19_2() -> <!AMBIGUITY!>println<!>(value_1.inv()) }
+    when { value_1.case_19_2() -> <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>()) }
-    when { value_1.case_19_3() == null -> <!AMBIGUITY!>println<!>(value_1.inv()) }
+    when { value_1.case_19_3() == null -> <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>()) }
-    when { value_1.case_19_4() != null -> <!AMBIGUITY!>println<!>(value_1.inv()) }
+    when { value_1.case_19_4() != null -> <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>()) }
 }
 
 // TESTCASE NUMBER: 20
@@ -488,16 +488,16 @@ fun case_22(value_1: Any?, value_2: Any?) {
 
 // TESTCASE NUMBER: 23
 fun case_23(value_1: Number?, value_2: Number?) {
-    if (value_1.case_23_1()) <!AMBIGUITY!>println<!>(value_1.inv())
+    if (value_1.case_23_1()) <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_2.case_23_2() == null) <!AMBIGUITY!>println<!>(value_2.inv())
+    if (value_2.case_23_2() == null) <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_2.case_23_3() != null) <!AMBIGUITY!>println<!>(value_2.inv())
+    if (value_2.case_23_3() != null) <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 24
 fun case_24(value_1: Any?, value_2: Any?) {
-    if (value_1.case_24_1()) <!AMBIGUITY!>println<!>(value_1.inv())
+    if (value_1.case_24_1()) <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_2.case_24_2() != null) <!AMBIGUITY!>println<!>(value_2.inv())
+    if (value_2.case_24_2() != null) <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_2.case_24_3() == null) <!AMBIGUITY!>println<!>(value_2.inv())
+    if (value_2.case_24_3() == null) <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 25
@@ -505,19 +505,19 @@ fun case_25(value_1: Any?, value_2: Int?, value_3: Any?, value_4: Int?) {
     when {
         value_1.case_25_1(value_2) -> {
             <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_2.inv())
+            println(value_2.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
     when {
         value_3.case_25_2(value_4) == null -> {
             <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_4.inv())
+            println(value_4.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
     when {
         value_3.case_25_3(value_4) != null -> {
             <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_4.inv())
+            println(value_4.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/2.fir.kt

@@ -26,7 +26,7 @@ fun case_3(value_1: Any?, value_2: Any?) {
 // TESTCASE NUMBER: 4
 fun case_4(value_1: Any?, value_2: Number?) {
     funWithReturns(value_1 !is Float? || value_1 == null || value_2 == null)
-    <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
     println(value_2?.toByte())
 }
 
@@ -36,9 +36,9 @@ class case_5_class {
     fun case_5(value_1: Any?, value_2: Number?) {
         val o = case_5_class()
         funWithReturns(value_1 !is Float? || value_1 == null || value_2 == null || o.prop_1 == null)
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         println(value_2?.toByte())
-        <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+        <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
     }
 }
 
@@ -105,19 +105,19 @@ fun case_8(value_1: Any?, value_2: Any?) {
 // TESTCASE NUMBER: 9
 fun case_9(value_1: Any?, value_2: Number?) {
     if (funWithReturnsTrue(value_1 !is Float? || value_1 == null || value_2 == null)) {
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         println(value_2?.toByte())
     }
     if (!funWithReturnsFalse(value_1 !is Float? || value_1 == null || value_2 == null)) {
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         println(value_2?.toByte())
     }
     if (funWithReturnsNotNull(value_1 is Float? && value_1 != null && value_2 != null) == null) {
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         println(value_2?.toByte())
     }
     if (funWithReturnsNull(value_1 is Float? && value_1 != null && value_2 != null) != null) {
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         println(value_2?.toByte())
     }
 }
@@ -129,24 +129,24 @@ class case_10_class {
     fun case_10(value_1: Any?, value_2: Number?) {
         val o = case_10_class()
         if (funWithReturnsTrue(value_1 !is Float? || value_1 == null || value_2 == null || o.prop_1 == null || this.prop_1 == null)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (!funWithReturnsFalse(value_1 !is Float? || value_1 == null || value_2 == null || o.prop_1 == null || this.prop_1 == null)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (funWithReturnsNotNull(value_1 !is Float? || value_1 == null || value_2 == null || o.prop_1 == null || this.prop_1 == null) != null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (funWithReturnsNull(value_1 !is Float? || value_1 == null || value_2 == null || o.prop_1 == null || this.prop_1 == null) == null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
     }
 }
@@ -156,5 +156,5 @@ fun case_11(value_1: Any?, value_2: Any?, value_3: Any?) {
     funWithReturnsAndInvertCondition(value_1 !is String? || value_2 !is Number && value_3 !is Float)
     println(value_1!!.length)
     <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>toByte<!>())
-    <!AMBIGUITY!>println<!>(value_3.<!AMBIGUITY!>dec<!>())
+    <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>dec<!>())
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/3.fir.kt

@@ -103,9 +103,9 @@ class case_3_class {
     fun case_3(value_1: Any?, value_2: Number?) {
         val o = case_3_class()
         contracts.case_3(value_1, value_2, o.prop_1, this.prop_1)
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         println(value_2?.toByte())
-        <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+        <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
     }
 }
 
@@ -156,24 +156,24 @@ class case_6_class {
     fun case_6(value_1: Any?, value_2: Number?) {
         val o = case_6_class()
         if (contracts.case_6_1(value_1, value_2, o.prop_1, this.prop_1)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (!contracts.case_6_2(value_1, value_2, o.prop_1, this.prop_1)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (contracts.case_6_3(value_1, value_2, o.prop_1, this.prop_1) == null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (contracts.case_6_4(value_1, value_2, o.prop_1, this.prop_1) != null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/4.fir.kt

@@ -146,7 +146,7 @@ fun case_1(value_1: Any?) {
 // TESTCASE NUMBER: 2
 fun case_2(value_1: Number) {
     value_1.case_2()
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 3
@@ -175,10 +175,10 @@ fun case_5(value_1: Any?) {
 
 // TESTCASE NUMBER: 6
 fun case_6(value_1: Number) {
-    when { value_1.case_6_1() -> <!AMBIGUITY!>println<!>(value_1.inv()) }
+    when { value_1.case_6_1() -> <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>()) }
-    when { !value_1.case_6_2() -> <!AMBIGUITY!>println<!>(value_1.inv()) }
+    when { !value_1.case_6_2() -> <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>()) }
-    when { value_1.case_6_3() != null -> <!AMBIGUITY!>println<!>(value_1.inv()) }
+    when { value_1.case_6_3() != null -> <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>()) }
-    when { value_1.case_6_4() != null -> <!AMBIGUITY!>println<!>(value_1.inv()) }
+    when { value_1.case_6_4() != null -> <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>()) }
 }
 
 // TESTCASE NUMBER: 7

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/5.fir.kt

@@ -92,13 +92,13 @@ fun case_1(value_1: Any?) {
 // TESTCASE NUMBER: 2
 fun case_2(value_1: Number?) {
     value_1.case_2()
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 3
 fun case_3(value_1: Any?) {
     value_1.case_3()
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 4
@@ -111,16 +111,16 @@ fun case_4(value_1: Any?, value_2: Any?, value_3: Any?) {
 
 // TESTCASE NUMBER: 5
 fun case_5(value_1: Number?, value_2: Number?, value_3: Number?) {
-    if (value_1.case_5_1()) <!AMBIGUITY!>println<!>(value_1.inv())
+    if (value_1.case_5_1()) <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (!value_2.case_5_2()) <!AMBIGUITY!>println<!>(value_2.inv())
+    if (!value_2.case_5_2()) <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_3.case_5_3() != null) <!AMBIGUITY!>println<!>(value_3.inv())
+    if (value_3.case_5_3() != null) <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_3.case_5_4() == null) <!AMBIGUITY!>println<!>(value_3.inv())
+    if (value_3.case_5_4() == null) <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 6
 fun case_6(value_1: Any?, value_2: Any?, value_3: Any?) {
-    if (value_1.case_6_1()) <!AMBIGUITY!>println<!>(value_1.inv())
+    if (value_1.case_6_1()) <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (!value_2.case_6_2()) <!AMBIGUITY!>println<!>(value_2.inv())
+    if (!value_2.case_6_2()) <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_3.case_6_3() == null) <!AMBIGUITY!>println<!>(value_3.inv())
+    if (value_3.case_6_3() == null) <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_3.case_6_4() != null) <!AMBIGUITY!>println<!>(value_3.inv())
+    if (value_3.case_6_4() != null) <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/6.fir.kt

@@ -111,27 +111,27 @@ import contracts.*
 fun case_1(value_1: Any?, value_2: Int?) {
     value_1.case_1(value_2)
     <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>length<!>)
-    <!AMBIGUITY!>println<!>(value_2.inv())
+    println(value_2.<!INAPPLICABLE_CANDIDATE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 2
 fun case_2(value_1: Number?, value_2: Any?) {
     value_1.case_2(value_2)
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
     <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>toByte<!>())
 }
 
 // TESTCASE NUMBER: 3
 fun case_3(value_1: Any?, value_2: String?) {
     value_1.case_3(value_2)
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
     println(value_2.<!INAPPLICABLE_CANDIDATE!>length<!>)
 }
 
 // TESTCASE NUMBER: 4
 fun case_4(value_1: Any?, value_2: Number, value_3: Any?, value_4: String?) {
     value_1.case_4(value_2, value_3, value_4)
-    <!AMBIGUITY!>println<!>(value_2.inv())
+    <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
     <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>toByte<!>())
     println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>)
 }
@@ -141,19 +141,19 @@ fun case_5(value_1: Any?, value_2: Int?, value_3: Any?, value_4: Int?, value_5:
     when {
         value_1.case_5_1(value_2) -> {
             <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_2.inv())
+            println(value_2.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
     when {
         !value_3.case_5_2(value_4) -> {
             <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_4.inv())
+            println(value_4.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
     when {
         value_5.case_5_3(value_6) != null -> {
             <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_6.inv())
+            println(value_6.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
 }
@@ -161,19 +161,19 @@ fun case_5(value_1: Any?, value_2: Int?, value_3: Any?, value_4: Int?, value_5:
 // TESTCASE NUMBER: 6
 fun case_6(value_1: Number?, value_2: Any?, value_3: Number?, value_4: Any?, value_5: Number?, value_6: Any?) {
     if (value_1.case_6_1(value_2)) {
-        <!AMBIGUITY!>println<!>(value_1.inv())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
         <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (!value_3.case_6_2(value_4)) {
-        <!AMBIGUITY!>println<!>(value_3.inv())
+        <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
         <!AMBIGUITY!>println<!>(value_4.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (value_5.case_6_3(value_6) != null) {
-        <!AMBIGUITY!>println<!>(value_5.inv())
+        <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>inv<!>())
         <!AMBIGUITY!>println<!>(value_6.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (value_5.case_6_4(value_6) == null) {
-        <!AMBIGUITY!>println<!>(value_5.inv())
+        <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>inv<!>())
         <!AMBIGUITY!>println<!>(value_6.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
 }
@@ -181,35 +181,35 @@ fun case_6(value_1: Number?, value_2: Any?, value_3: Number?, value_4: Any?, val
 // TESTCASE NUMBER: 7
 fun case_7(value_1: Any?, value_2: String?, value_3: Any?, value_4: String?, value_5: Any?, value_6: String?) {
     if (value_1.case_7_1(value_2)) {
-        <!AMBIGUITY!>println<!>(value_1.inv())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
         println(value_2.<!INAPPLICABLE_CANDIDATE!>length<!>)
     }
     if (value_3.case_7_2(value_4)) {
-        <!AMBIGUITY!>println<!>(value_3.inv())
+        <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
         println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>)
     }
     if (value_5.case_7_3(value_6) != null) {
-        <!AMBIGUITY!>println<!>(value_5.inv())
+        <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>inv<!>())
         println(value_6.<!INAPPLICABLE_CANDIDATE!>length<!>)
     }
     if (value_5.case_7_4(value_6) == null) {
-        <!AMBIGUITY!>println<!>(value_5.inv())
+        <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>inv<!>())
         println(value_6.<!INAPPLICABLE_CANDIDATE!>length<!>)
     }
 }
 
 // TESTCASE NUMBER: 8
 fun case_8(value_1: Any?, value_2: Number, value_3: Any?, value_4: String?) {
-    when { value_1.case_8_1(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_2.inv()) }
+    when { value_1.case_8_1(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>()) }
     when { value_1.case_8_1(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>toByte<!>()) }
     when { value_1.case_8_1(value_2, value_3, value_4) -> println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>) }
-    when { !value_1.case_8_2(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_2.inv()) }
+    when { !value_1.case_8_2(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>()) }
     when { !value_1.case_8_2(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>toByte<!>()) }
     when { !value_1.case_8_2(value_2, value_3, value_4) -> println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>) }
-    when { value_1.case_8_3(value_2, value_3, value_4) == null -> <!AMBIGUITY!>println<!>(value_2.inv()) }
+    when { value_1.case_8_3(value_2, value_3, value_4) == null -> <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>()) }
     when { value_1.case_8_3(value_2, value_3, value_4) == null -> <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>toByte<!>()) }
     when { value_1.case_8_3(value_2, value_3, value_4) == null -> println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>) }
-    when { value_1.case_8_4(value_2, value_3, value_4) != null -> <!AMBIGUITY!>println<!>(value_2.inv()) }
+    when { value_1.case_8_4(value_2, value_3, value_4) != null -> <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>()) }
     when { value_1.case_8_4(value_2, value_3, value_4) != null -> <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>toByte<!>()) }
     when { value_1.case_8_4(value_2, value_3, value_4) != null -> println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>) }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/7.fir.kt

@@ -210,7 +210,7 @@ import contracts.*
 // TESTCASE NUMBER: 1
 fun case_1(value_1: Int?) {
     case_1_1(value_1)
-    value_1.inv()
+    value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     case_1_2(value_1)
     value_1.inv()
     case_1_1(value_1)
@@ -222,7 +222,7 @@ fun case_2(value_1: Number?) {
     case_2_1(value_1)
     value_1.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
     case_2_2(value_1)
-    value_1.inv()
+    value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 3
@@ -240,13 +240,13 @@ fun case_4(value_1: Any?) {
     <!INAPPLICABLE_CANDIDATE!>case_4_2<!>(value_1)
     value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
     <!INAPPLICABLE_CANDIDATE!>case_4_3<!>(value_1)
-    value_1.inv()
+    value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 5
 fun case_5(value_1: Int?) {
     if (case_5_1(value_1)) {
-        value_1.inv()
+        value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         if (case_5_2(value_1)) {
             value_1.inv()
             case_5_1(value_1)
@@ -254,7 +254,7 @@ fun case_5(value_1: Int?) {
         }
     }
     if (!case_5_3(value_1)) {
-        value_1.inv()
+        value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         if (!case_5_4(value_1)) {
             value_1.inv()
             case_5_1(value_1)
@@ -262,7 +262,7 @@ fun case_5(value_1: Int?) {
         }
     }
     if (case_5_5(value_1) != null) {
-        value_1.inv()
+        value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         if (case_5_6(value_1) != null) {
             value_1.inv()
             case_5_1(value_1)
@@ -270,7 +270,7 @@ fun case_5(value_1: Int?) {
         }
     }
     if (case_5_7(value_1) == null) {
-        value_1.inv()
+        value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         if (case_5_8(value_1) == null) {
             value_1.inv()
             case_5_1(value_1)
@@ -284,25 +284,25 @@ fun case_6(value_1: Number?) {
     when {
         case_6_1(value_1) -> {
             value_1.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
-            when { case_6_2(value_1) -> value_1.inv() }
+            when { case_6_2(value_1) -> value_1.<!UNRESOLVED_REFERENCE!>inv<!>() }
         }
     }
     when {
         !case_6_3(value_1) -> {
             value_1.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
-            when { !case_6_4(value_1) -> value_1.inv() }
+            when { !case_6_4(value_1) -> value_1.<!UNRESOLVED_REFERENCE!>inv<!>() }
         }
     }
     when {
         case_6_5(value_1) != null -> {
             value_1.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
-            when { case_6_6(value_1) != null -> value_1.inv() }
+            when { case_6_6(value_1) != null -> value_1.<!UNRESOLVED_REFERENCE!>inv<!>() }
         }
     }
     when {
         case_6_7(value_1) == null -> {
             value_1.<!INAPPLICABLE_CANDIDATE!>toByte<!>()
-            when { case_6_8(value_1) == null -> value_1.inv() }
+            when { case_6_8(value_1) == null -> value_1.<!UNRESOLVED_REFERENCE!>inv<!>() }
         }
     }
 }
@@ -333,28 +333,28 @@ fun case_8(value_1: Any?) {
         value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
         if (<!INAPPLICABLE_CANDIDATE!>case_8_2<!>(value_1)) {
             value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-            if (<!INAPPLICABLE_CANDIDATE!>case_8_3<!>(value_1)) value_1.inv()
+            if (<!INAPPLICABLE_CANDIDATE!>case_8_3<!>(value_1)) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
         }
     }
     if (!case_8_4(value_1)) {
         value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
         if (!<!INAPPLICABLE_CANDIDATE!>case_8_5<!>(value_1)) {
             value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-            if (!<!INAPPLICABLE_CANDIDATE!>case_8_6<!>(value_1)) value_1.inv()
+            if (!<!INAPPLICABLE_CANDIDATE!>case_8_6<!>(value_1)) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
         }
     }
     if (case_8_7(value_1) == null) {
         value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
         if (<!INAPPLICABLE_CANDIDATE!>case_8_8<!>(value_1) != null) {
             value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-            if (<!INAPPLICABLE_CANDIDATE!>case_8_9<!>(value_1) != null) value_1.inv()
+            if (<!INAPPLICABLE_CANDIDATE!>case_8_9<!>(value_1) != null) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
         }
     }
     if (case_8_10(value_1) != null) {
         value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>()
         if (<!INAPPLICABLE_CANDIDATE!>case_8_11<!>(value_1) == null) {
             value_1.<!UNRESOLVED_REFERENCE!>toByte<!>()
-            if (<!INAPPLICABLE_CANDIDATE!>case_8_12<!>(value_1) == null) value_1.inv()
+            if (<!INAPPLICABLE_CANDIDATE!>case_8_12<!>(value_1) == null) value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
         }
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/8.fir.kt

@@ -62,7 +62,7 @@ fun case_1(value_1: Any?) {
     <!AMBIGUITY!>println<!>(value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>())
     if (funWithReturnsTrue(value_1 !is Number)) {
         <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>toByte<!>())
-        if (funWithReturnsNotNull(value_1 is Int) == null) <!AMBIGUITY!>println<!>(value_1.inv())
+        if (funWithReturnsNotNull(value_1 is Int) == null) <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
     }
 }
 
@@ -72,7 +72,7 @@ fun case_2(value_1: Any?) {
         <!AMBIGUITY!>println<!>(value_1?.<!UNRESOLVED_REFERENCE!>toByte<!>())
         funWithReturns(value_1 !is Number)
         <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>toByte<!>())
-        if (funWithReturnsNull(value_1 !is Int) == null) <!AMBIGUITY!>println<!>(value_1.inv())
+        if (funWithReturnsNull(value_1 !is Int) == null) <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
     }
 }
 
@@ -91,7 +91,7 @@ fun case_3(value_1: Int?, value_2: Any?) {
 // TESTCASE NUMBER: 4
 fun case_4(value_1: Number, value_2: (() -> Unit)?) {
     if (contracts.case_4(value_1, value_2) == true) {
-        value_1.inv()
+        value_1.<!UNRESOLVED_REFERENCE!>inv<!>()
     } else if (contracts.case_4(value_1, value_2) == false) {
         println(value_2)
     } else if (contracts.case_4(value_1, value_2) == null) {
@@ -108,7 +108,7 @@ fun case_5(value_1: Number?, value_2: String?) {
         }
         false -> {
             println(value_2.<!INAPPLICABLE_CANDIDATE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_1.inv())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
         }
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg/9.fir.kt

@@ -4,13 +4,13 @@
 // TESTCASE NUMBER: 1
 fun case_1(arg: Int?) {
     funWithAtMostOnceCallsInPlace { arg!! }
-    arg.<!AMBIGUITY!>inc<!>()
+    arg.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 }
 
 // TESTCASE NUMBER: 2
 fun case_2(arg: Int?) {
     funWithUnknownCallsInPlace { arg!! }
-    arg.<!AMBIGUITY!>inc<!>()
+    arg.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 }
 
 // TESTCASE NUMBER: 3

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/11.fir.kt

@@ -51,8 +51,8 @@ class case_3 {
     fun case_3(value_1: Any?, value_2: Number?) {
         val o = case_3()
         contracts.case_3(value_1, value_2, o.prop_1, this.prop_1)
-        <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+        <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
-        <!AMBIGUITY!>println<!>(this.prop_1.<!AMBIGUITY!>plus<!>(3))
+        <!AMBIGUITY!>println<!>(this.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
     }
 }
 
@@ -62,8 +62,8 @@ class case_4 {
     fun case_4(value_1: Any?, value_2: Number?) {
         val o = case_4()
         if (contracts.case_4(value_1, value_2, o.prop_1, this.prop_1)) {
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
-            <!AMBIGUITY!>println<!>(this.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(this.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/12.fir.kt

@@ -10,7 +10,7 @@ fun case_1(arg: Int?) {
 // TESTCASE NUMBER: 2
 fun case_2(arg: Int?) {
     funWithAtLeastOnceCallsInPlace { arg!! }
-    arg.<!AMBIGUITY!>inc<!>()
+    arg.<!INAPPLICABLE_CANDIDATE!>inc<!>()
 }
 
 // TESTCASE NUMBER: 3

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/14.fir.kt

@@ -49,21 +49,21 @@ import contracts.*
 // TESTCASE NUMBER: 1
 fun case_1(value_1: Int?) {
     if (contracts.case_1(value_1)!!) {
-        value_1.inv()
+        value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
 // TESTCASE NUMBER: 2
 fun case_2(value_1: Int?) {
     if (!contracts.case_2(value_1)!!) {
-        value_1.inv()
+        value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
 // TESTCASE NUMBER: 3
 fun case_3(value_1: Int?) {
     if (contracts.case_3(value_1)!!) {
-        value_1.inv()
+        value_1.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/3.fir.kt

@@ -102,9 +102,9 @@ class case_3_class {
     fun case_3(value_1: Any?, value_2: Number?) {
         val o = case_3_class()
         contracts.case_3(value_1, value_2, o.prop_1, this.prop_1)
-        <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
         println(value_2?.toByte())
-        <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+        <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
     }
 }
 
@@ -154,24 +154,24 @@ class case_6_class {
     fun case_6(value_1: Any?, value_2: Number?) {
         val o = case_6_class()
         if (contracts.case_6_1(value_1, value_2, o.prop_1, this.prop_1)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (!contracts.case_6_2(value_1, value_2, o.prop_1, this.prop_1)) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (contracts.case_6_3(value_1, value_2, o.prop_1, this.prop_1) != null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
         if (contracts.case_6_4(value_1, value_2, o.prop_1, this.prop_1) == null) {
-            <!AMBIGUITY!>println<!>(value_1.<!AMBIGUITY!>dec<!>())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>dec<!>())
             println(value_2?.toByte())
-            <!AMBIGUITY!>println<!>(o.prop_1.<!AMBIGUITY!>plus<!>(3))
+            <!AMBIGUITY!>println<!>(o.prop_1.<!NONE_APPLICABLE!>plus<!>(3))
         }
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/5.fir.kt

@@ -91,13 +91,13 @@ fun case_1(value_1: Any?) {
 // TESTCASE NUMBER: 2
 fun case_2(value_1: Number?) {
     value_1.case_2()
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 3
 fun case_3(value_1: Any?) {
     value_1.case_3()
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 4
@@ -110,16 +110,16 @@ fun case_4(value_1: Any?, value_2: Any?, value_3: Any?) {
 
 // TESTCASE NUMBER: 5
 fun case_5(value_1: Number?, value_2: Number?, value_3: Number?) {
-    if (value_1.case_5_1()) <!AMBIGUITY!>println<!>(value_1.inv())
+    if (value_1.case_5_1()) <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (!value_2.case_5_2()) <!AMBIGUITY!>println<!>(value_2.inv())
+    if (!value_2.case_5_2()) <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_3.case_5_3() != null) <!AMBIGUITY!>println<!>(value_3.inv())
+    if (value_3.case_5_3() != null) <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_3.case_5_4() == null) <!AMBIGUITY!>println<!>(value_3.inv())
+    if (value_3.case_5_4() == null) <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 6
 fun case_6(value_1: Any?, value_2: Any?, value_3: Any?) {
-    if (value_1.case_6_1()) <!AMBIGUITY!>println<!>(value_1.inv())
+    if (value_1.case_6_1()) <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (!value_2.case_6_2()) <!AMBIGUITY!>println<!>(value_2.inv())
+    if (!value_2.case_6_2()) <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_3.case_6_3() != null) <!AMBIGUITY!>println<!>(value_3.inv())
+    if (value_3.case_6_3() != null) <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
-    if (value_3.case_6_4() == null) <!AMBIGUITY!>println<!>(value_3.inv())
+    if (value_3.case_6_4() == null) <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/6.fir.kt

@@ -110,27 +110,27 @@ import contracts.*
 fun case_1(value_1: Any?, value_2: Int?) {
     value_1.case_1(value_2)
     <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>length<!>)
-    <!AMBIGUITY!>println<!>(value_2.inv())
+    println(value_2.<!INAPPLICABLE_CANDIDATE!>inv<!>())
 }
 
 // TESTCASE NUMBER: 2
 fun case_2(value_1: Number?, value_2: Any?) {
     value_1.case_2(value_2)
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
     <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>toByte<!>())
 }
 
 // TESTCASE NUMBER: 3
 fun case_3(value_1: Any?, value_2: String?) {
     value_1.case_3(value_2)
-    <!AMBIGUITY!>println<!>(value_1.inv())
+    <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
     println(value_2.<!INAPPLICABLE_CANDIDATE!>length<!>)
 }
 
 // TESTCASE NUMBER: 4
 fun case_4(value_1: Any?, value_2: Number, value_3: Any?, value_4: String?) {
     value_1.case_4(value_2, value_3, value_4)
-    <!AMBIGUITY!>println<!>(value_2.inv())
+    <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>())
     <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>toByte<!>())
     println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>)
 }
@@ -140,25 +140,25 @@ fun case_5(value_1: Any?, value_2: Int?, value_3: Any?, value_4: Int?, value_5:
     when {
         value_1.case_5_1(value_2) -> {
             <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_2.inv())
+            println(value_2.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
     when {
         !value_3.case_5_2(value_4) -> {
             <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_4.inv())
+            println(value_4.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
     when {
         value_5.case_5_3(value_6) != null -> {
             <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_6.inv())
+            println(value_6.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
     when {
         value_5.case_5_4(value_6) == null -> {
             <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>length<!>)
-            <!AMBIGUITY!>println<!>(value_6.inv())
+            println(value_6.<!INAPPLICABLE_CANDIDATE!>inv<!>())
         }
     }
 }
@@ -166,19 +166,19 @@ fun case_5(value_1: Any?, value_2: Int?, value_3: Any?, value_4: Int?, value_5:
 // TESTCASE NUMBER: 6
 fun case_6(value_1: Number?, value_2: Any?, value_3: Number?, value_4: Any?, value_5: Number?, value_6: Any?) {
     if (value_1.case_6_1(value_2)) {
-        <!AMBIGUITY!>println<!>(value_1.inv())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
         <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (!value_3.case_6_2(value_4)) {
-        <!AMBIGUITY!>println<!>(value_3.inv())
+        <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
         <!AMBIGUITY!>println<!>(value_4.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (value_5.case_6_3(value_6) != null) {
-        <!AMBIGUITY!>println<!>(value_5.inv())
+        <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>inv<!>())
         <!AMBIGUITY!>println<!>(value_6.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
     if (value_5.case_6_4(value_6) == null) {
-        <!AMBIGUITY!>println<!>(value_5.inv())
+        <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>inv<!>())
         <!AMBIGUITY!>println<!>(value_6.<!UNRESOLVED_REFERENCE!>toByte<!>())
     }
 }
@@ -186,35 +186,35 @@ fun case_6(value_1: Number?, value_2: Any?, value_3: Number?, value_4: Any?, val
 // TESTCASE NUMBER: 7
 fun case_7(value_1: Any?, value_2: String?, value_3: Any?, value_4: String?, value_5: Any?, value_6: String?) {
     if (value_1.case_7_1(value_2)) {
-        <!AMBIGUITY!>println<!>(value_1.inv())
+        <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
         println(value_2.<!INAPPLICABLE_CANDIDATE!>length<!>)
     }
     if (value_3.case_7_2(value_4)) {
-        <!AMBIGUITY!>println<!>(value_3.inv())
+        <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>inv<!>())
         println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>)
     }
     if (value_5.case_7_3(value_6) != null) {
-        <!AMBIGUITY!>println<!>(value_5.inv())
+        <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>inv<!>())
         println(value_6.<!INAPPLICABLE_CANDIDATE!>length<!>)
     }
     if (value_5.case_7_4(value_6) == null) {
-        <!AMBIGUITY!>println<!>(value_5.inv())
+        <!AMBIGUITY!>println<!>(value_5.<!UNRESOLVED_REFERENCE!>inv<!>())
         println(value_6.<!INAPPLICABLE_CANDIDATE!>length<!>)
     }
 }
 
 // TESTCASE NUMBER: 8
 fun case_8(value_1: Any?, value_2: Number, value_3: Any?, value_4: String?, value_5: Any?, value_6: Number, value_7: Any?, value_8: String?) {
-    when { value_1.case_8_1(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_2.inv()) }
+    when { value_1.case_8_1(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_2.<!UNRESOLVED_REFERENCE!>inv<!>()) }
     when { value_1.case_8_1(value_2, value_3, value_4) -> <!AMBIGUITY!>println<!>(value_3.<!UNRESOLVED_REFERENCE!>toByte<!>()) }
     when { value_1.case_8_1(value_2, value_3, value_4) -> println(value_4.<!INAPPLICABLE_CANDIDATE!>length<!>) }
-    when { !value_5.case_8_2(value_6, value_7, value_8) -> <!AMBIGUITY!>println<!>(value_6.inv()) }
+    when { !value_5.case_8_2(value_6, value_7, value_8) -> <!AMBIGUITY!>println<!>(value_6.<!UNRESOLVED_REFERENCE!>inv<!>()) }
     when { !value_5.case_8_2(value_6, value_7, value_8) -> <!AMBIGUITY!>println<!>(value_7.<!UNRESOLVED_REFERENCE!>toByte<!>()) }
     when { !value_5.case_8_2(value_6, value_7, value_8) -> println(value_8.<!INAPPLICABLE_CANDIDATE!>length<!>) }
-    when { value_5.case_8_3(value_6, value_7, value_8) != null -> <!AMBIGUITY!>println<!>(value_6.inv()) }
+    when { value_5.case_8_3(value_6, value_7, value_8) != null -> <!AMBIGUITY!>println<!>(value_6.<!UNRESOLVED_REFERENCE!>inv<!>()) }
     when { value_5.case_8_3(value_6, value_7, value_8) != null -> <!AMBIGUITY!>println<!>(value_7.<!UNRESOLVED_REFERENCE!>toByte<!>()) }
     when { value_5.case_8_3(value_6, value_7, value_8) != null -> println(value_8.<!INAPPLICABLE_CANDIDATE!>length<!>) }
-    when { value_5.case_8_4(value_6, value_7, value_8) == null -> <!AMBIGUITY!>println<!>(value_6.inv()) }
+    when { value_5.case_8_4(value_6, value_7, value_8) == null -> <!AMBIGUITY!>println<!>(value_6.<!UNRESOLVED_REFERENCE!>inv<!>()) }
     when { value_5.case_8_4(value_6, value_7, value_8) == null -> <!AMBIGUITY!>println<!>(value_7.<!UNRESOLVED_REFERENCE!>toByte<!>()) }
     when { value_5.case_8_4(value_6, value_7, value_8) == null -> println(value_8.<!INAPPLICABLE_CANDIDATE!>length<!>) }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos/8.fir.kt

@@ -133,7 +133,7 @@ fun case_6(value_1: Number, value_2: String?, value_3: Any?) {
             println(value_2.<!INAPPLICABLE_CANDIDATE!>length<!>)
         }
         null -> {
-            <!AMBIGUITY!>println<!>(value_1.inv())
+            <!AMBIGUITY!>println<!>(value_1.<!UNRESOLVED_REFERENCE!>inv<!>())
         }
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/10.fir.kt

@@ -13,5 +13,5 @@ fun case_1() {
     }
 
     <!DEBUG_INFO_EXPRESSION_TYPE("ClassLevel2 & kotlin.Any?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("ClassLevel2 & kotlin.Any?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("ClassLevel2 & kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
 }

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/14.fir.kt

@@ -6,7 +6,7 @@
 fun case_1(x: Int?) {
     if ((x is Int) ?: (x is Int)) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -14,7 +14,7 @@ fun case_1(x: Int?) {
 fun case_2(x: Int?) {
     if (x?.equals(1) ?: x is Int) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/16.fir.kt

@@ -11,7 +11,7 @@ fun case_1(x: ClassWithCustomEquals) {
     val y = null
     if (x == y) {
         <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -19,7 +19,7 @@ fun case_1(x: ClassWithCustomEquals) {
 fun case_2(x: ClassWithCustomEquals) {
     if (x == null) {
         <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -31,7 +31,7 @@ fun case_2(x: ClassWithCustomEquals) {
 fun case_3(x: ClassWithCustomEquals, y: Nothing?) {
     if (x == y) {
         <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -44,7 +44,7 @@ fun case_4(x: ClassWithCustomEquals) {
     val y = null
     if (y == x) {
         <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -56,7 +56,7 @@ fun case_4(x: ClassWithCustomEquals) {
 fun case_5(x: ClassWithCustomEquals, y: Nothing?) {
     if (y == x) {
         <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -69,7 +69,7 @@ fun case_6(x: ClassWithCustomEquals) {
     val y = null
     if (x == y == true) {
         <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -77,7 +77,7 @@ fun case_6(x: ClassWithCustomEquals) {
 fun case_7(x: ClassWithCustomEquals) {
     if ((x != null) == false) {
         <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -89,7 +89,7 @@ fun case_7(x: ClassWithCustomEquals) {
 fun case_8(x: ClassWithCustomEquals, y: Nothing?) {
     if (!(y == x) == false) {
         <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("ClassWithCustomEquals")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/21.fir.kt

@@ -16,7 +16,7 @@ class Case1 {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
             this.x
             y.x
-            y.x.inv()
+            y.x.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         } else {
             x = 10
         }

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/39.fir.kt

@@ -27,7 +27,7 @@ fun case_2(y: MutableList<Int>) {
         y[x ?: break] = 10
     }
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 /*
@@ -41,7 +41,7 @@ fun case_3(y: MutableList<Int>) {
         y[0] = x ?: break
     }
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 4
@@ -51,7 +51,7 @@ fun case_4() {
         x ?: break
     }
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 5
@@ -96,7 +96,7 @@ fun case_8() {
         y += x ?: break
     }
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 /*
@@ -111,7 +111,7 @@ fun case_9() {
         y -= x ?: break
     }
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 /*
@@ -126,7 +126,7 @@ fun case_10() {
         val z = y - (x ?: break)
     }
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 /*
@@ -141,7 +141,7 @@ fun case_11() {
         val z = y * (x ?: break)
     }
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 12
@@ -152,7 +152,7 @@ fun case_12() {
         y += if (x == null) break else 10
     }
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 13

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/4.fir.kt

@@ -6,7 +6,7 @@
 fun case_1(x: Any?) {
     if (x is Int is Boolean) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>not<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
@@ -17,7 +17,7 @@ fun case_1(x: Any?) {
 fun case_2(x: Any?) {
     if (x is Int is Any? is Boolean) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>not<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
@@ -28,7 +28,7 @@ fun case_2(x: Any?) {
 inline fun <reified T>case_3(x: Any?) {
     if (x is Int is T) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
     }
@@ -38,7 +38,7 @@ inline fun <reified T>case_3(x: Any?) {
 inline fun <reified T : Boolean>case_4(x: Any?) {
     if (x is Int is T == null) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
     }
@@ -48,7 +48,7 @@ inline fun <reified T : Boolean>case_4(x: Any?) {
 fun case_5(x: Any?) {
     if (x is Int != null) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
     }
@@ -58,7 +58,7 @@ fun case_5(x: Any?) {
 fun case_6(x: Any?) {
     if (x is Int == null) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
     }
@@ -68,7 +68,7 @@ fun case_6(x: Any?) {
 fun case_7(x: Any?) {
     if (!(x !is Int) == false) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
     }
@@ -78,7 +78,7 @@ fun case_7(x: Any?) {
 fun case_8(x: Any?) {
     if (!(x !is Int) == true) else {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
     }
@@ -88,7 +88,7 @@ fun case_8(x: Any?) {
 fun case_9(x: Any?) {
     if (x !is Int !is Any?) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>propAny<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>funAny<!>()
     }

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/42.fir.kt

@@ -153,7 +153,7 @@ fun case_14(x: Any) {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float & kotlin.Any")!>x<!>.<!UNRESOLVED_REFERENCE!>NaN<!>
         } else {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number & kotlin.Comparable<kotlin.Int & kotlin.Float> & kotlin.Any")!>x<!>
-            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number & kotlin.Comparable<kotlin.Int & kotlin.Float> & kotlin.Any")!>x<!>.inv()
+            <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number & kotlin.Comparable<kotlin.Int & kotlin.Float> & kotlin.Any")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         }
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/43.fir.kt

@@ -14,7 +14,7 @@ fun case_1(x: Double?, y: Double?) : Double {
     } else if (x == null && y != null) {
         y
     } else {
-        x <!AMBIGUITY!>+<!> y
+        x <!NONE_APPLICABLE!>+<!> y
     }
 }
 

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/6.fir.kt

@@ -6,7 +6,7 @@
 fun case_1(x: Any?) {
     if (x is Int || x !is Int) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -64,7 +64,7 @@ fun case_7(x: Any) {
 fun case_8(x: Any?) {
     if (x is Int? == x is Int?) else {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>?.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>?.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 

compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg/7.fir.kt

@@ -6,7 +6,7 @@
 fun case_1(x: Int?) {
     if ((x is Int) ?: (x is Int)) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -14,7 +14,7 @@ fun case_1(x: Int?) {
 fun case_2(x: Int?) {
     if (x?.equals(1) ?: x is Int) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 

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

@@ -95,7 +95,7 @@ fun case_7(x: Class?) {
 fun case_8(x: Int?) {
     if (false || false || false || x == nullableNothingProperty) return
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 9

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

@@ -94,7 +94,7 @@ fun case_7(x: Class?) {
 fun case_8(x: Int?) {
     if (false || false || false || x == nullableNothingProperty) throw Exception()
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 9

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

@@ -109,7 +109,7 @@ fun case_8(x: Int?) {
     for (i in 0..10) {
         if (false || false || false || x == nullableNothingProperty) continue
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -118,7 +118,7 @@ fun case_9(list: List<Int?>) {
     for (element in list) {
         if (element != implicitNullableNothingProperty && true && true && true) else { break }
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>element<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>element<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>element<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -205,9 +205,9 @@ fun case_15(map: MutableMap<Int?, Int?>, y: Nothing?) {
         if (k != y) else break
         if (v != y) else continue
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>k<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>k<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>k<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>v<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>v<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>v<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -216,9 +216,9 @@ fun case_16(map: Map<Int?, Int?>) {
     for ((k, v) in map) {
         if (k !== implicitNullableNothingProperty && v !== implicitNullableNothingProperty) else { continue }
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>k<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>k<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>k<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>v<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>v<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>v<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 

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

@@ -6,7 +6,7 @@
 fun case_1(x: Any?) {
     if (x is Int || false) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -70,7 +70,7 @@ fun case_7(x: Any) {
 fun case_8(x: Any?) {
     if (!(x is Int?) && true) else {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>?.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?")!>x<!>?.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 

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

@@ -86,5 +86,5 @@ fun case_6() {
     }
 
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?"), UNINITIALIZED_VARIABLE!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?"), UNINITIALIZED_VARIABLE!>x<!>.<!AMBIGUITY!>minus<!>(10.0)
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any?"), UNINITIALIZED_VARIABLE!>x<!>.<!INAPPLICABLE_CANDIDATE!>minus<!>(10.0)
 }

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

@@ -12,7 +12,7 @@ fun case_1(x: Number?) {
 
     if (x == y) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -47,7 +47,7 @@ fun case_4() {
 
     if (x == y) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number?")!>x<!>?.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number?")!>x<!>?.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -59,6 +59,6 @@ fun case_4() {
 fun case_5(x: Class, y: Class) {
     if (x.prop_14 == y.prop_15) {
         x.prop_14
-        x.prop_14.inv()
+        x.prop_14.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }

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

@@ -13,7 +13,7 @@ import kotlin.reflect.*
 fun case_1(x: Int?) {
     if (x != funNothingQuest() == true) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -26,7 +26,7 @@ fun case_2(x: Int?) {
     operator fun Nothing?.not() = null
     if (x != !null != false) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -50,7 +50,7 @@ fun case_3(x: Int?) {
 fun case_4(x: Int?, y: List<Nothing?>) {
     if (x == y[0] == true) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -66,7 +66,7 @@ fun case_5(x: Int?) {
 
     if (x == y.z == true) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -80,7 +80,7 @@ fun case_6(x: Int?) {
 
     if (x == y == true) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 
@@ -97,7 +97,7 @@ fun case_7(x: Int?) {
 
     if (x == y.z == true) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }
 

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

@@ -6,7 +6,7 @@
 fun case_1(x: Any?) {
     if (x!! is Int) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any & kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -14,14 +14,14 @@ fun case_1(x: Any?) {
 fun case_2(x: Any?) {
     (x as Nothing?)!!
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing? & kotlin.Any?")!>x<!>
-    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing? & kotlin.Any?")!>x<!>.inv()
+    <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing? & kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
 }
 
 // TESTCASE NUMBER: 3
 fun case_3(x: Any?) {
     if (x as Number? is Int) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Any?")!>x<!>.<!UNRESOLVED_REFERENCE!>inv<!>()
     }
 }
 
@@ -37,7 +37,7 @@ fun case_4(x: Any?) {
 fun case_5(x: Any?) {
     if (x as Nothing? is Nothing) {
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing? & kotlin.Any?")!>x<!>
-        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing? & kotlin.Any?")!>x<!>.inv()
+        <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing? & kotlin.Any?")!>x<!>.<!INAPPLICABLE_CANDIDATE!>inv<!>()
     }
 }