import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken

@OptIn(KaAnalysisApiInternals::class)
internal class KaFirRendererProvider(
    analysisSession: KaSession,
    token: KaLifetimeToken

            return project.getService(Fe10AnalysisFacade::class.java)
        }
    }

    fun getAnalysisContext(element: KtElement, token: KaLifetimeToken): Fe10AnalysisContext

    fun getAnalysisContext(ktModule: KtModule, token: KaLifetimeToken): Fe10AnalysisContext

    fun analyze(elements: List<KtElement>, mode: AnalysisMode = AnalysisMode.FULL): BindingContext

                    add(annotationDescriptor.toKaAnnotation(analysisContext, index))
                }
            }
        }
    }

    override val token: KaLifetimeToken
        get() = analysisContext.token

    override fun isEmpty(): Boolean = withValidityAssertion {
        return if (ignoredAnnotations.isEmpty()) {
            fe10Annotations.isEmpty()
        } else {

    private val builder: KaSymbolByFirBuilder,
) : AbstractList<KaAnnotation>(), KaAnnotationList {
    private val backingAnnotations by lazy { annotations(firSymbol, builder) }

    override val token: KaLifetimeToken
        get() = builder.token

    private val useSiteSession: FirSession
        get() = builder.rootSession

    override fun isEmpty(): Boolean = withValidityAssertion {

import org.jetbrains.kotlin.types.TypeUtils

internal class KaFe10TypeInfoProvider(
    override val analysisSession: KaFe10Session
) : KaTypeInfoProvider(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun isFunctionalInterfaceType(type: KaType): Boolean {
        require(type is KaFe10Type)
        return JavaSingleAbstractMethodUtils.isSamType(type.fe10Type)
    }

internal class KaFe10ImportOptimizer(
    override val analysisSession: KaFe10Session,
) : KaImportOptimizer(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun analyseImports(file: KtFile): KaImportOptimizerResult = withValidityAssertion {
        error("FE10 implementation of KtImportOptimizer should not be called from anywhere")
    }

                    KaClassTypeQualifier.KaResolvedClassTypeQualifier(
                        it.toKaClassSymbol(analysisContext),
                        emptyList(),
                        token
                    )
                }

                nestedType.allInnerTypes.mapTo(this) { innerType ->
                    KaClassTypeQualifier.KaResolvedClassTypeQualifier(

) : KaSubstitutorFactory(), KaFe10SessionComponent {

    override fun buildSubstitutor(builder: KaSubstitutorBuilder): KaSubstitutor {
        if (builder.mappings.isEmpty()) return KaSubstitutor.Empty(token)
        TODO()
    }

import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.fir.declarations.getSealedClassInheritors

internal class KaFirInheritorsProvider(
    override val analysisSession: KaFirSession,
    override val token: KaLifetimeToken,
) : KaInheritorsProvider(), KaFirSessionComponent {
    override fun getInheritorsOfSealedClass(
        classSymbol: KaNamedClassOrObjectSymbol
    ): List<KaNamedClassOrObjectSymbol> {

    }

    override val typeParameters: List<KaTypeParameterSymbol> get() = withValidityAssertion { emptyList() }
    override val annotations: KaAnnotationList get() = withValidityAssertion { KaEmptyAnnotationList(token) }

    override fun equals(other: Any?): Boolean = isEqualTo(other)
    override fun hashCode(): Int = calculateHashCode()