override val annotationsObject: Annotations
        get() = withValidityAssertion { descriptor.annotations }

    override val returnType: KtType
        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtType(analysisContext) }

    override fun createPointer(): KtSymbolPointer<KtBackingFieldSymbol> = withValidityAssertion {
        val accessorPsi = descriptor.containingDeclaration.toSourceElement.getPsi()

) : KtTypeAliasSymbol(), KtFe10PsiSymbol<KtTypeAlias, TypeAliasDescriptor> {
    override val descriptor: TypeAliasDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi)
        bindingContext[BindingContext.TYPE_ALIAS, psi]
    }

    override val name: Name
        get() = withValidityAssertion { psi.nameAsSafeName }

    override val typeParameters: List<KtTypeParameterSymbol>

/compiler/testData/serialization/klib/ "Kotlin Common Backend"
/compiler/testData/type/ "Kotlin Compiler Core"
/compiler/testData/typeQualifierNickname/ "Kotlin Compiler Core"
/compiler/testData/versionRequirement/ "Kotlin JVM"
/compiler/testData/writeFlags/ "Kotlin JVM"
/compiler/testData/writeSignature/ "Kotlin JVM"
/compiler/testData/type-checker-test.kt "Kotlin Compiler Core"
/compiler/testData/type-substitutor.kt "Kotlin Compiler Core"

        override val name: Name
            get() = withValidityAssertion { Name.identifier("value") }

        override val returnType: KtType
            get() = withValidityAssertion { propertyDescriptor.type.toKtType(analysisContext) }

        override val origin: KtSymbolOrigin
            get() = withValidityAssertion { propertyDescriptor.getSymbolOrigin(analysisContext) }

        override val psi: PsiElement?

    override val callableIdIfNonLocal: CallableId?
        get() = withValidityAssertion { psi.callableIdIfNonLocal }

    override val returnType: KtType
        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }

    override val receiverParameter: KtReceiverParameterSymbol?
        get() = withValidityAssertion {
            if (!psi.isExtensionDeclaration()) {

    }

    override fun getTypeScope(type: KtType): KtTypeScope? {
        check(type is KtFirType) { "KtFirScopeProvider can only work with KtFirType, but ${type::class} was provided" }
        return getFirTypeScope(type)
            ?.withSyntheticPropertiesScopeOrSelf(type.coneType)
            ?.let { convertToKtTypeScope(it) }
    }

    override fun getSyntheticJavaPropertiesScope(type: KtType): KtTypeScope? {

            token,
        )
    }
    add(FirErrors.ACTUAL_TYPE_ALIAS_TO_NULLABLE_TYPE) { firDiagnostic ->
        ActualTypeAliasToNullableTypeImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.ACTUAL_TYPE_ALIAS_TO_NOTHING) { firDiagnostic ->
        ActualTypeAliasToNothingImpl(
            firDiagnostic as KtPsiDiagnostic,

    }

    /**
     * Maps [typeArguments] to the type parameters of [partiallyAppliedSymbol].
     *
     * If too many type arguments are provided, a mapping is still created. Extra type arguments are simply ignored. If this wasn't the
     * case, the resulting [KtCall] would contain no type arguments at all, which can cause problems later. If too few type arguments are

        override val diagnosticClass get() = IncompatibleTypes::class
        val typeA: KtType
        val typeB: KtType
    }

    interface IncompatibleTypesWarning : KtFirDiagnostic<KtElement> {
        override val diagnosticClass get() = IncompatibleTypesWarning::class
        val typeA: KtType
        val typeB: KtType
    }

    interface TypeVarianceConflictError : KtFirDiagnostic<PsiElement> {

                else -> psi.nameAsSafeName
            }
        }
    override val returnType: KtType
        get() = withValidityAssertion { descriptor?.type?.toKtType(analysisContext) ?: createErrorType() }

    override val isVal: Boolean
        get() = withValidityAssertion { !psi.isVar }

    override val symbolKind: KtSymbolKind