/**
     * Gets all the super types of the given type. The returned result is ordered by a BFS traversal of the class hierarchy, without any
     * duplicates.
     *
     * @param shouldApproximate see [getDirectSuperTypes]
     */
    public fun KaType.getAllSuperTypes(shouldApproximate: Boolean = false): List<KaType> =

 * not necessarily the case for declaration providers (e.g. the IDE declaration provider hitting the index without caching).
 *
 * However, since symbol names providers may not be able to compute name sets per their contract, we may have to fall back to the

            KaRendererKeywordFilter { modifier, _ -> modifier in modifiers }

        public fun without(vararg modifiers: KtKeywordToken): KaRendererKeywordFilter =
            KaRendererKeywordFilter { modifier, _ -> modifier !in modifiers }

        public fun without(modifiers: TokenSet): KaRendererKeywordFilter =
            KaRendererKeywordFilter { modifier, _ -> modifier !in modifiers }
    }
}

 * IDE Analysis API.
 *
 * [KotlinMessageBusProvider] exists so that this default may change in the future without breaking the API. Hence, it should not be assumed
 * that the message bus provided by [KotlinMessageBusProvider] will always be equal to the project's message bus.
 */

    override val name: Name
        get() = withValidityAssertion { descriptor.name }

    // There doesn't seem to be a way to determine if `descriptor` has a body or not, so we return an initializer even for enum entries
    // without a body.
    override val enumEntryInitializer: KaEnumEntryInitializerSymbol?
        get() = this

    override fun createPointer(): KaSymbolPointer<KaEnumEntrySymbol> = withValidityAssertion {

         * If a private property has no getter/setter (the typical situation for simple private properties without explicitly defined
         * getter/setter) then this method is not used at all. Instead
         * [org.jetbrains.kotlin.backend.jvm.lower.ReflectiveAccessLowering.visitGetField] (or visitSetField) generates the access without
         * asking.
         */

- [`KT-64308`](https://youtrack.jetbrains.com/issue/KT-64308) K2: prefer call with Unit conversion at lower level to one without Unit conversion at upper level
- [`KT-64307`](https://youtrack.jetbrains.com/issue/KT-64307) K2: prefer function with default arguments at lower level to one without them at upper level during callable reference resolve

                            keywordsRenderer = keywordsRenderer.with {
                                keywordFilter =
                                    keywordFilter and KaRendererKeywordFilter.without(KtTokens.VAL_KEYWORD, KtTokens.VAR_KEYWORD)
                            }
                        }
                        printCollection(symbol.entries, prefix = "(", postfix = ")") {

        // `NewKotlinTypeCheckerImpl` is inconsistent with its error type leniency: `isSubtypeOf` is lenient by default while `equalTypes`
        // isn't. Hence, even without a `LENIENT` policy, we need to wrap `typeChecker` to achieve consistent strictness.
        return IsErrorTypeEqualToAnythingTypeChecker(typeChecker, errorTypePolicy == KaSubtypingErrorTypePolicy.LENIENT)
    }

    }
}

public enum class ShortenStrategy {
    /** Skip shortening references to this symbol. */
    DO_NOT_SHORTEN,

    /**
     * Only shorten references to this symbol if it's possible without adding a new import directive to the file. Otherwise, leave it as
     * it is.
     *
     * Example:
     *   package a.b.c
     *   import foo.bar
     *   fun test() {}
     *   fun runFunctions() {