override val thisLabelsToShorten: List<ThisLabelToShortenInfo> = emptyList()
            override val kDocQualifiersToShorten: List<SmartPsiElementPointer<KDocName>> get() = emptyList()

            override val isEmpty: Boolean get() = true
        }
    }

import java.lang.annotation.ElementType

internal fun mapAnnotationParameters(annotation: FirAnnotation): Map<Name, FirExpression> {
    if (annotation is FirAnnotationCall && annotation.arguments.isEmpty()) return emptyMap()

    checkWithAttachment(annotation.resolved, { "By now the annotations argument mapping should have been resolved" }) {
        withFirEntry("annotation", annotation)

import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
import org.jetbrains.kotlin.descriptors.findTypeAliasAcrossModuleDependencies
import org.jetbrains.kotlin.descriptors.isEmpty
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter

                    yield(ktSymbol)
                }
            }
        }
    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KtCallableSymbol> = withValidityAssertion {
        if (names.isEmpty()) return emptySequence()
        val namesSet = names.toSet()
        return getCallableSymbols { it in namesSet }
    }

import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
import org.jetbrains.kotlin.resolve.BindingContext

@OptIn(KtAnalysisNonPublicApi::class)
fun MutableSet<KtFile>.collectReachableInlineDelegatedPropertyAccessors() {
    if (isEmpty()) return

    // One of the compiler lowerings, namely `PropertyReferenceLowering`,
    // optimizes usages of property references in some cases,
    // and if a containing delegated property accessor is inline,

                    KtFirAnnotationListForDeclaration(firSymbol, builder)
                firSymbol.annotations.isEmpty() ->
                    KtEmptyAnnotationsList(builder.token)
                else ->
                    KtFirAnnotationListForDeclaration(firSymbol, builder)
            }
        }
    }

            fe10Annotations: Annotations,
            analysisContext: Fe10AnalysisContext,
            ignoreAnnotations: Set<ClassId> = emptySet(),
        ): KtAnnotationsList {
            return if (!fe10Annotations.isEmpty()) {
                KtFe10AnnotationsList(fe10Annotations, ignoreAnnotations, analysisContext)
            } else {
                KtEmptyAnnotationsList(analysisContext.token)
            }
        }
    }

        }

    private fun KtAnalysisSession.fixUpAnnotationCallResolveToCtor(resultsToFix: Collection<KtSymbol>): Collection<KtSymbol> {
        if (resultsToFix.isEmpty() || !isAnnotationCall) return resultsToFix

        return resultsToFix.map { targetSymbol ->
            if (targetSymbol is KtFirNamedClassOrObjectSymbol && targetSymbol.classKind == KtClassKind.ANNOTATION_CLASS) {

        val fir = classSymbol.getFirForScope()
        val delegateFields = fir.delegateFields

        if (delegateFields.isEmpty()) {
            return getEmptyScope()
        }

        fir.lazyResolveToPhaseWithCallableMembers(FirResolvePhase.STATUS)

        val firScope = FirDelegatedMemberScope(

        partiallyAppliedSymbol: KtPartiallyAppliedSymbol<*, *>
    ): Map<KtTypeParameterSymbol, KtType> {
        val typeParameters = partiallyAppliedSymbol.symbol.typeParameters
        if (typeParameters.isEmpty()) return emptyMap()
        if (typeArguments.size < typeParameters.size) return emptyMap()

        val result = mutableMapOf<KtTypeParameterSymbol, KtType>()