is CharValue -> KtConstantValue.KtCharConstantValue(value, sourcePsi = null)
        is IntValue -> KtConstantValue.KtIntConstantValue(value, sourcePsi = null)
        is LongValue -> KtConstantValue.KtLongConstantValue(value, sourcePsi = null)
        is ShortValue -> KtConstantValue.KtShortConstantValue(value, sourcePsi = null)

                    when (value) {
                        ConeContractConstantValues.TRUE -> KtContractConstantType.TRUE
                        ConeContractConstantValues.FALSE -> KtContractConstantType.FALSE
                        else -> errorWithAttachment("Can't convert ${value::class} to the Analysis API") {
                            withEntry("value", value) { value.toString() }
                        }

            printCollectionIfNotEmpty(valueArguments, separator = ", ", prefix = "(", postfix = ")") { (name, value) ->
                append(name.render())
                append(" = ")
                append(value.toKtAnnotationValue(analysisContext).renderAsSourceCode())
            }

            append(separator)
        }
    }

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

    override val name: Name
        get() = withValidityAssertion { descriptor?.name ?: Name.identifier("value") }

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

    }

    private fun renderConstantValueDebug(value: KtAnnotationValue, printer: PrettyPrinter) {
        when (value) {
            is KtAnnotationApplicationValue -> {
                renderAnnotationDebug(value.annotationValue.classId, value.annotationValue.arguments, printer)
            }

            is KtArrayAnnotationValue -> {
                printer.printCollection(value.values, separator = ", ", prefix = "[", postfix = "]") {

    )

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

        }

        val firSafeCall = parentCall.getOrBuildFirOfType<FirSafeCallExpression>(firResolveSession)
        return firSafeCall.checkedSubjectRef.value
    }
}

private class LazyKtCompletionExtensionCandidateChecker(
    delegateFactory: () -> KtCompletionExtensionCandidateChecker
) : KtCompletionExtensionCandidateChecker {

        override val isNoinline: Boolean
            get() = withValidityAssertion { false }

        override val name: Name
            get() = withValidityAssertion { Name.identifier("value") }

        override val returnType: KtType
            get() = withValidityAssertion { propertyDescriptor.type.toKtType(analysisContext) }

        override val origin: KtSymbolOrigin

        convertArgument(key, firSymbolBuilder)
    }.mapValues { (_, value) -> 
        convertArgument(value, firSymbolBuilder)
    }
}

private fun convertArgument(argument: Collection<*>, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
    return argument.map { value ->
        convertArgument(value, firSymbolBuilder)
    }
}

            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.VALUE_CLASS_NOT_TOP_LEVEL) { firDiagnostic ->
        ValueClassNotTopLevelImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.VALUE_CLASS_NOT_FINAL) { firDiagnostic ->
        ValueClassNotFinalImpl(
            firDiagnostic as KtPsiDiagnostic,