proc_macro_assertions::assert

Struct Assert

pub struct Assert<'a, T, A>where
    T: Generatable<'a, A>,
    A: 'a + TidAble<'a>,{
    pub template: MaybeBorrowed<'a, T>,
    pub assert: MaybeBorrowed<'a, A>,
}

Expand description

One of the Assert types provided by the crate, at this point in time also the only one.

This is backed by some template that the the type is checked against.

Every template must implement Generatable so that it can be turned into tokens that actually check if the type matches the template.

Further information about the structure of this crate can be found in the module documentation.

Fields§

§template: MaybeBorrowed<'a, T>§assert: MaybeBorrowed<'a, A>

Trait Implementations§

impl<'a, T, A> Assertable<'a> for Assert<'a, T, A>
where T: Generatable<'a, A> + Eq + Ord, A: Eq + Ord + TidAble<'a>,

type Output = RawAssert<'a, T, A>

The other assertable type the assert should be turned into. Read more

fn do_assert(self) -> Self::Output

impl<'a, Gen, A> AttachGenerics<'a> for Assert<'a, Gen, A>
where Gen: Generatable<'a, A>, A: 'a + TidAble<'a>,

type Output = Assert<'a, Gen, A>

An optional type wrapper around the type the generics will be attached to Used by this crate to wrap types with MaybeBorrowed to allow both references and owned types to be represented by the same type.

fn with_optional_generics<G>( self, generics: Option<G>, ) -> WithGenerics<'a, Self::Output>
where G: Into<MaybeBorrowed<'a, Generics>>,

fn with_generics<G>(self, generics: G) -> WithGenerics<'a, Self::Output>
where G: Into<MaybeBorrowed<'a, Generics>>, Self: Sized,

Attach some generics G to Self. This allows for the generics to to not exactly be syn::Generics but any type that can be turned into MaybeBorrowed<syn::Generics>. This allows for both &syn::Generics and syn::Generics to be attached using the same trait.

Auto Trait Implementations§

impl<'a, T, A> Freeze for Assert<'a, T, A>
where T: Freeze, A: Freeze,

impl<'a, T, A> RefUnwindSafe for Assert<'a, T, A>
where T: RefUnwindSafe, A: RefUnwindSafe,

impl<'a, T, A> Send for Assert<'a, T, A>
where T: Send + Sync, A: Send + Sync,

impl<'a, T, A> Sync for Assert<'a, T, A>
where T: Sync, A: Sync,

impl<'a, T, A> Unpin for Assert<'a, T, A>
where T: Unpin, A: Unpin,

impl<'a, T, A> UnwindSafe for Assert<'a, T, A>
where T: UnwindSafe + RefUnwindSafe, A: UnwindSafe + RefUnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> AnyExt for T
where T: Any + ?Sized,

fn downcast_ref<T>(this: &Self) -> Option<&T>
where T: Any,

Attempts to downcast this to T behind reference

fn downcast_mut<T>(this: &mut Self) -> Option<&mut T>
where T: Any,

Attempts to downcast this to T behind mutable reference

fn downcast_rc<T>(this: Rc<Self>) -> Result<Rc<T>, Rc<Self>>
where T: Any,

Attempts to downcast this to T behind Rc pointer

fn downcast_arc<T>(this: Arc<Self>) -> Result<Arc<T>, Arc<Self>>
where T: Any,

Attempts to downcast this to T behind Arc pointer

fn downcast_box<T>(this: Box<Self>) -> Result<Box<T>, Box<Self>>
where T: Any,

Attempts to downcast this to T behind Box pointer

fn downcast_move<T>(this: Self) -> Option<T>
where T: Any, Self: Sized,

Attempts to downcast owned Self to T, useful only in generic context as a workaround for specialization

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<'a, A> RawAssertable<'a> for A
where A: Assertable<'a>,

fn do_raw_assert<I>(self, store: &mut Store<'a, I>)
where I: IdentGenerator,

impl<'a, T, U> ResolveBounds<'a, T> for U
where T: AssertableWithBounds<'a, U> + 'a,

fn resolve_for( self, assertable: impl Into<MaybeBorrowed<'a, T>>, ) -> ResolvedBounds<'a, U, T>

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<T> TypeEq for T
where T: ?Sized,

type This = T