import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.scopes.*

internal abstract class KtFe10ScopeResolution : KtScope, KtLifetimeOwner {
    abstract val analysisContext: Fe10AnalysisContext
    abstract val scope: ResolutionScope

                    // words, this receiver expression should be pointing at an unqualified name of a class, whose class ID is
                    // `outerClassId`.
                    if (receiverExpression == expression) {
                        // If there is still an outer class, then return symbol of that class
                        outerClassId?.let { return listOfNotNull(it.toTargetPsi(session, symbolBuilder)) }

        return classOrObject.declarations.singleOrNull()
    }

    private fun provideSourceForFunctionClass(klass: FirClass): PsiElement? {
        return classByClassId(klass.symbol.classId, klass.llFirSession.ktModule)
    }

    private fun classByClassId(classId: ClassId, ktModule: KtModule): KtClassOrObject? {
        val project = ktModule.project

import org.jetbrains.kotlin.analysis.api.impl.base.components.KtRendererProviderImpl
import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken

@OptIn(KtAnalysisApiInternals::class)
internal class KtFirRendererProvider(
    analysisSession: KtAnalysisSession,
    token: KtLifetimeToken

import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile
import kotlin.reflect.KClass

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

import org.jetbrains.kotlin.analysis.api.scopes.KtTypeScope
import org.jetbrains.kotlin.analysis.utils.errors.unexpectedElementError

internal class KtFirScopeSubstitution(
    override val analysisSession: KtFirAnalysisSession,
) : KtScopeSubstitution(), KtFirAnalysisSessionComponent {

    @OptIn(KtAnalysisApiInternals::class)
    override fun getDeclarationScope(scope: KtTypeScope): KtScope {
        return when (scope) {

import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol

internal open class KtFirAnonymousObjectSymbol(
    override val firSymbol: FirAnonymousObjectSymbol,
    override val analysisSession: KtFirAnalysisSession,
) : KtAnonymousObjectSymbol(), KtFirSymbol<FirAnonymousObjectSymbol> {

import org.jetbrains.kotlin.asJava.KtLightClassMarker
import org.jetbrains.kotlin.load.java.JvmAnnotationNames
import org.jetbrains.kotlin.name.Name

@OptIn(KtAnalysisApiInternals::class)
internal class KtFirSymbolProviderByJavaPsi(
    override val analysisSession: KtFirAnalysisSession,
) : KtSymbolProviderByJavaPsi(), KtFirAnalysisSessionComponent {

class KtFe10ExpressionTypeProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtExpressionTypeProvider(), Fe10KtAnalysisSessionComponent {
    private companion object {
        val NON_EXPRESSION_CONTAINERS = arrayOf(
            KtImportDirective::class.java,
            KtTypeReference::class.java,
            KtPackageDirective::class.java,

import org.jetbrains.kotlin.fir.declarations.utils.hasStableParameterNames
import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.impl.isExtension

internal class KtFirAnonymousFunctionSymbol(
    override val firSymbol: FirAnonymousFunctionSymbol,
    override val analysisSession: KtFirAnalysisSession,
) : KtAnonymousFunctionSymbol(), KtFirSymbol<FirAnonymousFunctionSymbol> {