}
        println("}")
        println()

        println("private fun $CONVERT_ARGUMENT(argument: Any?, firSymbolBuilder: KtSymbolByFirBuilder): Any? {")
        withIndent {
            println("return when (argument) {")
            withIndent {
                println("null -> null")
                for (type in convertersMap.keys) {

        if (symbol is KtFirPsiJavaClassSymbol && !symbol.mayHaveDeprecation()) {
            return null
        }

        return when (val firSymbol = symbol.firSymbol) {
            is FirPropertySymbol -> {
                firSymbol.getDeprecationForCallSite(analysisSession.useSiteSession, AnnotationUseSiteTarget.PROPERTY)
            }

            currentExpression == ifExpression.then || currentExpression == ifExpression.`else`
        } ?: return null
        getExpectedType(ifExpression)?.let { return it }

        // if `KtIfExpression` doesn't have an expected type, get the expected type of the current branch from the other branch
        val otherBranch = (if (expression == ifExpression.then) ifExpression.`else` else ifExpression.then) ?: return null

            // Parentheses are ignored for this analysis.
            is KtParenthesizedExpression ->
                doesParentUseChild(parent.parent, parent)

            // When expressions use the subject expression _unless_ the first branch in the
            // when is an `else`.
            is KtWhenExpression ->
                parent.subjectExpression == child && parent.entries.firstOrNull()?.isElse == false

            // treated as a property read.
            return resolveCall(parentBinaryExpression)
        }

        if (psi is KtCallableReferenceExpression) {
            return resolveCall(psi.callableReference)
        }

        when (unwrappedPsi) {
            is KtBinaryExpression -> {

    fun evaluate(
        fir: FirElement?,
        mode: KtConstantEvaluationMode,
    ): FirLiteralExpression<*>? =
        when (fir) {
            is FirPropertyAccessExpression -> {
                when (val referredVariable = fir.calleeReference.toResolvedVariableSymbol()) {
                    is FirPropertySymbol -> {
                        if (referredVariable.callableId.isStringLength) {

    ): KtConstantAnnotationValue? {
        val expression = psi as? KtElement

        @OptIn(UnresolvedExpressionTypeAccess::class)
        val type = coneTypeOrNull
        val constantValue = when {
            value == null -> KtConstantValue.KtNullConstantValue(expression)
            type == null -> KtConstantValueFactory.createConstantValue(value, psi as? KtElement)

    }
}

private val FirErrorNamedReference.unresolvedName: Name?
    get() = when (val diagnostic = diagnostic) {
        is ConeUnresolvedError -> diagnostic.unresolvedName
        is ConeAmbiguityError -> diagnostic.name
        else -> null
    }

private val ConeUnresolvedError.unresolvedName: Name?
    get() = when (this) {
        is ConeUnresolvedNameError -> name
        is ConeUnresolvedReferenceError -> name

     */
    private fun KtFirPsiJavaClassSymbol.isVisibleByPsi(useSiteFile: KtFirFileSymbol): Boolean? {
        when (visibility) {
            Visibilities.Private ->
                // Private classes from Java cannot be accessed from Kotlin.
                return false

            Visibilities.Public ->
                return when (val outerClass = this.outerClass) {
                    null -> true

            when (psi) {
                is KtEnumEntry -> invalidEnumEntryAsClassKind()
                is KtObjectDeclaration -> when {
                    psi.isCompanion() -> KtClassKind.COMPANION_OBJECT
                    psi.isObjectLiteral() -> KtClassKind.ANONYMOUS_OBJECT
                    else -> KtClassKind.OBJECT
                }
                is KtClass -> when {