)
    }.orEmpty()

    return toKtAnnotationApplication(builder, index, arguments)
}

private fun FirAnnotation.asKtAnnotationApplicationForTargetAnnotation(
    builder: KtSymbolByFirBuilder,
    index: Int,
): KtAnnotationApplicationWithArgumentsInfo = asKtAnnotationApplicationForAnnotationWithEnumArgument(
    builder = builder,
    index = index,
    expectedEnumClassId = StandardClassIds.AnnotationTarget,

    override fun buildClassType(builder: KtClassTypeBuilder): KtClassType {
        val lookupTag = when (builder) {
            is KtClassTypeBuilder.ByClassId -> {
                val classSymbol = rootModuleSession.symbolProvider.getClassLikeSymbolByClassId(builder.classId)
                    ?: return ConeErrorType(ConeUnresolvedSymbolError(builder.classId)).asKtType() as KtClassType

    private val builder: KtSymbolByFirBuilder,
) : KtAnnotationsList() {
    private val useSiteSession: FirSession get() = builder.rootSession
    override val token: KtLifetimeToken get() = builder.token

    override val annotations: List<KtAnnotationApplicationWithArgumentsInfo>
        get() = withValidityAssertion {
            annotations(firCallableSymbol, builder, receiverParameter)
        }

    internal val firScope: S,
    protected val builder: KtSymbolByFirBuilder,
) : KtScope {
    final override val token: KtLifetimeToken get() = builder.token

    override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {
        firScope.getCallableSymbols(getPossibleCallableNames().filter(nameFilter), builder)
    }

        get() = withValidityAssertion {
            KtFirAnnotationListForDeclaration.create(firSymbol, builder)
        }

    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(analysisSession.firSymbolBuilder) }
    override val receiverParameter: KtReceiverParameterSymbol? get() = withValidityAssertion { firSymbol.receiver(builder) }

) : KtSubstitutorFactory(), KtFirAnalysisSessionComponent {

    override fun buildSubstitutor(builder: KtSubstitutorBuilder): KtSubstitutor {
        if (builder.mappings.isEmpty()) return KtSubstitutor.Empty(token)

        val firSubstitution = buildMap {
            builder.mappings.forEach { (ktTypeParameterSymbol, ktType) ->
                check(ktTypeParameterSymbol is KtFirTypeParameterSymbol)

import org.jetbrains.kotlin.name.Name

internal open class KtFirDelegatingNamesAwareScope(
    firScope: FirContainingNamesAwareScope,
    builder: KtSymbolByFirBuilder,
) : KtFirBasedScope<FirContainingNamesAwareScope>(firScope, builder) {
    private val allNamesCached by cached {
        getPossibleCallableNames() + getPossibleClassifierNames()
    }

    override val annotationsList by cached {
        KtFirAnnotationListForDeclaration.create(firSymbol, builder)
    }

    override val superTypes: List<KtType> by cached { firSymbol.superTypesList(builder) }

    context(KtAnalysisSession)
    override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {

    val firSymbol: FirBasedSymbol<*>,
    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 {
            annotations(firSymbol, builder)
        }

        else -> emptyList()
    }

internal fun FirAnnotation.toKtAnnotationApplication(
    builder: KtSymbolByFirBuilder,
    index: Int,
    arguments: List<KtNamedAnnotationValue> = FirAnnotationValueConverter.toNamedConstantValue(
        builder.analysisSession,
        mapAnnotationParameters(this),
        builder,
    )
): KtAnnotationApplicationWithArgumentsInfo {