* provides symbol names from binary libraries in Standalone mode, which the Standalone declaration provider does not contain (to avoid
 * stub-indexing binary libraries). And in general, querying the symbol names provider might be faster since its sets are cached, which is
 * not necessarily the case for declaration providers (e.g. the IDE declaration provider hitting the index without caching).
 *

    override fun getDiagnosticsForElement(
        element: KtElement,
        filter: KaDiagnosticCheckerFilter
    ): Collection<KaDiagnosticWithPsi<*>> {
        return element.getDiagnostics(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }
    }

    override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KaDiagnosticCheckerFilter): Collection<KaDiagnosticWithPsi<*>> =

        super.getClassifierSymbols(nameFilter).filter { it is KaNamedClassOrObjectSymbol && it.isInner }

    override fun getCallableSymbols(nameFilter: KaScopeNameFilter): Sequence<KaCallableSymbol> = withValidityAssertion {
        super.getCallableSymbols(nameFilter).filter { symbol ->
            when (symbol) {
                is KaFunctionSymbol -> !symbol.isStatic

            with(analysisSession) {
                return symbol.getCombinedDeclaredMemberScope().getAllSymbols()
                    .filter { member ->
                        val origin = member.origin
                        origin != KaSymbolOrigin.DELEGATED &&
                                origin != KaSymbolOrigin.SOURCE_MEMBER_GENERATED &&

            owner: KaAnnotated,
            annotationRenderer: KaAnnotationRenderer,
            printer: PrettyPrinter,
        ) {
            val annotations = owner.annotations
                .filter { annotationRenderer.annotationFilter.filter(analysisSession, it, owner) }
                .ifEmpty { return }

            printer.printCollection(
                annotations,
                separator = when (owner) {

    override fun getCallableSymbols(nameFilter: KaScopeNameFilter): Sequence<KaCallableSymbol> = withValidityAssertion {
        firScope.getCallableSymbols(getPossibleCallableNames().filter(nameFilter), builder)
    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KaCallableSymbol> = withValidityAssertion {
        firScope.getCallableSymbols(names, builder)
    }

import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtClass
import org.jetbrains.kotlin.psi.KtClassOrObject
import org.jetbrains.kotlin.psi.psiUtil.contains
import kotlin.collections.filter

@OptIn(LLFirInternals::class, SymbolInternals::class)
internal class KotlinStandaloneFirDirectInheritorsProvider(private val project: Project) : KotlinDirectInheritorsProvider {

        return ExpectedActualResolver.findExpectedForActual(memberDescriptor).orEmpty().asSequence()
            .filter { it.key.isCompatibleOrWeaklyIncompatible }
            .flatMap { it.value }
            .map { it.toKtSymbol(analysisContext) as KaDeclarationSymbol }
            .toList()
    }

     *
     * To check if annotation is present, please use [contains].
     *
     * The semantic is equivalent to
     * ```
     * annotationsList.annotationsByClassId(classId) == annotationsList.annotations.filter { it.classId == classId }
     * ```
     */
    public operator fun get(classId: ClassId): List<KaAnnotation>

    @Deprecated("Use 'get' instead.", replaceWith = ReplaceWith("get(classId)"))

).renderElementAsString(this)

private object MinimalConeTypeAttributeRenderer : ConeAttributeRenderer() {
    override fun render(attributes: Iterable<ConeAttribute<*>>): String =
        attributes.filter { it.isImportant }.let(ToString::render)

    private val ConeAttribute<*>.isImportant get() = this is AbbreviatedTypeAttribute