[FIR] Remove the applicability filtering when reporting diagnostics

In case we don't want to introduce any new
abstractions like "user relevance for
applicability", we can just remove the
filtering.

^KT-62541 Fixed

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

@@ -34,7 +34,7 @@ fun test() {
     bar<Int>()
     bar<<!UPPER_BOUND_VIOLATED!>Double?<!>>()
     bar<<!UPPER_BOUND_VIOLATED!>Double<!>>()
-    1.buzz<<!UPPER_BOUND_VIOLATED!>Double<!>>()
+    1.<!INAPPLICABLE_CANDIDATE!>buzz<!><<!UPPER_BOUND_VIOLATED!>Double<!>>()
 }
 
 fun <T : Any> foo() {}

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

@@ -40,7 +40,7 @@ fun test5() {
 fun <R: Any> R?.sure() : R = this!!
 
 fun <T> test6(l: List<T>?) {
-    l.sure<<!UPPER_BOUND_VIOLATED!>T<!>>()
+    l.<!INAPPLICABLE_CANDIDATE!>sure<!><<!UPPER_BOUND_VIOLATED!>T<!>>()
 }
 
 

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

@@ -13,6 +13,6 @@ fun <F : String?> bar(x: F) {
     foo1<<!UPPER_BOUND_VIOLATED!>F<!>>(<!ARGUMENT_TYPE_MISMATCH!>x<!>)
 
     x<!UNSAFE_CALL!>.<!>foo2()
-    x.foo2<<!UPPER_BOUND_VIOLATED!>F<!>>()
+    x.<!INAPPLICABLE_CANDIDATE!>foo2<!><<!UPPER_BOUND_VIOLATED!>F<!>>()
 }
 

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

@@ -9,4 +9,4 @@ fun <T, Q> List<T>.map1(f: (T)-> Q): List<T>? = tail!!.map1(f)
 
 fun <T, Q> List<T>.map2(f: (T)-> Q): List<T>? = tail.sure().map2(f)
 
-fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = tail.sure<<!UPPER_BOUND_VIOLATED!>T<!>>().<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>map3<!>(f)
+fun <T, Q> List<T>.map3(f: (T)-> Q): List<T>? = tail.<!INAPPLICABLE_CANDIDATE!>sure<!><<!UPPER_BOUND_VIOLATED!>T<!>>().<!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>map3<!>(f)

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

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

compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt

@@ -1,3 +1,3 @@
 //KT-13330 AssertionError: Illegal resolved call to variable with invoke
 
-fun foo(exec: (String.() -> Unit)?) = "".<!INAPPLICABLE_CANDIDATE!>exec<!><<!UNRESOLVED_REFERENCE!>caret<!>>() // <caret> is test data tag here
+fun foo(exec: (String.() -> Unit)?) = "".<!UNSAFE_IMPLICIT_INVOKE_CALL!>exec<!><<!UNRESOLVED_REFERENCE!>caret<!>>() // <caret> is test data tag here

compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt

@@ -8,6 +8,6 @@ class SomeClass
 fun test(identifier: SomeClass, fn: String.() -> Unit) {
     <!NONE_APPLICABLE!>identifier<!>()
     <!NONE_APPLICABLE!>identifier<!>(123)
-    identifier(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
+    <!OPERATOR_MODIFIER_REQUIRED!>identifier<!>(<!ARGUMENT_TYPE_MISMATCH!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
     <!ARGUMENT_TYPE_MISMATCH!>1<!>.fn()
 }

compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt

@@ -11,7 +11,7 @@ fun test(a: A) {
     <!UNSAFE_IMPLICIT_INVOKE_CALL!>(a.x)<!>("")
 
     with("") {
-        a.x<!NO_VALUE_FOR_PARAMETER!>()<!>
+        a.<!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!><!NO_VALUE_FOR_PARAMETER!>()<!>
         <!UNSAFE_IMPLICIT_INVOKE_CALL!>(a.x)<!>()
         if (a.x != null) {
             a.x<!NO_VALUE_FOR_PARAMETER!>()<!> // todo

compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt

@@ -6,7 +6,7 @@ class SomeClass
 
 fun test(identifier: SomeClass, fn: String.() -> Unit) {
     <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>identifier<!>()
-    identifier(<!TOO_MANY_ARGUMENTS!>123<!>)
-    identifier(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
+    <!OPERATOR_MODIFIER_REQUIRED!>identifier<!>(<!TOO_MANY_ARGUMENTS!>123<!>)
+    <!OPERATOR_MODIFIER_REQUIRED!>identifier<!>(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
     <!ARGUMENT_TYPE_MISMATCH!>1<!>.fn()
 }

compiler/testData/diagnostics/tests/resolve/propertyInCompanionOfEnum.fir.kt

@@ -33,7 +33,7 @@ fun foo() {
 import test.E as U
 
 fun bar() {
-    U.Entry checkType { _<<!UNRESOLVED_REFERENCE!>E<!>>() }
+    U.Entry checkType { <!INAPPLICABLE_CANDIDATE!>_<!><<!UNRESOLVED_REFERENCE!>E<!>>() }
     U.Entry checkType { <!UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><String>() }
     U.Companion.Entry checkType { _<String>() }
     U.NotEntry checkType { _<String>() }