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

    override fun buildClassType(builder: KtClassTypeBuilder): KtClassType {
        val descriptor: ClassDescriptor? = when (builder) {
            is KtClassTypeBuilder.ByClassId -> {
                val fqName = builder.classId.asSingleFqName()
                analysisContext.resolveSession

    )

    override fun visitReturnsEffectDeclaration(
        returnsEffect: ConeReturnsEffectDeclaration,
        data: Unit
    ): KtContractReturnsContractEffectDeclaration =
        when (val value = returnsEffect.value) {
            ConeContractConstantValues.NULL ->
                KtContractReturnsSpecificValueEffectDeclaration(KtContractConstantValue(KtContractConstantType.NULL, builder.token))

        if (!expression.isExplicitSmartCastInfoTarget) return null

        val possibleFunctionCall = expression.getPossiblyQualifiedCallExpressionForCallee() ?: expression

        return when (val firExpression = possibleFunctionCall.getOrBuildFir(analysisSession.firResolveSession)) {
            is FirSmartCastExpression -> firExpression
            is FirSafeCallExpression -> firExpression.selector as? FirSmartCastExpression

        val creator = conversions[diagnostic.factory] ?: buildCreatorForPluginDiagnostic(diagnostic.factory)

        @Suppress("UNCHECKED_CAST")
        return with(analysisSession) {
            when (creator) {
                is KtFirDiagnostic0Creator -> with(creator) {
                    create(diagnostic as KtSimpleDiagnostic)
                }

        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()
            is TypeAliasDescriptor -> getClassInternalName(declaration.expandedType.constructor)

        analysisSession: KtAnalysisSession,
        referenceTargetSymbols: Collection<KtSymbol>,
    ): Collection<PsiElement> = with(analysisSession) {
        referenceTargetSymbols.flatMap { symbol ->
            when (symbol) {
                is KtFirSyntheticJavaPropertySymbol -> listOfNotNull(symbol.javaGetterSymbol.psi, symbol.javaSetterSymbol?.psi)
                is KtFirSymbol<*> -> getPsiDeclarations(symbol)

    ): KtCompilationResult {
        if (file is KtCodeFragment) {
            throw UnsupportedOperationException("Code fragments are not supported in K1 implementation")
        }

        val classBuilderFactory = when (target) {
            is KtCompilerTarget.Jvm -> target.classBuilderFactory
        }

        val effectiveConfiguration = configuration
            .copy()
            .apply {

    private val _callableNames: Set<Name> by cached {
        val result = mutableSetOf<Name>()
        owner.firSymbol.fir.declarations
            .mapNotNullTo(result) { firDeclaration ->
                when (firDeclaration) {
                    is FirSimpleFunction -> firDeclaration.name
                    is FirProperty -> firDeclaration.name
                    else -> null
                }
            }

    )

    override fun visitReturnsEffectDeclaration(
        returnsEffect: ReturnsEffectDeclaration,
        data: Unit
    ): KtContractReturnsContractEffectDeclaration =
        when (val value = returnsEffect.value) {
            ConstantReference.NULL ->
                KtContractReturnsSpecificValueEffectDeclaration(KtContractConstantValue(KtContractConstantType.NULL, analysisContext.token))

    fun getResolvedToPsi(analysisSession: KtAnalysisSession, referenceTargetSymbols: Collection<KtSymbol>): Collection<PsiElement> =
        with(analysisSession) {
            referenceTargetSymbols.flatMap { symbol ->
                when (symbol) {
                    is KtFirSymbol<*> -> getPsiDeclarations(symbol)
                    else -> listOfNotNull(symbol.psi)
                }
            }
        }