FIR: report ambiguity-like errors in type resolve

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

@@ -259,8 +259,8 @@ private fun mapSystemHasContradictionError(
     qualifiedAccessSource: KtSourceElement?,
 ): List<KtDiagnostic> {
     val errorsToIgnore = mutableSetOf<ConstraintSystemError>()
-    return buildList<KtDiagnostic> {
-        for (error in diagnostic.candidate.system.errors) {
+    return buildList {
+        for (error in diagnostic.candidate.errors) {
             addIfNotNull(
                 error.toDiagnostic(
                     source,
@@ -273,7 +273,7 @@ private fun mapSystemHasContradictionError(
         }
     }.ifEmpty {
         listOfNotNull(
-            diagnostic.candidate.system.errors.firstNotNullOfOrNull {
+            diagnostic.candidate.errors.firstNotNullOfOrNull {
                 if (it in errorsToIgnore) return@firstNotNullOfOrNull null
                 val message = when (it) {
                     is NewConstraintError -> "NewConstraintError at ${it.position}: ${it.lowerType} <!: ${it.upperType}"
@@ -284,7 +284,7 @@ private fun mapSystemHasContradictionError(
                 }
 
                 if (it is NewConstraintError && it.position.from is FixVariableConstraintPosition<*>) {
-                    val morePreciseDiagnosticExists = diagnostic.candidate.system.errors.any { other ->
+                    val morePreciseDiagnosticExists = diagnostic.candidate.errors.any { other ->
                         other is NewConstraintError && other.position.from !is FixVariableConstraintPosition<*>
                     }
                     if (morePreciseDiagnosticExists) return@firstNotNullOfOrNull null
@@ -352,7 +352,7 @@ private fun ConstraintSystemError.toDiagnostic(
             }
         }
         is NotEnoughInformationForTypeParameter<*> -> {
-            val isDiagnosticRedundant = candidate.system.errors.any { otherError ->
+            val isDiagnosticRedundant = candidate.errors.any { otherError ->
                 (otherError is ConstrainingTypeIsError && otherError.typeVariable == this.typeVariable)
                         || otherError is NewConstraintError
             }

compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt

@@ -1245,7 +1245,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
             is ConeInapplicableCandidateError -> {
                 describeVerbose(diagnostic.candidate.symbol)
                 br
-                diagnostic.candidate.system.errors.forEach { callDiagnostic ->
+                diagnostic.candidate.errors.forEach { callDiagnostic ->
                     when (callDiagnostic) {
                         is NewConstraintError -> {
                             ident()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.fir.types.ConeTypeVariable
 import org.jetbrains.kotlin.resolve.calls.components.SuspendConversionStrategy
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemOperation
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintStorage
+import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintSystemError
 import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
@@ -37,13 +38,16 @@ class Candidate(
 ) : AbstractCandidate() {
 
     var systemInitialized: Boolean = false
-    override val system: NewConstraintSystemImpl by lazy(LazyThreadSafetyMode.NONE) {
+    val system: NewConstraintSystemImpl by lazy(LazyThreadSafetyMode.NONE) {
         val system = constraintSystemFactory.createConstraintSystem()
         system.addOtherSystem(baseSystem)
         systemInitialized = true
         system
     }
 
+    override val errors: List<ConstraintSystemError>
+        get() = system.errors
+
     lateinit var substitutor: ConeSubstitutor
     lateinit var freshVariables: List<ConeTypeVariable>
     var resultingTypeForCallableReference: ConeKotlinType? = null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirTypeResolverImpl.kt

@@ -18,6 +18,10 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeUnexpectedTypeArgumentsError
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.*
+import org.jetbrains.kotlin.fir.resolve.calls.AbstractCallInfo
+import org.jetbrains.kotlin.fir.resolve.calls.AbstractCandidate
+import org.jetbrains.kotlin.fir.resolve.calls.ReceiverValue
+import org.jetbrains.kotlin.fir.resolve.calls.ResolutionDiagnostic
 import org.jetbrains.kotlin.fir.resolve.diagnostics.*
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
@@ -32,6 +36,8 @@ import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.fir.visibilityChecker
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.StandardClassIds
+import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintSystemError
+import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
 
@@ -132,7 +138,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
                 candidates.clear()
             }
             if (symbolApplicability == applicability) {
-                candidates.add(TypeCandidate(symbol, substitutor, diagnostic))
+                candidates.add(TypeCandidate(symbol, substitutor, diagnostic, symbolApplicability))
             }
         }
 
@@ -160,7 +166,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
                 TypeResolutionResult.Resolved(candidate)
             }
             candidateCount > 1 -> {
-                TypeResolutionResult.Ambiguity
+                TypeResolutionResult.Ambiguity(candidates.toList())
             }
             candidateCount == 0 -> {
                 TypeResolutionResult.Unresolved
@@ -170,7 +176,7 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
     }
 
     sealed class TypeResolutionResult {
-        object Ambiguity : TypeResolutionResult()
+        class Ambiguity(val typeCandidates: List<TypeCandidate>) : TypeResolutionResult()
         object Unresolved : TypeResolutionResult()
         class Resolved(val typeCandidate: TypeCandidate) : TypeResolutionResult()
     }
@@ -227,19 +233,25 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
             is TypeResolutionResult.Resolved -> {
                 result.typeCandidate.symbol to result.typeCandidate.substitutor
             }
-            TypeResolutionResult.Ambiguity -> null to null
+            is TypeResolutionResult.Ambiguity -> null to null
             TypeResolutionResult.Unresolved -> null to null
         }
 
         if (symbol == null || symbol !is FirClassifierSymbol<*>) {
-            val diagnostic = if (symbol?.fir is FirEnumEntry) {
-                if (isOperandOfIsOperator) {
-                    ConeSimpleDiagnostic("'is' operator can not be applied to an enum entry.", DiagnosticKind.IsEnumEntry)
-                } else {
-                    ConeSimpleDiagnostic("An enum entry should not be used as a type.", DiagnosticKind.EnumEntryAsType)
+            val diagnostic = when {
+                symbol?.fir is FirEnumEntry -> {
+                    if (isOperandOfIsOperator) {
+                        ConeSimpleDiagnostic("'is' operator can not be applied to an enum entry.", DiagnosticKind.IsEnumEntry)
+                    } else {
+                        ConeSimpleDiagnostic("An enum entry should not be used as a type.", DiagnosticKind.EnumEntryAsType)
+                    }
+                }
+                result is TypeResolutionResult.Ambiguity -> {
+                    ConeAmbiguityError(typeRef.qualifier.last().name, result.typeCandidates.first().applicability, result.typeCandidates)
+                }
+                else -> {
+                    ConeUnresolvedQualifierError(typeRef.render())
                 }
-            } else {
-                ConeUnresolvedQualifierError(typeRef.render())
             }
             return ConeErrorType(diagnostic)
         }
@@ -516,10 +528,30 @@ class FirTypeResolverImpl(private val session: FirSession) : FirTypeResolver() {
 
 
     class TypeCandidate(
-        val symbol: FirBasedSymbol<*>,
+        override val symbol: FirBasedSymbol<*>,
         val substitutor: ConeSubstitutor?,
-        val diagnostic: ConeDiagnostic?
-    ) {
+        val diagnostic: ConeDiagnostic?,
+        override val applicability: CandidateApplicability
+    ) : AbstractCandidate() {
+
+        override val dispatchReceiverValue: ReceiverValue?
+            get() = null
+
+        override val extensionReceiverValue: ReceiverValue?
+            get() = null
+
+        override val explicitReceiverKind: ExplicitReceiverKind
+            get() = ExplicitReceiverKind.NO_EXPLICIT_RECEIVER
+
+        override val diagnostics: List<ResolutionDiagnostic>
+            get() = emptyList()
+
+        override val errors: List<ConstraintSystemError>
+            get() = emptyList()
+
+        override val callInfo: AbstractCallInfo
+            get() = throw UnsupportedOperationException("Should not be called")
+
         override fun equals(other: Any?): Boolean {
             if (this === other) return true
             if (other !is TypeCandidate) return false

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/calls/AbstractCandidate.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.calls
 
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl
+import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintSystemError
 import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
 
@@ -17,6 +17,6 @@ abstract class AbstractCandidate {
     abstract val explicitReceiverKind: ExplicitReceiverKind
     abstract val callInfo: AbstractCallInfo
     abstract val diagnostics: List<ResolutionDiagnostic>
-    abstract val system: NewConstraintSystemImpl
+    abstract val errors: List<ConstraintSystemError>
     abstract val applicability: CandidateApplicability
 }