import org.jetbrains.kotlin.utils.exceptions.withPsiEntry

internal class KtFirImportOptimizer(
    private val analysisSession: KtFirAnalysisSession,
    override val token: KtLifetimeToken,
    private val firResolveSession: LLFirResolveSession
) : KtImportOptimizer() {
    private val firSession: FirSession
        get() = firResolveSession.useSiteFirSession

        return getKtExpressionNonErrorType(subject)
    }

    private fun getKtExpressionNonErrorType(expression: KtExpression): KtType? =
        getKtExpressionType(expression)?.nonErrorTypeOrNull()

    private fun KtType.nonErrorTypeOrNull(): KtType? = takeUnless { it is KtErrorType }

    private fun PsiElement.isWhileLoopCondition() =

            }
        }
    }

    private val CallableId.isStringEquals: Boolean
        get() = classId == StandardClassIds.String && callableName.identifierOrNullIfSpecial == "equals"

    private val CallableId.isStringPlus: Boolean
        get() = classId == StandardClassIds.String && callableName.identifierOrNullIfSpecial == "plus"

    ////// KINDS

import org.jetbrains.kotlin.utils.addToStdlib.safeAs

internal class KtFe10CallResolver(
    override val analysisSession: KtFe10AnalysisSession
) : AbstractKtCallResolver(), Fe10KtAnalysisSessionComponent {
    private companion object {
        private val operatorWithAssignmentVariant = setOf(
            OperatorNameConventions.PLUS,
            OperatorNameConventions.MINUS,
            OperatorNameConventions.TIMES,

}

private class SyntheticTypeElement(parent: PsiElement, typeText: String) : ClsTypeElementImpl(parent, typeText, '\u0000'), SyntheticElement

private val PsiElement.containingKtFile: KtFile?
    get() = (this as? KtLightElement<*, *>)?.kotlinOrigin?.containingKtFile

private class AnonymousTypesSubstitutor(
    private val session: FirSession,

    KtFirAnalysisSessionComponent {
    private val firSession: FirSession
        get() = rootModuleSession

    private val scopeSession: ScopeSession
        get() = firResolveSession.getScopeSessionFor(firSession)

    private val metadataVersion = firSession.languageVersionSettings.languageVersion.toMetadataVersion()

        printDiagnosticClassesImplementation(diagnosticList)
    }

    private fun SmartPrinter.printDiagnosticClassesImplementation(diagnosticList: HLDiagnosticList) {
        for (diagnostic in diagnosticList.diagnostics) {
            printDiagnosticImplementation(diagnostic, diagnosticList)
            println()
        }
    }

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

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

    override fun asPsiType(
        type: KtType,
        useSitePosition: PsiElement,
        allowErrorTypes: Boolean,

import org.jetbrains.kotlin.name.ClassId

internal class KtFirAnnotationListForType private constructor(
    val coneType: ConeKotlinType,
    private val builder: KtSymbolByFirBuilder,
) : KtAnnotationsList() {
    override val token: KtLifetimeToken get() = builder.token
    private val useSiteSession: FirSession get() = builder.rootSession

    // `KtFirAnalysisSession`s must be soft-referenced to allow simultaneous garbage collection of an unused `KtFirAnalysisSession` together
    // with its `LLFirSession`.
    private val cache: ConcurrentMap<KtModule, KtAnalysisSession> = ContainerUtil.createConcurrentSoftValueMap()

    init {
        LowMemoryWatcher.register(::clearCaches, project)
    }