[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/fir/analysis-tests/testData/resolve/problems/invalidCode.kt

@@ -35,7 +35,7 @@ package d
 interface I {
     fun <T
             > f<!SYNTAX!><!> = <!TOO_MANY_ARGUMENTS!>C<!>(
-        <!SYNTAX!><!SYNTAX!><!>.<!><!TOO_MANY_ARGUMENTS!>f<!><!SYNTAX!><!>
+        <!SYNTAX!><!SYNTAX!><!>.<!><!INFIX_MODIFIER_REQUIRED, TOO_MANY_ARGUMENTS!>f<!><!SYNTAX!><!>
     class C : I<!SYNTAX!><!>
 
 // FILE: e.kt

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt

@@ -259,9 +259,7 @@ private fun mapInapplicableCandidateError(
 ): List<KtDiagnostic> {
     val typeContext = session.typeContext
     val genericDiagnostic = FirErrors.INAPPLICABLE_CANDIDATE.createOn(source, diagnostic.candidate.symbol)
-    val diagnostics = diagnostic.candidate.diagnostics.filter {
+    val diagnostics = diagnostic.candidate.diagnostics.filter { !it.applicability.isSuccess }.mapNotNull { rootCause ->
-        it.applicability.userRelevantApplicability == diagnostic.applicability.userRelevantApplicability
-    }.mapNotNull { rootCause ->
         when (rootCause) {
             is VarargArgumentOutsideParentheses -> FirErrors.VARARG_OUTSIDE_PARENTHESES.createOn(
                 rootCause.argument.source ?: qualifiedAccessSource
@@ -370,12 +368,6 @@ private fun mapInapplicableCandidateError(
     }
 }
 
-private val CandidateApplicability.userRelevantApplicability: CandidateApplicability
-    get() = when (this) {
-        CandidateApplicability.INAPPLICABLE_ARGUMENTS_MAPPING_ERROR -> CandidateApplicability.INAPPLICABLE
-        else -> this
-    }
-
 private fun mapSystemHasContradictionError(
     session: FirSession,
     diagnostic: ConeConstraintSystemHasContradiction,

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<!UNSAFE_CALL!>.<!>foo(b<!UNSAFE_CALL!>.<!>foo(<!ARGUMENT_TYPE_MISMATCH!>c<!>))
-    a!!.foo(b<!UNSAFE_CALL!>.<!>foo(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<!>)
+    <!OPERATOR_MODIFIER_REQUIRED!>identifier<!>(<!TOO_MANY_ARGUMENTS!>123<!>)
-    identifier(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
+    <!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>() }

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

@@ -36,6 +36,6 @@ operator fun Int.invoke(y: Int, z: Int) {}
 fun test5() {
     var x: Int? = 10
     x!!
-    <!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!>(if (true) { x = null; 0 } else 0, x)
+    <!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!>(if (true) { x = null; 0 } else 0, <!ARGUMENT_TYPE_MISMATCH!>x<!>)
     x<!UNSAFE_CALL!>.<!>inv()
 }

compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos/2.1.fir.kt

@@ -74,7 +74,7 @@ fun case3() {
  */
 fun case4(marker : Marker?) {
     marker?.<!DEBUG_INFO_CALL("fqName: libPackage.Marker.foo; typeCall: function")!>foo(y=1)<!>
-    marker?.<!DEBUG_INFO_CALL("fqName: libPackage.Marker.invoke; typeCall: variable&invoke")!>foo(x=1)<!>><!SYNTAX!><!>
+    marker?.<!DEBUG_INFO_CALL("fqName: libPackage.Marker.invoke; typeCall: variable&invoke")!>foo(x=1)<!><!OPERATOR_MODIFIER_REQUIRED!>><!><!SYNTAX!><!>
 }
 
 

compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos/2.1.fir.kt

@@ -74,7 +74,7 @@ fun case3() {
  */
 fun case4(marker: Marker?) {
     marker?.<!DEBUG_INFO_CALL("fqName: libPackage.Marker.foo; typeCall: function")!>foo(y = { 1 })<!>
-    marker?.<!DEBUG_INFO_CALL("fqName: libPackage.Marker.invoke; typeCall: variable&invoke")!>foo(x = { 1 })<!>><!SYNTAX!><!>
+    marker?.<!DEBUG_INFO_CALL("fqName: libPackage.Marker.invoke; typeCall: variable&invoke")!>foo(x = { 1 })<!><!OPERATOR_MODIFIER_REQUIRED!>><!><!SYNTAX!><!>
 }
 
 

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

@@ -387,7 +387,7 @@ fun case_22(a: (() -> Unit)?) {
 // TESTCASE NUMBER: 23
 fun case_23(a: ((Float) -> Int?)?, b: Float?) {
     if (<!EQUALITY_NOT_APPLICABLE!>a != null !is Boolean<!> && <!FORBIDDEN_IDENTITY_EQUALS!>b !== null is Boolean<!>) {
-        val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!><!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float?")!>b<!>)<!>
+        val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!><!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float?")!>b<!>)<!>
         if (x != null) {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.equals(null)
@@ -406,8 +406,8 @@ fun case_23(a: ((Float) -> Int?)?, b: Float?) {
 // TESTCASE NUMBER: 24
 fun case_24(a: ((() -> Unit) -> Unit)?, b: (() -> Unit)?) =
     if (<!FORBIDDEN_IDENTITY_EQUALS!>a !== null is Boolean<!> && <!FORBIDDEN_IDENTITY_EQUALS!>b !== null !is Boolean<!>) {
-        <!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>?")!>b<!>)
+        <!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>?")!>b<!>)
-        <!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(b)
+        <!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!ARGUMENT_TYPE_MISMATCH!>b<!>)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>?")!>b<!><!UNSAFE_CALL!>.<!>equals(null)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>?")!>b<!>.propT
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>?")!>b<!><!UNSAFE_CALL!>.<!>propAny
@@ -450,7 +450,7 @@ fun case_25(b: Boolean) {
 // TESTCASE NUMBER: 26
 fun case_26(a: ((Float) -> Int?)?, b: Float?) {
     if (a != null == true == false && b != null == true == false) {
-        val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!><!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Nothing?")!>b<!>)<!>
+        val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!><!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Nothing?")!>b<!>)<!>
         if (<!DEPRECATED_IDENTITY_EQUALS!>x != null == true === false<!>) {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Nothing?")!>x<!>
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Nothing?")!>x<!>.equals(null)

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

@@ -24,7 +24,7 @@ fun case_1(x: Class?) {
 fun case_2() {
     var x: Class? = <!INITIALIZER_TYPE_MISMATCH!>10<!>
     x!!
-    x(if (true) {x=null;0} else 0, <!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>)
+    <!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!>(if (true) {x=null;0} else 0, <!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>)
     <!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>
     <!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!><!UNSAFE_CALL!>.<!>fun_1()
 }

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

@@ -62,7 +62,7 @@ fun case_4() {
 fun case_5() {
     var x: Class? = Class()
     x!!
-    x(if (true) {x=null;0} else 0, <!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>)
+    <!UNSAFE_IMPLICIT_INVOKE_CALL!>x<!>(if (true) {x=null;0} else 0, <!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!>)
     <!DEBUG_INFO_EXPRESSION_TYPE("Class?")!>x<!><!UNSAFE_CALL!>.<!>fun_1()
 }
 

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

@@ -95,7 +95,7 @@ fun case_3(b: Boolean) {
 // TESTCASE NUMBER: 4
 fun case_4(a: ((Float) -> Int?)?, b: Float?) {
     if (a != null == true && b != null == true || false || false || false || false || false || false || false || false || false) {
-        val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!><!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float?")!>b<!>)<!>
+        val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!><!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float?")!>b<!>)<!>
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<kotlin.Float, kotlin.Int?>?")!>a<!><!UNSAFE_CALL!>.<!>equals(null)
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<kotlin.Float, kotlin.Int?>?")!>a<!>.propT
         <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function1<kotlin.Float, kotlin.Int?>?")!>a<!><!UNSAFE_CALL!>.<!>propAny

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

@@ -603,7 +603,7 @@ fun case_29(x: Boolean) {
 // TESTCASE NUMBER: 30
 fun case_30(a: ((Float) -> Int?)?, b: Float?) {
     if (implicitNullableNothingProperty != a == true && b != implicitNullableNothingProperty == true || false || false || false || false || false || false || false || false || false) {
-        val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!><!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float?")!>b<!>)<!>
+        val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!><!UNSAFE_IMPLICIT_INVOKE_CALL!>a<!>(<!ARGUMENT_TYPE_MISMATCH, DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float?")!>b<!>)<!>
         if (false || implicitNullableNothingProperty != x == true) {
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!>
             <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>x<!><!UNSAFE_CALL!>.<!>equals(null)

plugins/assign-plugin/testData/diagnostics/otherOperators.fir.diag.txt

@@ -22,10 +22,14 @@
 
 /otherOperators.fir.kt:(1057,1066): error: No 'set' operator method providing array access.
 
+/otherOperators.fir.kt:(1117,1130): error: 'operator' modifier is required on 'FirNamedFunctionSymbol /StringProperty.get' in 'get'.
+
 /otherOperators.fir.kt:(1128,1129): error: Too many arguments for 'public final fun /StringProperty.get(): kotlin/String'.
 
 /otherOperators.fir.kt:(1131,1133): error: Unresolved reference '+='.
 
+/otherOperators.fir.kt:(1161,1179): error: 'operator' modifier is required on 'FirNamedFunctionSymbol /StringProperty.get' in 'get'.
+
 /otherOperators.fir.kt:(1177,1178): error: Too many arguments for 'public final fun /StringProperty.get(): kotlin/String'.
 
 /otherOperators.fir.kt:(1180,1182): error: Unresolved reference '+='.

plugins/assign-plugin/testData/diagnostics/otherOperators.fir.kt

@@ -42,8 +42,8 @@ fun `should not effect error reporting for other operators`() {
     nullTask?.input<!NO_SET_METHOD!>[0, 0, 0]<!> = StringProperty("Fail")
 
     // a?.b[c] += d
-    task.input[<!TOO_MANY_ARGUMENTS!>0<!>] <!UNRESOLVED_REFERENCE!>+=<!> StringProperty("Fail")
+    <!OPERATOR_MODIFIER_REQUIRED!>task.input[<!TOO_MANY_ARGUMENTS!>0<!>]<!> <!UNRESOLVED_REFERENCE!>+=<!> StringProperty("Fail")
-    nullTask?.input[<!TOO_MANY_ARGUMENTS!>0<!>] <!UNRESOLVED_REFERENCE!>+=<!> StringProperty("Fail")
+    <!OPERATOR_MODIFIER_REQUIRED!>nullTask?.input[<!TOO_MANY_ARGUMENTS!>0<!>]<!> <!UNRESOLVED_REFERENCE!>+=<!> StringProperty("Fail")
 
     // a[i] = b should not be translated to a.get(i).assign(b)
     operator fun Task.get(i: Int) = this.input