import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
import org.jetbrains.kotlin.resolve.scopes.MemberScope

internal class KtFe10PackageScope(
    scope: MemberScope,
    private val owner: KtPackageSymbol,
    analysisContext: Fe10AnalysisContext
) : KtFe10ScopeMember(scope, constructors = emptyList(), analysisContext) {

        val classId = ktClassLikeSymbol.classIdIfNonLocal ?: return null
        val owner = analysisSession.getClassLikeSymbol(classId) as? FirRegularClass ?: return null
        val resolver = LocalSamResolver(analysisSession, analysisSession.useSiteSession)
        return resolver.getSamConstructor(owner)?.let {
            analysisSession.firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(it.symbol)
        }

            return getContainingModule(symbol.owningProperty)
        }

        if (symbol is KtFe10DynamicFunctionDescValueParameterSymbol) {
            return getContainingModule(symbol.owner)
        }

        TODO(symbol::class.java.name)
    }

    private fun getFakeContainingKtModule(descriptor: DescriptorWithContainerSource): KtModule {

            if (calleeReference is FirResolvedNamedReference) {
                val callee = calleeReference.resolvedSymbol.fir as? FirCallableDeclaration
                // TODO: check callee owner directly?
                if (callee !is FirConstructor && callee?.isStatic != true) {
                    classLikeDeclaration.companionObjectSymbol?.let { return it.fir.buildSymbol(symbolBuilder) }
                }

    private val owner: FirJavaClass,
) : FirCallableFilteringScope(delegate) {
    init {
        // The `isDeclared` check is based on class IDs. Local classes don't have proper class IDs, but because this scope is used to
        // represent Java classes viewed from Kotlin code, we shouldn't be able to encounter any local Java classes.
        require(!owner.isLocal) {

- [`KT-59858`](https://youtrack.jetbrains.com/issue/KT-59858) Kotlin Native: Compilation failed: Sequence contains more than one matching element, org.jetbrains.kotlin.backend.konan.lower.FunctionReferenceLowering$FunctionReferenceBuilder.buildClass(FunctionReferenceLowering.kt:644)

    }

    interface ConflictingInheritedMembers : KtFirDiagnostic<KtClassOrObject> {
        override val diagnosticClass get() = ConflictingInheritedMembers::class
        val owner: KtClassLikeSymbol
        val conflictingDeclarations: List<KtCallableSymbol>
    }

    interface AbstractMemberNotImplemented : KtFirDiagnostic<KtClassOrObject> {

        val owner = descriptor.owner

        if (descriptor is IrBasedReceiverParameterDescriptor && owner is IrValueParameter) {
            val receiverClass = (owner.type as? IrSimpleType)?.classifier as? IrClassSymbol
            val receiverClassId = receiverClass?.owner?.classId

            if (receiverClassId != null) {
                if (owner.index >= 0) {

import org.jetbrains.kotlin.resolve.calls.CallResolver
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.resolve.calls.results.OverloadingConflictResolver
import org.jetbrains.kotlin.resolve.calls.tower.KotlinToResolvedCallTransformer
import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner

        // That way, the resulting scope will contain all the nested declarations which can be references by KDoc.
        val parentKDoc = positionInFakeFile.parentOfType<KDoc>()
        val correctedPosition = parentKDoc?.owner ?: positionInFakeFile

        val context = ContextCollector.process(
            fakeFile.getOrBuildFirFile(firResolveSession),
            SessionHolderImpl(analysisSession.useSiteSession, getScopeSession()),