) {
            val annotations = owner.annotations
                .filter { annotationRenderer.annotationFilter.filter(analysisSession, it, owner) }
                .ifEmpty { return }

            printer.printCollection(
                annotations,
                separator = when (owner) {
                    is KaValueParameterSymbol -> " "
                    is KaDeclarationSymbol -> "\n"
                    else -> " "

        annotation: KaAnnotation,
        owner: KaAnnotated,
        annotationRenderer: KaAnnotationRenderer,
        printer: PrettyPrinter,
    )

    public object WITHOUT_USE_SITE : KaAnnotationUseSiteTargetRenderer {
        override fun renderUseSiteTarget(
            analysisSession: KaSession,
            annotation: KaAnnotation,
            owner: KaAnnotated,
            annotationRenderer: KaAnnotationRenderer,

    private val owner: FirJavaClass,
) : FirCallableFilteringScope(delegate) {
    init {
        // The `isDeclared` check is based on class IDs. Local classes don't have proper class IDs, but because this scope is used to
        // represent Java classes viewed from Kotlin code, we shouldn't be able to encounter any local Java classes.
        require(!owner.isLocal) {

import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
import org.jetbrains.kotlin.name.Name

internal class KaFirFileScope(
    private val owner: KaFirFileSymbol,
    private val builder: KaSymbolByFirBuilder
) : KaScope {
    override val token: KaLifetimeToken get() = builder.token

    private val allNamesCached by cached {

        analysisSession: KaSession,
        members: List<KaDeclarationSymbol>,
        owner: KaSymbolWithMembers,
    ): List<KaDeclarationSymbol>

    public object ENUM_ENTRIES_AT_BEGINING : KaRendererBodyMemberScopeSorter {
        override fun sortMembers(
            analysisSession: KaSession,
            members: List<KaDeclarationSymbol>,
            owner: KaSymbolWithMembers,
        ): List<KaDeclarationSymbol> {

        require(analysisSession is KaFirSession)
        val owner = analysisSession.getClassLikeSymbol(ownerClassId) as? FirRegularClass ?: return null
        val classSymbol = analysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(owner.symbol)
        with(analysisSession) {
            return classSymbol.getSamConstructor()
        }
    }

import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeOwner
import org.jetbrains.kotlin.name.ClassId

/**
 * A list of annotations applied for some entity.
 *
 * Annotation owners are usually implement [KaAnnotated]
 */
public interface KaAnnotationList : List<KaAnnotation>, KaLifetimeOwner {
    @Deprecated("Use the annotation list as a 'List'.")
    public val annotations: List<KaAnnotation>

    AnnotationTarget.CONSTRUCTOR,
    AnnotationTarget.FUNCTION,
    AnnotationTarget.TYPEALIAS
)
@RequiresOptIn("Internal Analysis API component which should not be used outside the Analysis API implementation modules as it does not have any compatibility guarantees")
public annotation class KaAnalysisApiInternals

@Suppress("OPT_IN_MARKER_CAN_ONLY_BE_USED_AS_ANNOTATION_OR_ARGUMENT_IN_OPT_IN")

/**
 * A candidate that is NOT applicable for a call. A candidate is inapplicable if a call argument is missing or is not assignable to the
 * candidate's parameters, OR a call type argument is missing or does not fit the constraints of the candidate's type parameters.
 */
public class KaInapplicableCallCandidateInfo(
    candidate: KaCall,
    isInBestCandidates: Boolean,
    diagnostic: KaDiagnostic,

     *         else -> {}
     *     }
     * }
     *
     * Note that this function returns the same missing cases regardless of the existence of the else branch.
     * If you have to assume that it does not have the missing cases when it has an else branch,
     * you need a separate check whether it has an else branch or not.
     */
    public fun KtWhenExpression.getMissingCases(): List<WhenMissingCase> =