}

internal fun annotationsByClassId(
    firSymbol: FirBasedSymbol<*>,
    classId: ClassId,
    useSiteTargetFilter: AnnotationUseSiteTargetFilter,
    builder: KtSymbolByFirBuilder,
    annotationContainer: FirAnnotationContainer = firSymbol.fir,
): List<KtAnnotationApplicationWithArgumentsInfo> =
    if (classId == StandardClassIds.Annotations.Target && firSymbol.fir.resolvePhase < FirResolvePhase.ANNOTATION_ARGUMENTS) {

        val classId = function.containingClassLookupTag()?.classId ?: return null
        val classOrObject = classByClassId(classId, function.llFirSession.ktModule) ?: return null
        return classOrObject.declarations.singleOrNull()
    }

    private fun provideSourceForFunctionClass(klass: FirClass): PsiElement? {
        return classByClassId(klass.symbol.classId, klass.llFirSession.ktModule)
    }

        }

    override fun hasAnnotation(classId: ClassId, useSiteTargetFilter: AnnotationUseSiteTargetFilter): Boolean = withValidityAssertion {
        hasAnnotation(firCallableSymbol, classId, useSiteTargetFilter, useSiteSession, receiverParameter)
    }

    override fun annotationsByClassId(
        classId: ClassId,
        useSiteTargetFilter: AnnotationUseSiteTargetFilter,

            if (parentFir is FirResolvedQualifier) {
                var classId = parentFir.classId
                while (unresolvedCounter > 0) {
                    unresolvedCounter--
                    classId = classId?.outerClassId
                }
                return listOfNotNull(classId?.toTargetPsi(session, symbolBuilder))
            }

                        ?.javaFileFacadeFqName?.asString()
                } else {
                    val classId = (containingSymbolOrSelf as? KtConstructorSymbol)?.containingClassIdIfNonLocal
                        ?: (containingSymbolOrSelf as? KtCallableSymbol)?.callableIdIfNonLocal?.classId
                    classId?.takeUnless { it.shortClassName.isSpecial }
                        ?.asFqNameString()
                }
            }

) : KtSamResolver(), KtFirAnalysisSessionComponent {

    override fun getSamConstructor(ktClassLikeSymbol: KtClassLikeSymbol): KtSamConstructorSymbol? {
        val classId = ktClassLikeSymbol.classIdIfNonLocal ?: return null
        val owner = analysisSession.getClassLikeSymbol(classId) as? FirRegularClass ?: return null
        val resolver = LocalSamResolver(analysisSession, analysisSession.useSiteSession)

        val lookupTag = when (builder) {
            is KtClassTypeBuilder.ByClassId -> {
                val classSymbol = rootModuleSession.symbolProvider.getClassLikeSymbolByClassId(builder.classId)
                    ?: return ConeErrorType(ConeUnresolvedSymbolError(builder.classId)).asKtType() as KtClassType
                classSymbol.toLookupTag()
            }
            is KtClassTypeBuilder.BySymbol -> {
                val symbol = builder.symbol

                            isCompatible = isCompatible && typeParameterOwner.classId != StandardClassIds.Enum
                        }
                        if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitComparisonOfIncompatibleClasses)) {
                            isCompatible = isCompatible && typeParameterOwner.classId != StandardClassIds.KClass
                        }

    analysisContext: Fe10AnalysisContext,
    predicate: (ClassId) -> Boolean = { true }
) {
    val separator = if (isSingleLineAnnotations) " " else "\n"
    for (annotation in annotations) {
        val annotationClass = annotation.annotationClass ?: continue
        val classId = annotationClass.classId
        if (classId != null && !predicate(classId)) {
            continue
        }

}

internal val ClassifierDescriptor.classId: ClassId?
    get() = when (val owner = containingDeclaration) {
        is PackageFragmentDescriptor -> ClassId(owner.fqName, name)
        is ClassifierDescriptorWithTypeParameters -> owner.classId?.createNestedClassId(name)
        else -> null
    }

internal val ClassifierDescriptor.maybeLocalClassId: ClassId