require(this is TypeParameterDescriptor)

        for (upperBound in upperBounds) {
            val declaration = upperBound.constructor.declarationDescriptor as? ClassDescriptor ?: continue
            if (declaration.kind != ClassKind.INTERFACE && declaration.kind != ClassKind.ANNOTATION_CLASS) {
                return upperBound
            }
        }

            printer {
                append('(')
                typeRenderer.renderType(analysisSession, type.lowerBound, printer)
                append("..")
                typeRenderer.renderType(analysisSession, type.upperBound, printer)
                append(')')
            }
        }
    }

    public object AS_SHORT : KaFlexibleTypeRenderer {
        override fun renderType(
            analysisSession: KaSession,

) : KaFlexibleType(), KaFe10Type {
    override val lowerBound: KaType
        get() = withValidityAssertion { fe10Type.lowerBound.toKtType(analysisContext) }

    override val upperBound: KaType
        get() = withValidityAssertion { fe10Type.upperBound.toKtType(analysisContext) }

    override val nullability: KaTypeNullability
        get() = withValidityAssertion { fe10Type.ktNullability }

    override val lowerBound: KaType get() = withValidityAssertion { builder.typeBuilder.buildKtType(coneType.lowerBound) }
    override val upperBound: KaType get() = withValidityAssertion { builder.typeBuilder.buildKtType(coneType.upperBound) }
    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }

org.checkerframework.checker.index.qual
org.checkerframework.checker.index.samelen
org.checkerframework.checker.index.searchindex
org.checkerframework.checker.index.substringindex
org.checkerframework.checker.index.upperbound
org.checkerframework.checker.initialization
org.checkerframework.checker.initialization.qual
org.checkerframework.checker.interning
org.checkerframework.checker.interning.qual
org.checkerframework.checker.linear

        isParameterized ->
            "$parameterizedTypeDefinition<${actualTypeArguments.joinToString(transform = ::kotlinTypeStringFor)}>"
        isWildcard ->
            (upperBound ?: lowerBound)?.let(::kotlinTypeStringFor) ?: "Any"
        else ->
            toString().let { primitiveTypeStrings[it] ?: it }
    }

/**
 * A flexible type's [abbreviatedType] is always `null`, as only [lowerBound] and [upperBound] may actually be expanded types.
 */
public abstract class KaFlexibleType : KaType {
    public abstract val lowerBound: KaType
    public abstract val upperBound: KaType
}

public typealias KtFlexibleType = KaFlexibleType

public abstract class KaIntersectionType : KaType {

internal
fun newTypeParameterOf(
    flags: Flags = 0,
    name: String,
    id: Int = 0,
    variance: KmVariance,
    upperBound: KmType,
): KmTypeParameter {
    val kmTypeParameter = KmTypeParameter(flags, name, id, variance)
    kmTypeParameter.upperBounds += upperBound
    return kmTypeParameter
}


internal

        return when (this) {
            // We also need to collect those on `upperBound` due to nullability.
            is ConeFlexibleType -> lowerBound.getDirectSuperTypes(shouldApproximate) + upperBound.getDirectSuperTypes(shouldApproximate)
            is ConeDefinitelyNotNullType -> original.getDirectSuperTypes(shouldApproximate).map {

        withValidityAssertion { analysisSession.typeProvider.withNullability(this, newNullability) }

    public fun KaType.upperBoundIfFlexible(): KaType = withValidityAssertion { (this as? KaFlexibleType)?.upperBound ?: this }
    public fun KaType.lowerBoundIfFlexible(): KaType = withValidityAssertion { (this as? KaFlexibleType)?.lowerBound ?: this }