import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext.eraseContainingTypeParameters
import org.jetbrains.kotlin.types.error.ErrorType
import org.jetbrains.kotlin.types.error.ErrorTypeKind
import org.jetbrains.kotlin.types.error.ErrorUtils

internal val MemberDescriptor.ktSymbolKind: KtSymbolKind
    get() {
        return when (this) {

import org.jetbrains.kotlin.types.StarProjectionImpl
import org.jetbrains.kotlin.types.TypeProjectionImpl
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.types.error.ErrorTypeKind
import org.jetbrains.kotlin.types.error.ErrorUtils
import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull

internal class KtFe10TypeCreator(
    override val analysisSession: KtFe10AnalysisSession

        return KtFe10AnalysisHandlerExtension.getInstance(project, ktModule)
    }

    private fun <T : Any> T?.orThrowResolutionNotPerformedError(): T =
        this ?: error("Resolution is not performed")
}

class KtFe10AnalysisHandlerExtension(
    private val useSiteModule: KtSourceModule? = null
) : AnalysisHandlerExtension {
    internal companion object {

import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.types.*
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

            append('@')
            val rendered = if (renderAnnotationWithShortNames) annotation.fqName?.shortName()?.render() else annotation.fqName?.render()
            append(rendered ?: "ERROR")

            val valueArguments = annotation.allValueArguments.entries.sortedBy { it.key.asString() }
            printCollectionIfNotEmpty(valueArguments, separator = ", ", prefix = "(", postfix = ")") { (name, value) ->

) : KtReceiverParameterSymbol(), KtFe10DescSymbol<ReceiverParameterDescriptor> {

    override val type: KtType
        get() = withValidityAssertion {
            descriptor.returnType?.toKtType(analysisContext) ?: error("expect return type for $descriptor")
        }

    override val owningCallableSymbol: KtCallableSymbol
        get() = withValidityAssertion { descriptor.containingDeclaration.toKtSymbol(analysisContext) as KtCallableSymbol }

            ConeContractConstantValues.TRUE -> KtContractBooleanConstantExpression(true, builder.token)
            ConeContractConstantValues.FALSE -> KtContractBooleanConstantExpression(false, builder.token)
            else -> error("Can't convert $booleanConstantDescriptor to Analysis API")
        }

    override fun visitValueParameterReference(
        valueParameterReference: ConeValueParameterReference,
        data: Unit

                    create(diagnostic as KtDiagnosticWithParameters4<Any?, Any?, Any?, Any?>)
                }
                else -> error("Invalid KtFirDiagnosticCreator ${creator::class.simpleName}")
            }
        }
    }

    @Suppress("RemoveExplicitTypeArguments") // See KT-52838

        return buildList {
            for (diagnostic in diagnostics.all()) {
                if (diagnostic.severity == Severity.ERROR) {
                    val ktDiagnostic = KtFe10Diagnostic(diagnostic, token)
                    if (!allowedErrorFilter(ktDiagnostic)) {
                        add(ktDiagnostic)
                    }
                }

    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnsupportedSuspendTest

internal class NewInferenceErrorImpl(
    override val error: String,
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NewInferenceError

internal class OtherErrorImpl(