private val builder: KaSymbolByFirBuilder,
) : AbstractList<KaAnnotation>(), KaAnnotationList {
    private val backingAnnotations by lazy { annotations(firSymbol, builder) }

    override val token: KaLifetimeToken
        get() = builder.token

    private val useSiteSession: FirSession
        get() = builder.rootSession

    override fun isEmpty(): Boolean = withValidityAssertion {

                    add(annotationDescriptor.toKaAnnotation(analysisContext, index))
                }
            }
        }
    }

    override val token: KaLifetimeToken
        get() = analysisContext.token

    override fun isEmpty(): Boolean = withValidityAssertion {
        return if (ignoredAnnotations.isEmpty()) {
            fe10Annotations.isEmpty()
        } else {

    public abstract val type: KaType?
}

public class KaStarTypeProjection(override val token: KaLifetimeToken) : KaTypeProjection() {
    override val type: KaType? get() = withValidityAssertion { null }
}

public class KaTypeArgumentWithVariance(
    type: KaType,
    variance: Variance,
    override val token: KaLifetimeToken,
) : KaTypeProjection() {
    override val type: KaType by validityAsserted(type)

    public val typeArguments: List<KaTypeProjection>

    public class KaResolvedClassTypeQualifier(
        private val backingSymbol: KaClassifierSymbol,
        typeArguments: List<KaTypeProjection>,
        override val token: KaLifetimeToken
    ) : KaClassTypeQualifier {
        override val name: Name get() = withValidityAssertion { backingSymbol.nameOrAnonymous }

internal class KaFirCapturedType(
    override val coneType: ConeCapturedType,
    private val builder: KaSymbolByFirBuilder,
) : KaCapturedType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token
    override val nullability: KaTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }

    override val projection: KaTypeProjection

internal class KaFirDefinitelyNotNullType(
    override val coneType: ConeDefinitelyNotNullType,
    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 {

                    StandardClassIds.Annotations.ContextFunctionTypeParams,
                )
            )
        }

    override val token: KaLifetimeToken
        get() = analysisContext.token
}

internal fun KotlinType.renderForDebugging(analysisContext: Fe10AnalysisContext): String {
    val renderer = KaFe10DebugTypeRenderer()

internal class KaFe10CompileTimeConstantProvider(
    override val analysisSession: KaFe10Session
) : KaCompileTimeConstantProvider(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun evaluate(expression: KtExpression): KaConstantValue? {
        val bindingContext = analysisContext.analyze(expression)

            ?: KaFe10NeverRestoringSymbolPointer()
    }

    override val returnType: KaType
        get() = withValidityAssertion { owningProperty.returnType }

    override val token: KaLifetimeToken
        get() = owningProperty.token

    override val annotations: KaAnnotationList
        get() = withValidityAssertion {
            KaFe10AnnotationList.create(fieldDescriptor?.annotations ?: Annotations.EMPTY, analysisContext)

internal class KaFirDynamicType(
    override val coneType: ConeDynamicType,
    private val builder: KaSymbolByFirBuilder,
) : KaDynamicType(), KaFirType {
    override val token: KaLifetimeToken get() = builder.token
    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }