import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtDeclaration
import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtNamedDeclaration

internal class KtFirResolveExtensionInfoProvider(
    override val analysisSession: KtFirAnalysisSession,
) : KtResolveExtensionInfoProvider(), KtFirAnalysisSessionComponent {
    override val token: KtLifetimeToken

    implementation(project(":compiler:ir.serialization.jvm"))
    api(intellijCore())
    implementation(project(":analysis:analysis-api-providers"))
    implementation(project(":analysis:analysis-internal-utils"))
    implementation(project(":analysis:kt-references"))
    implementation(project(":analysis:symbol-light-classes"))

    testImplementation(projectTests(":analysis:low-level-api-fir"))

        this ?: error("Resolution is not performed")
}

class KtFe10AnalysisHandlerExtension(
    private val useSiteModule: KtSourceModule? = null
) : AnalysisHandlerExtension {
    internal companion object {
        fun getInstance(area: AreaInstance, module: KtModule): KtFe10AnalysisHandlerExtension {
            val extensions = AnalysisHandlerExtension.extensionPointName.getExtensions(area)

import org.jetbrains.kotlin.types.error.ErrorUtils
import org.jetbrains.kotlin.types.model.KotlinTypeMarker
import org.jetbrains.kotlin.types.model.TypeConstructorMarker
import org.jetbrains.org.objectweb.asm.Type

internal class KtFe10JvmTypeMapperContext(private val resolveSession: ResolveSession) : TypeMappingContext<JvmSignatureWriter> {
    companion object {
        fun getNestedType(type: KotlinType): NestedType {

import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForReceiver
import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment
import org.jetbrains.kotlin.utils.exceptions.withPsiEntry

internal class KtFirCompletionCandidateChecker(
    override val analysisSession: KtFirAnalysisSession,
    override val token: KtLifetimeToken,
) : KtCompletionCandidateChecker(), KtFirAnalysisSessionComponent {

 */
val STUB_UNBOUND_IR_SYMBOLS: CompilerConfigurationKey<Boolean> = CompilerConfigurationKey<Boolean>("stub unbound IR symbols")

internal class KtFe10CompilerFacility(
    override val analysisSession: KtFe10AnalysisSession
) : KtCompilerFacility(), Fe10KtAnalysisSessionComponent {
    override fun compile(
        file: KtFile,

                return@withValidityAssertion true
            }
            descriptor.isOperator
        }

    override val isExternal: Boolean
        get() = withValidityAssertion { descriptor.isExternal }

    override val isInline: Boolean
        get() = withValidityAssertion { descriptor.isInline }

    override val isOverride: Boolean

import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
import org.jetbrains.kotlin.name.Name


internal fun FirScope.getCallableSymbols(
    callableNames: Collection<Name>,
    builder: KtSymbolByFirBuilder
): Sequence<KtCallableSymbol> = sequence {
    callableNames.forEach { name ->
        yieldList {

 */

package org.jetbrains.kotlin.analysis.api.fir.signatures

import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor

internal interface SubstitutorBasedSignature {
    val coneSubstitutor: ConeSubstitutor

import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer

internal class KtFe10NeverRestoringSymbolPointer<T : KtSymbol> : KtSymbolPointer<T>() {
    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol", ReplaceWith("null"))