return KtFe10AnalysisHandlerExtension.getInstance(project, ktModule)
    }

    private fun <T : Any> T?.orThrowResolutionNotPerformedError(): T =
        this ?: error("Resolution is not performed")
}

class KtFe10AnalysisHandlerExtension(
    private val useSiteModule: KtSourceModule? = null
) : AnalysisHandlerExtension {
    internal companion object {

internal class KtFe10AnalysisSessionProvider(project: Project) : KtAnalysisSessionProvider(project) {
    override fun getAnalysisSession(useSiteKtElement: KtElement): KtAnalysisSession {
        val facade = Fe10AnalysisFacade.getInstance(project)
        val token = tokenFactory.create(project, project.createProjectWideOutOfBlockModificationTracker())
        val context = facade.getAnalysisContext(useSiteKtElement, token)

        }

    override val psi: PsiElement?
        get() = withValidityAssertion {
            (source as? PsiSourceElement)?.psi
                ?: KtFe10ReferenceResolutionHelper.getInstance()
                    ?.findDecompiledDeclaration(analysisContext.resolveSession.project, descriptor, null)
        }

    override val origin: KtSymbolOrigin

    override val fqName: FqName
        get() = withValidityAssertion { packageName }

    override val psi: PsiElement? by cached {
        val project = analysisContext.resolveSession.project
        JavaPsiFacade.getInstance(project).findPackage(fqName.asString())
    }

    override fun createPointer(): KtSymbolPointer<KtPackageSymbol> = withValidityAssertion {
        KtFe10PackageSymbolPointer(fqName)
    }

            )

            when {
                analysisSession.targetPlatform.isJvm() -> {
                    val psiPackage = PsiPackageImpl(PsiManager.getInstance(analysisSession.project), packageFqName.asString())
                    forEachNonKotlinPsiElementFinder(analysisSession.project) { finder ->

import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner

interface Fe10AnalysisFacade {
    companion object {
        fun getInstance(project: Project): Fe10AnalysisFacade {
            return project.getService(Fe10AnalysisFacade::class.java)
        }
    }

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

     */
    internal class SessionInvalidationListener(val project: Project) : LLFirSessionInvalidationListener {
        private val analysisSessionProvider: KtFirAnalysisSessionProvider
            get() = getInstance(project) as? KtFirAnalysisSessionProvider
                ?: error("Expected the analysis session provider to be a `${KtFirAnalysisSessionProvider::class.simpleName}`.")

        }
    }

    override fun asKtType(
        psiType: PsiType,
        useSitePosition: PsiElement,
    ): KtType? {
        val javaElementSourceFactory = JavaElementSourceFactory.getInstance(project)
        val javaType = JavaTypeImpl.create(psiType, javaElementSourceFactory.createTypeSource(psiType))

        val javaTypeRef = buildJavaTypeRef {

internal class KtFe10ScopeProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtScopeProvider(), Fe10KtAnalysisSessionComponent {
    private companion object {
        val LOG = Logger.getInstance(KtFe10ScopeProvider::class.java)
    }

    override val token: KtLifetimeToken
        get() = analysisSession.token

    override fun getMemberScope(classSymbol: KtSymbolWithMembers): KtScope {

class KtFe10CompilerPluginsProvider : KtCompilerPluginsProvider() {
    override fun <T : Any> getRegisteredExtensions(module: KtSourceModule, extensionType: ProjectExtensionDescriptor<T>): List<T> {
        return extensionType.getInstances(module.project)
    }

    @OptIn(InternalNonStableExtensionPoints::class)
    override fun isPluginOfTypeRegistered(module: KtSourceModule, pluginType: CompilerPluginType): Boolean {