typeProjection.projectionKind == Variance.INVARIANT -> {
                    when (typeParameter.variance) {
                        Variance.IN_VARIANCE -> BoundTypeArgument(typeProjection.type, Variance.IN_VARIANCE)
                        Variance.OUT_VARIANCE -> BoundTypeArgument(typeProjection.type, Variance.OUT_VARIANCE)
                        else -> BoundTypeArgument(typeProjection.type, Variance.INVARIANT)
                    }

        return Map::class.createType(
            arguments = listOf(
                KTypeProjection(
                    variance = KVariance.INVARIANT,
                    type = keyArgument.type?.let(mappingConversionForKeys::convertType)
                ),
                KTypeProjection(
                    variance = KVariance.INVARIANT,
                    type = valueArgument.type?.let(mappingConversionForValues::convertType)
                )

        ApiTypeUsage(
            sourceName,
            isNullable,
            type(sourceName),
            variance,
            typeArguments.map { apiTypeUsageFor(it.binaryName, variance = it.variance, typeArguments = it.typeArguments) },
            bounds.map { apiTypeUsageFor(it.binaryName, variance = it.variance, typeArguments = it.typeArguments) }
        )
    }


internal
val ApiTypeUsage.isStarProjectionTypeUsage

        val bindingContext = analysisContext.analyze(psi)
        bindingContext[BindingContext.TYPE_PARAMETER, psi]
    }

    override val variance: Variance
        get() = withValidityAssertion { psi.variance }

    override val upperBounds: List<KtType>
        get() = withValidityAssertion {

            } else {
                when (projection.projectionKind) {
                    Variance.INVARIANT -> renderType(projection.type, printer)
                    Variance.IN_VARIANCE -> {
                        append("in ")
                        renderType(projection.type, printer)
                    }
                    Variance.OUT_VARIANCE -> {
                        append("out ")

                token,
            )
        }

        private fun ProjectionKind.toVariance(): Variance = when (this) {
            ProjectionKind.OUT -> Variance.OUT_VARIANCE
            ProjectionKind.IN -> Variance.IN_VARIANCE
            ProjectionKind.INVARIANT -> Variance.INVARIANT
            ProjectionKind.STAR -> error("KtStarProjectionTypeArgument should not be directly created")
        }

    override val upperBounds: List<KtType>
        get() = withValidityAssertion { descriptor.upperBounds.filterNot { it.isNullableAny() }.map { it.toKtType(analysisContext) } }

    override val variance: Variance
        get() = withValidityAssertion { descriptor.variance }

    override val isReified: Boolean
        get() = withValidityAssertion { descriptor.isReified }

private
fun ApiTypeUsage.toTypeArgumentString(): String =
    "${variance.toKotlinString()}$sourceName${typeArguments.toTypeArgumentsString(type)}${isNullable.toKotlinNullabilityString()}"


private
fun Variance.toKotlinString() =
    when (this) {
        Variance.INVARIANT -> ""
        Variance.COVARIANT -> "out "
        Variance.CONTRAVARIANT -> "in "
    }


private

        get() = when (this) {
            is KtStarTypeProjection -> ConeStarProjection
            is KtTypeArgumentWithVariance -> {
                typeContext.createTypeArgument(type.coneType, variance.convertVariance()) as ConeTypeProjection
            }
        }

    fun createTypeCheckerContext(): TypeCheckerState {
        // TODO use correct session here,

            substitutions[parameterTypeConstructor] = TypeProjectionImpl(arguments[index] as KotlinType)
        }

        return TypeSubstitutor.create(substitutions).substitute(declaration.defaultType, Variance.INVARIANT) as SimpleType
    }

    override fun TypeParameterMarker.representativeUpperBound(): KotlinTypeMarker {
        require(this is TypeParameterDescriptor)

        for (upperBound in upperBounds) {