}


    fun toConstantValue(
        firExpression: FirExpression,
        builder: KtSymbolByFirBuilder,
    ): KtAnnotationValue? = firExpression.convertConstantExpression(builder)

    private fun FirExpression.convertConstantExpression(builder: KtSymbolByFirBuilder): KtAnnotationValue? {
        val token = builder.analysisSession.token
        val sourcePsi = psi as? KtElement

        return when (this) {

internal class KtFirAnnotationListForType private constructor(
    val coneType: ConeKotlinType,
    private val builder: KtSymbolByFirBuilder,
) : KtAnnotationsList() {
    override val token: KtLifetimeToken get() = builder.token
    private val useSiteSession: FirSession get() = builder.rootSession

    override val annotations: List<KtAnnotationApplicationWithArgumentsInfo>
        get() = withValidityAssertion {

    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }

    override val valueParameters: List<KtValueParameterSymbol> by cached { firSymbol.createKtValueParameters(builder) }

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion {
            firSymbol.fir.hasStableParameterNames
        }

    override val frontendKind: FrontendKind get() = FrontendKind.Fe10

    override val testPrefix: String
        get() = "descriptors"

    override fun configureTest(builder: TestConfigurationBuilder, disposable: Disposable) {
        builder.apply {
            useAdditionalService<KtTestModuleFactory> { KtSourceTestModuleFactory }

import org.jetbrains.kotlin.name.Name

internal class KtFirDelegatedMemberScope(
    firScope: FirContainingNamesAwareScope,
    builder: KtSymbolByFirBuilder
) : KtFirDelegatingNamesAwareScope(firScope, builder) {

    override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {

                getSymbolDescriptor(builder.symbol) as? ClassDescriptor
            }
        }

        if (descriptor == null) {
            val name = when (builder) {
                is KtClassTypeBuilder.ByClassId -> builder.classId.asString()
                is KtClassTypeBuilder.BySymbol ->
                    builder.symbol.classIdIfNonLocal?.asString()
                        ?: builder.symbol.name?.asString()

    builder: KtSymbolByFirBuilder,
    firFunctionSymbol: KtFirFunctionSymbol
): KtContractEffectDeclaration =
    accept(ConeContractDescriptionElementToAnalysisApi(builder, firFunctionSymbol), Unit) as KtContractEffectDeclaration

private class ConeContractDescriptionElementToAnalysisApi(
    private val builder: KtSymbolByFirBuilder,
    private val firFunctionSymbol: KtFirFunctionSymbol

                    add(builder.classifierBuilder.buildClassifierSymbol(firSymbol))
                }
            }
        }
    }

internal fun FirScope.getConstructors(builder: KtSymbolByFirBuilder): Sequence<KtConstructorSymbol> =
    sequence {
        yieldList {
            processDeclaredConstructors { firSymbol ->
                add(builder.functionLikeBuilder.buildConstructorSymbol(firSymbol))

    }

    override fun getClassifierSymbols(names: Collection<Name>): Sequence<KtClassifierSymbol> = withValidityAssertion {
        firScope.getClassifierSymbols(names, builder)
    }

    override fun getConstructors(): Sequence<KtConstructorSymbol> = withValidityAssertion {
        firScope.getConstructors(builder)
    }

import org.jetbrains.kotlin.name.Name

internal class KtFirFileScope(
    private val owner: KtFirFileSymbol,
    private val builder: KtSymbolByFirBuilder
) : KtScope {
    override val token: KtLifetimeToken get() = builder.token

    private val allNamesCached by cached {
        _callableNames + _classifierNames
    }