val token = tokenFactory.create(project, project.createProjectWideOutOfBlockModificationTracker())
        val context = facade.getAnalysisContext(useSiteKtElement, token)
        val useSiteModule = ProjectStructureProvider.getModule(project, useSiteKtElement, contextualModule = null)
        return KtFe10AnalysisSession(context, useSiteModule, token)
    }

    override val analysisSession: KtFe10AnalysisSession,
) : KtResolveExtensionInfoProvider(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    override fun getResolveExtensionScopeWithTopLevelDeclarations(): KtScope {
        return KtEmptyScope(token)
    }

    override fun isResolveExtensionFile(file: VirtualFile): Boolean = false

@OptIn(KtAnalysisApiInternals::class, KtAnalysisNonPublicApi::class)
@Suppress("LeakingThis")
class KtFe10AnalysisSession(
    val analysisContext: Fe10AnalysisContext,
    override val useSiteModule: KtModule,
    token: KtLifetimeToken,
) : KtAnalysisSession(token) {

    override val smartCastProviderImpl: KtSmartCastProvider = KtFe10SmartCastProvider(this)
    override val diagnosticProviderImpl: KtDiagnosticProvider = KtFe10DiagnosticProvider(this)

                return when (calls.size) {
                    0 -> KtErrorCallInfo(listOf(KtQualifierCall(token, callExpression)), inapplicableCandidateDiagnostic(), token)
                    else -> KtErrorCallInfo(calls, inapplicableCandidateDiagnostic(), token)
                }
            }
        }

        if (this is FirImplicitInvokeCall) {

import org.jetbrains.kotlin.psi.*

internal class KtFe10ImportOptimizer(
    override val analysisSession: KtFe10AnalysisSession
) : KtImportOptimizer(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

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

internal class KtFe10JvmTypeMapper(
    override val analysisSession: KtFe10AnalysisSession
) : KtJvmTypeMapper(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisContext.resolveSession) }

    override fun mapTypeToJvmType(type: KtType, mode: TypeMappingMode): Type {

            ?: KtFe10NeverRestoringSymbolPointer()
    }

    override val returnType: KtType
        get() = withValidityAssertion { owningProperty.returnType }

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

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion {
            KtFe10AnnotationsList.create(descriptor?.annotations ?: Annotations.EMPTY, analysisContext)

                    KtClassTypeQualifier.KtResolvedClassTypeQualifier(
                        it.toKtClassSymbol(analysisContext),
                        emptyList(),
                        token
                    )
                }

                nestedType.allInnerTypes.mapTo(this) { innerType ->
                    KtClassTypeQualifier.KtResolvedClassTypeQualifier(

internal class KtFe10TypeInfoProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtTypeInfoProvider(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

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

internal class KtFe10SymbolProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtSymbolProvider(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol
        get() = KtFe10PackageSymbol(FqName.ROOT, analysisContext)

    override fun getFileSymbol(psi: KtFile): KtFileSymbol {