*/
public sealed class KaAnnotationValue(override val token: KaLifetimeToken) : KaLifetimeOwner {
    public abstract val sourcePsi: KtElement?
}

public typealias KtAnnotationValue = KaAnnotationValue

/**
 * This represents an unsupported expression used as an annotation value.
 */
public class KaUnsupportedAnnotationValue @KaAnalysisApiInternals constructor(
    token: KaLifetimeToken
) : KaAnnotationValue(token) {

        backingArguments += KaTypeArgumentWithVariance(type, variance, type.token)
    }

    public class ByClassId(classId: ClassId, override val token: KaLifetimeToken) : KaClassTypeBuilder() {
        public val classId: ClassId by validityAsserted(classId)
    }

    public class BySymbol(symbol: KaClassLikeSymbol, override val token: KaLifetimeToken) : KaClassTypeBuilder() {

import kotlin.reflect.KClass

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

    override fun getDiagnosticsForElement(element: KtElement, filter: KaDiagnosticCheckerFilter): Collection<KaDiagnosticWithPsi<*>> {

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

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

    override fun isEmpty(): Boolean = withValidityAssertion {
        // isEmpty check is possible on a callable symbol directly as annotations cannot be moved from a containing

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

    override val origin: KaSymbolOrigin
        get() = withValidityAssertion { KaSymbolOrigin.JS_DYNAMIC }

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

    override val annotations: KaAnnotationList
        get() = withValidityAssertion { KaEmptyAnnotationList(token) }

    override val name: Name

                FirAnnotationValueConverter.toNamedConstantValue(builder.analysisSession, mapAnnotationParameters(firAnnotation), builder)
            }
        }
    }

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

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

    override fun isEmpty(): Boolean = withValidityAssertion {
        return coneType.customAnnotations.isEmpty()

    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 }