@OptIn(UnexpandedTypeCheck::class)
    override val upperBounds: List<KaType> by cached {
        firSymbol.resolvedBounds.mapNotNull { type ->
            if (type.isNullableAny) return@mapNotNull null
            builder.typeBuilder.buildKtType(type)
        }
    }

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

    private val builder: KaSymbolByFirBuilder,
) : KaDefinitelyNotNullType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token
    override val original: KaType = withValidityAssertion { builder.typeBuilder.buildKtType(this.coneType.original) }
    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }

    override val abbreviatedType: KaUsualClassType?

                    KaClassTypeQualifier.KaUnresolvedClassTypeQualifier(
                        part.name,
                        part.typeArgumentList.typeArguments.map { builder.typeBuilder.buildTypeProjection(it.toConeTypeProjection()) },
                        builder.token
                    )
                }

            is ConeUnresolvedNameError -> listOf(

    override val nullability: KaTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }

    override val projection: KaTypeProjection
        get() = withValidityAssertion { builder.typeBuilder.buildTypeProjection(coneType.constructor.projection) }

    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }

) : KaIntersectionType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token

    override val conjuncts: List<KaType> by cached {
        coneType.intersectedTypes.map { conjunct -> builder.typeBuilder.buildKtType(conjunct) }
    }
    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }

                @ComponentType
                void register1(TypeBuilder<UnmanagedComponentSpec> builder) {
                    builder.defaultImplementation(DefaultUnmanagedComponentSpec)
                }

                @ComponentType
                void register2(TypeBuilder<SampleComponentSpec> builder) {
                    builder.internalView(InternalSampleSpec)
                }

        // `KaType.abbreviatedType`, we should return `null` in such cases. The user can then fall back to the expanded type.
        typeBuilder.buildKtType(abbreviatedConeType) as? KaUsualClassType
    }

        return when (substitutors.size) {
            0 -> KaSubstitutor.Empty(token)
            else -> {
                val chained = substitutors.reduce { left, right -> left.chain(right) }
                firSymbolBuilder.typeBuilder.buildSubstitutor(chained)
            }
        }
    }


    private fun collectInheritancePath(
        baseSymbol: FirClassSymbol<*>,
        superSymbol: FirClassSymbol<*>,

    override val nullableNothing: KaType by cachedBuiltin(builtinTypes.nullableNothingType)

    private fun cachedBuiltin(builtinTypeRef: FirImplicitBuiltinTypeRef): ValidityAwareCachedValue<KaType> = cached {
        builder.typeBuilder.buildKtType(builtinTypeRef)
    }

}

private fun convertArgument(argument: ConeKotlinType, firSymbolBuilder: KaSymbolByFirBuilder): Any? {
    return firSymbolBuilder.typeBuilder.buildKtType(argument)
}

private fun convertArgument(argument: FirTypeRef, firSymbolBuilder: KaSymbolByFirBuilder): Any? {
    return firSymbolBuilder.typeBuilder.buildKtType(argument)
}

private fun convertArgument(argument: KtSourceElement, firSymbolBuilder: KaSymbolByFirBuilder): Any? {