// and if a containing delegated property accessor is inline,
    // it might need this accessor's bytecode.
    //
    // If an accessor function is defined in a different module,
    // IDE tries to acquire its bytecode via the index, however,
    // the index doesn't cover classfiles from compiler output,
    // so the lowering fails.
    //
    // To solve the problem, we need to find all delegated properties with inline accessors

    }

    fun isPrimitiveBacked(type: KotlinType): Boolean =
        AbstractTypeMapper.isPrimitiveBacked(this, type)

    override fun getClassInternalName(typeConstructor: TypeConstructorMarker): String {
        require(typeConstructor is TypeConstructor)

        return when (val declaration = typeConstructor.declarationDescriptor) {
            is TypeParameterDescriptor -> declaration.name.asString().sanitize()

@OptIn(KtAnalysisNonPublicApi::class) // used in IDEA K1 evaluator
@Suppress("unused")
fun KtAnalysisSession.getInlineFunctionAnalyzer(analyzeOnlyReifiedInlineFunctions: Boolean): InlineFunctionAnalyzer {
    require(this is KtFe10AnalysisSession) {
        "K2 implementation shouldn't call this code"
    }
    return InlineFunctionAnalyzer(analysisContext, analyzeOnlyReifiedInlineFunctions)
}

@OptIn(KtAnalysisNonPublicApi::class)

    }
}

private class KtFirResolveExtensionScope(
    private val analysisSession: KtFirAnalysisSession,
    private val tools: List<LLFirResolveExtensionTool>,
) : KtScope {
    init {
        require(tools.isNotEmpty())
    }

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

    override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {

        firExplicitReceiver = explicitReceiver?.let(::findReceiverFirExpression)
    }

    override fun computeApplicability(candidate: KtCallableSymbol): KtExtensionApplicabilityResult {
        require(candidate is KtFirSymbol<*>)

        analysisSession.withValidityAssertion {
            val firSymbol = candidate.firSymbol as FirCallableSymbol<*>
            firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS)

                override fun getContainerSource(descriptor: DeclarationDescriptor): DeserializedContainerSource? {
                    // Stubbed top-level function IR symbols (from other source files in the module) require a parent facade class to be
                    // generated, which requires a container source to be provided. Without a facade class, function IR symbols will have

    }

    override fun getFileScope(fileSymbol: KtFileSymbol): KtScope {
        require(fileSymbol is KtFe10FileSymbol)
        return KtFe10FileScope(fileSymbol.psi, analysisContext, token)
    }

    override fun getPackageScope(packageSymbol: KtPackageSymbol): KtScope {
        require(packageSymbol is KtFe10PackageSymbol)

        else -> listOf(symbol)
    }
    return intersectionOverriddenSymbolsOrSingle.mapNotNull { it.findPsiForReferenceResolve() }
}

private fun KtSymbol.findPsiForReferenceResolve(): PsiElement? {
    require(this is KtFirSymbol<*>)
    return firSymbol.fir.findReferencePsi()

    override val analysisSession: KtFe10AnalysisSession,
) : KtReferenceResolveProvider(), Fe10KtAnalysisSessionComponent {
    override fun resolveToSymbols(reference: KtReference): Collection<KtSymbol> {
        require(reference is KtFe10Reference)
        val bindingContext = analysisContext.analyze(reference.element, Fe10AnalysisFacade.AnalysisMode.PARTIAL)
        return reference.getTargetDescriptors(bindingContext).mapNotNull { descriptor ->

        check(firDiagnostic is KtPsiDiagnostic)
        return firDiagnostic.asKtDiagnostic()
    }

    val KtType.coneType: ConeKotlinType
        get() {
            require(this is KtFirType)
            return coneType
        }

    val KtTypeProjection.coneTypeProjection: ConeTypeProjection
        get() = when (this) {
            is KtStarTypeProjection -> ConeStarProjection