require(candidates.isNotEmpty()) { "Cannot have zero candidates" }

        val distinctCandidates = candidates.distinctBy { it.callableId }
        return distinctCandidates.singleOrNull()
            ?: errorWithAttachment("Expected all candidates to have same callableId but some of them but was different") {
                withEntry("callableIds", distinctCandidates.map { it.callableId.asSingleFqName() }.joinToString())

internal class OverloadResolutionAmbiguityImpl(
    override val candidates: List<KtSymbol>,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OverloadResolutionAmbiguity

internal class AssignOperatorAmbiguityImpl(
    override val candidates: List<KtSymbol>,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,

                    candidate.dispatchReceiver,
                    candidate.chosenExtensionReceiver,
                    candidate.explicitReceiverKind
                )
            } else {
                KtPartiallyAppliedSymbol(
                    with(analysisSession) { unsubstitutedKtSignature.substitute(substitutor) },
                    candidate.dispatchReceiver?.toKtReceiverValue(),

        override val diagnosticClass get() = OverloadResolutionAmbiguity::class
        val candidates: List<KtSymbol>
    }

    interface AssignOperatorAmbiguity : KtFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = AssignOperatorAmbiguity::class
        val candidates: List<KtSymbol>
    }

    interface IteratorAmbiguity : KtFirDiagnostic<PsiElement> {

            val candidates = result.allCandidates?.let { analysisContext.overloadingConflictResolver.filterOutEquivalentCalls(it) }
                ?: error("allCandidates is null even when collectAllCandidates = true")

            candidates.flatMap { candidate ->
                // The current BindingContext does not have the diagnostics for each individual candidate, only for the resolved call.

        firExplicitReceiver = explicitReceiver?.let(::findReceiverFirExpression)
    }

    override fun computeApplicability(candidate: KtCallableSymbol): KtExtensionApplicabilityResult {
        require(candidate is KtFirSymbol<*>)

        analysisSession.withValidityAssertion {
            val firSymbol = candidate.firSymbol as FirCallableSymbol<*>
            firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS)

  @TestDataPath("$PROJECT_ROOT")
  public class NoCandidates {
    @Test
    public void testAllFilesPresentInNoCandidates() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/callResolver/resolveCandidates/noCandidates"), Pattern.compile("^(.+)\\.kt$"), null, true);
    }

- [`KT-60601`](https://youtrack.jetbrains.com/issue/KT-60601) K2 / Maven: Overload resolution ambiguity between candidates inline method

    else -> emptyList()
}

internal fun ConeDiagnostic.getCandidateSymbols(): Collection<FirBasedSymbol<*>> =
    when (this) {
        is ConeHiddenCandidateError -> {
            // Candidate with @Deprecated(DeprecationLevel.HIDDEN)
            emptyList()
        }
        is ConeDiagnosticWithCandidates -> candidateSymbols
        is ConeDiagnosticWithSymbol<*> -> listOf(symbol)

                firSymbolBuilder.buildSymbol(firBasedSymbol)
            },
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.INAPPLICABLE_CANDIDATE) { firDiagnostic ->
        InapplicableCandidateImpl(
            firSymbolBuilder.buildSymbol(firDiagnostic.a),
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }