[FIR] Add utility for checking if FirReference is one of error reference

Also simplify relevant code in checkers

compiler/fir/checkers/checkers.native/src/org/jetbrains/kotlin/fir/analysis/native/checkers/FirNativeThrowsChecker.kt

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
+import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
 import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
@@ -142,10 +143,8 @@ object FirNativeThrowsChecker : FirBasicDeclarationChecker() {
             return expression.hasUnresolvedArgument()
         }
 
-        if (this is FirResolvable) {
+        if (this is FirResolvable && calleeReference.isError()) {
-            when (this.calleeReference) {
+            return true
-                is FirErrorNamedReference, is FirResolvedErrorReference -> return true
-            }
         }
 
         if (this is FirVarargArgumentsExpression) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirConstChecks.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
@@ -30,11 +31,8 @@ internal fun checkConstantArguments(
     expression: FirExpression,
     session: FirSession,
 ): ConstantArgumentKind? {
-    val expressionSymbol = expression.toResolvedCallableReference()
+    val expressionSymbol = expression.toReference()?.toResolvedCallableSymbol(discardErrorReference = true)
-        ?.takeUnless { it is FirResolvedErrorReference }
+    val classKindOfParent = (expressionSymbol?.getReferencedClassSymbol(session) as? FirRegularClassSymbol)?.classKind
-        ?.resolvedSymbol as? FirCallableSymbol<*>
-    val classKindOfParent = (expressionSymbol?.getReferencedClassSymbol(session) as? FirRegularClassSymbol)
-        ?.classKind
 
     when {
         expression is FirNamedArgumentExpression -> {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt

@@ -13,9 +13,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
+import org.jetbrains.kotlin.fir.references.*
-import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
-import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
@@ -94,12 +92,9 @@ object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() {
         return null
     }
 
+    @OptIn(SymbolInternals::class)
     private fun FirConstructor.getDelegated(): FirConstructor? {
         this.symbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
-        val delegatedConstructorSymbol = (delegatedConstructor?.calleeReference as? FirResolvedNamedReference)
+        return delegatedConstructor?.calleeReference?.toResolvedConstructorSymbol(discardErrorReference = true)?.fir
-            .takeUnless { it is FirResolvedErrorReference }
-            ?.resolvedSymbol
-        @OptIn(SymbolInternals::class)
-        return delegatedConstructorSymbol?.fir as? FirConstructor
     }
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDelegatedPropertyChecker.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall
 import org.jetbrains.kotlin.fir.expressions.arguments
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
+import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.*
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -65,11 +66,7 @@ object FirDelegatedPropertyChecker : FirPropertyChecker() {
              */
             private fun checkFunctionReferenceErrors(functionCall: FirFunctionCall): Boolean {
                 val reference = functionCall.calleeReference
-                val diagnostic = when (reference) {
+                val diagnostic = if (reference.isError()) reference.diagnostic else return false
-                    is FirErrorNamedReference -> reference.diagnostic
-                    is FirResolvedErrorReference -> reference.diagnostic
-                    else -> return false
-                }
                 if (reference.source?.kind != KtFakeSourceElementKind.DelegatedPropertyAccessor) return false
                 val expectedFunctionSignature =
                     (if (isGet) "getValue" else "setValue") + "(${functionCall.arguments.joinToString(", ") { it.typeRef.coneType.renderReadable() }})"

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
+import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.references.toResolvedVariableSymbol
 import org.jetbrains.kotlin.fir.resolve.diagnostics.*
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
@@ -71,11 +72,8 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
                 else -> null
             } ?: return
 
-        val diagnostic = when (val reference = componentCall.calleeReference) {
+        val reference = componentCall.calleeReference
-            is FirErrorNamedReference -> reference.diagnostic
+        val diagnostic = if (reference.isError()) reference.diagnostic else null
-            is FirResolvedErrorReference -> reference.diagnostic
-            else -> null
-        }
         if (diagnostic != null) {
             checkComponentCall(
                 originalDestructuringDeclarationOrInitializerSource,
@@ -88,7 +86,6 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
                 context
             )
         }
-
     }
 
     private fun checkInitializer(

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirForLoopChecker.kt

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.resolve.calls.UnsafeCall
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError
@@ -105,9 +106,10 @@ object FirForLoopChecker : FirBlockChecker() {
         noneApplicableFactory: KtDiagnosticFactory1<Collection<FirBasedSymbol<*>>>? = null,
         unsafeCallFactory: KtDiagnosticFactory0? = null,
     ): Boolean {
-        when (val calleeReference = call.calleeReference) {
+        val calleeReference = call.calleeReference
-            is FirErrorNamedReference, is FirResolvedErrorReference -> {
+        when {
-                when (val diagnostic = (calleeReference as FirDiagnosticHolder).diagnostic) {
+            calleeReference.isError() -> {
+                when (val diagnostic = calleeReference.diagnostic) {
                     is ConeAmbiguityError -> if (diagnostic.applicability.isSuccess) {
                         reporter.reportOn(reportSource, ambiguityFactory, diagnostic.candidates.map { it.symbol }, context)
                     } else if (noneApplicableFactory != null) {
@@ -140,7 +142,7 @@ object FirForLoopChecker : FirBlockChecker() {
                 }
                 return true
             }
-            is FirResolvedNamedReference -> {
+            calleeReference is FirResolvedNamedReference -> {
                 val symbol = calleeReference.resolvedSymbol
                 if (symbol is FirNamedFunctionSymbol) {
                     if (!symbol.isOperator) {

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirSealedClassConstructorCallChecker.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.references.toResolvedConstructorSymbol
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
@@ -23,10 +24,7 @@ import org.jetbrains.kotlin.fir.types.coneType
 
 object FirSealedClassConstructorCallChecker : FirQualifiedAccessExpressionChecker() {
     override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) {
-        val constructorSymbol = (expression.calleeReference as? FirResolvedNamedReference)
+        val constructorSymbol = expression.calleeReference.toResolvedConstructorSymbol(discardErrorReference = true) ?: return
-            ?.takeUnless { it is FirResolvedErrorReference }
-            ?.resolvedSymbol as? FirConstructorSymbol
-            ?: return
 
         val typeSymbol = (constructorSymbol.resolvedReturnTypeRef.coneType.fullyExpandedType(context.session) as? ConeClassLikeType)
             ?.lookupTag?.toSymbol(context.session) as? FirRegularClassSymbol

compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTotalKotlinTestCase.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.isCatchParameter
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
+import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
@@ -84,14 +85,12 @@ class RawFirBuilderTotalKotlinTestCase : AbstractRawFirBuilderTestCase() {
                     }
 
                     override fun visitQualifiedAccess(qualifiedAccess: FirQualifiedAccess, data: FirElement) {
-                        when (val calleeReference = qualifiedAccess.calleeReference) {
+                        val calleeReference = qualifiedAccess.calleeReference
-                            is FirErrorNamedReference, is FirResolvedErrorReference -> {
+                        if (calleeReference.isError()) {
-                                errorReferences++
+                            errorReferences++
-                                println((calleeReference as FirDiagnosticHolder).diagnostic.reason)
+                            println((calleeReference as FirDiagnosticHolder).diagnostic.reason)
-                            }
+                        } else {
-                            else -> {
+                            normalReferences++
-                                normalReferences++
-                            }
                         }
                         visitStatement(qualifiedAccess, data)
                     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/references/FirReferenceUtils.kt

@@ -5,8 +5,11 @@
 
 package org.jetbrains.kotlin.fir.references
 
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
 
 val FirReference.resolved: FirResolvedNamedReference? get() = this as? FirResolvedNamedReference
 
@@ -52,3 +55,14 @@ fun FirReference.toResolvedFunctionSymbol(discardErrorReference: Boolean = false
 fun FirReference.toResolvedConstructorSymbol(discardErrorReference: Boolean = false): FirConstructorSymbol? {
     return this.toResolvedSymbol<FirConstructorSymbol>(discardErrorReference)
 }
+
+@OptIn(ExperimentalContracts::class)
+fun FirReference.isError(): Boolean {
+    contract {
+        returns(true) implies (this@isError is FirDiagnosticHolder)
+    }
+    return when (this) {
+        is FirResolvedErrorReference, is FirErrorNamedReference -> true
+        else -> false
+    }
+}

compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
+import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
 import org.jetbrains.kotlin.fir.resolve.transformers.FirGlobalResolveProcessor
@@ -283,8 +284,8 @@ class FirResolveBench(val withProgress: Boolean, val listener: BenchListener? =
                             if (type is ConeErrorType) {
                                 errorFunctionCallTypes++
                                 val psi = callee.psi
-                                if ((callee is FirErrorNamedReference || callee is FirResolvedErrorReference) && psi != null) {
+                                if (callee.isError() && psi != null) {
-                                    reportProblem((callee as FirDiagnosticHolder).diagnostic.reason, psi)
+                                    reportProblem(callee.diagnostic.reason, psi)
                                 }
                             }
                         }
@@ -300,8 +301,8 @@ class FirResolveBench(val withProgress: Boolean, val listener: BenchListener? =
                             if (type is ConeErrorType) {
                                 errorQualifiedAccessTypes++
                                 val psi = callee.psi
-                                if ((callee is FirErrorNamedReference || callee is FirResolvedErrorReference) && psi != null) {
+                                if (callee.isError() && psi != null) {
-                                    reportProblem((callee as FirDiagnosticHolder).diagnostic.reason, psi)
+                                    reportProblem(callee.diagnostic.reason, psi)
                                 }
                             }
                         }

plugins/assign-plugin/assign-plugin.k2/src/org/jetbrains/kotlin/assignment/plugin/k2/diagnostics/FirAssignmentPluginFunctionCallChecker.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.expression.FirFunctionCallChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.arguments
@@ -23,6 +24,7 @@ import org.jetbrains.kotlin.fir.expressions.toResolvedCallableSymbol
 import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference
+import org.jetbrains.kotlin.fir.references.isError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeDiagnosticWithSingleCandidate
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
@@ -33,8 +35,9 @@ object FirAssignmentPluginFunctionCallChecker : FirFunctionCallChecker() {
     override fun check(expression: FirFunctionCall, context: CheckerContext, reporter: DiagnosticReporter) {
         if (!expression.isOverloadAssignCallCandidate()) return
 
-        if (expression.isFunctionResolveError()) {
+        val calleeReference = expression.calleeReference
-            if (expression.isOverloadedAssignCallError(context.session)) {
+        if (calleeReference.isError()) {
+            if (expression.isOverloadedAssignCallError(context.session, calleeReference.diagnostic)) {
                 reporter.reportOn(expression.source, NO_APPLICABLE_ASSIGN_METHOD, context)
             }
         } else if (expression.isOverloadedAssignCall(context.session) && !expression.isReturnTypeUnit()) {
@@ -45,13 +48,8 @@ object FirAssignmentPluginFunctionCallChecker : FirFunctionCallChecker() {
     private fun FirFunctionCall.isOverloadAssignCallCandidate() =
         arguments.size == 1 && source?.kind == KtFakeSourceElementKind.DesugaredCompoundAssignment
 
-    private fun FirFunctionCall.isFunctionResolveError() = when(calleeReference){
+    private fun FirFunctionCall.isOverloadedAssignCallError(session: FirSession, diagnostic: ConeDiagnostic): Boolean {
-        is FirErrorNamedReference, is FirResolvedErrorReference -> true
+        val functionName = when (diagnostic) {
-        else -> false
-    }
-
-    private fun FirFunctionCall.isOverloadedAssignCallError(session: FirSession): Boolean {
-        val functionName = when (val diagnostic = (calleeReference as? FirDiagnosticHolder)?.diagnostic) {
             is ConeAmbiguityError -> diagnostic.name
             is ConeDiagnosticWithSingleCandidate -> diagnostic.candidate.callInfo.name
             is ConeUnresolvedNameError -> diagnostic.name