pub struct TraitDef<'a> {
    pub span: Span,
    pub path: Path,
    pub skip_path_as_bound: bool,
    pub needs_copy_as_bound_if_packed: bool,
    pub additional_bounds: Vec<Ty>,
    pub supports_unions: bool,
    pub methods: Vec<MethodDef<'a>>,
    pub associated_types: Vec<(Ident, Ty)>,
    pub is_const: bool,
}

Fields§

§span: Span

The span for the current #[derive(Foo)] header.

§path: Path

Path of the trait, including any type parameters

§skip_path_as_bound: bool

Whether to skip adding the current trait as a bound to the type parameters of the type.

§needs_copy_as_bound_if_packed: bool

Whether Copy is needed as an additional bound on type parameters in a packed struct.

§additional_bounds: Vec<Ty>

Additional bounds required of any type parameters of the type, other than the current trait

§supports_unions: bool

Can this trait be derived for unions?

§methods: Vec<MethodDef<'a>>§associated_types: Vec<(Ident, Ty)>§is_const: bool

Implementations§

source§

impl<'a> TraitDef<'a>

source

pub fn expand( self, cx: &mut ExtCtxt<'_>, mitem: &MetaItem, item: &'a Annotatable, push: &mut dyn FnMut(Annotatable) )

source

pub fn expand_ext( self, cx: &mut ExtCtxt<'_>, mitem: &MetaItem, item: &'a Annotatable, push: &mut dyn FnMut(Annotatable), from_scratch: bool )

source

fn create_derived_impl( &self, cx: &mut ExtCtxt<'_>, type_ident: Ident, generics: &Generics, field_tys: Vec<P<Ty>>, methods: Vec<P<AssocItem>>, is_packed: bool ) -> P<Item>

Given that we are deriving a trait DerivedTrait for a type like:

struct Struct<'a, ..., 'z, A, B: DeclaredTrait, C, ..., Z> where C: WhereTrait {
    a: A,
    b: B::Item,
    b1: <B as DeclaredTrait>::Item,
    c1: <C as WhereTrait>::Item,
    c2: Option<<C as WhereTrait>::Item>,
    ...
}

create an impl like:

impl<'a, ..., 'z, A, B: DeclaredTrait, C, ... Z> where
    C:                       WhereTrait,
    A: DerivedTrait + B1 + ... + BN,
    B: DerivedTrait + B1 + ... + BN,
    C: DerivedTrait + B1 + ... + BN,
    B::Item:                 DerivedTrait + B1 + ... + BN,
    <C as WhereTrait>::Item: DerivedTrait + B1 + ... + BN,
    ...
{
    ...
}

where B1, …, BN are the bounds given by bounds_paths.’. Z is a phantom type, and therefore does not get bound by the derived trait.

source

fn expand_struct_def( &self, cx: &mut ExtCtxt<'_>, struct_def: &'a VariantData, type_ident: Ident, generics: &Generics, from_scratch: bool, is_packed: bool ) -> P<Item>

source

fn expand_enum_def( &self, cx: &mut ExtCtxt<'_>, enum_def: &'a EnumDef, type_ident: Ident, generics: &Generics, from_scratch: bool ) -> P<Item>

source§

impl<'a> TraitDef<'a>

source

fn summarise_struct( &self, cx: &mut ExtCtxt<'_>, struct_def: &VariantData ) -> StaticFields

source

fn create_struct_patterns( &self, cx: &mut ExtCtxt<'_>, struct_path: Path, struct_def: &'a VariantData, prefixes: &[String], by_ref: ByRef ) -> ThinVec<P<Pat>>

source

fn create_fields<F>( &self, struct_def: &'a VariantData, mk_exprs: F ) -> Vec<FieldInfo>where F: Fn(usize, &FieldDef, Span) -> Vec<P<Expr>>,

source

fn mk_pattern_ident(&self, prefix: &str, i: usize) -> Ident

source

fn create_struct_pattern_fields( &self, cx: &mut ExtCtxt<'_>, struct_def: &'a VariantData, prefixes: &[String] ) -> Vec<FieldInfo>

source

fn create_struct_field_access_fields( &self, cx: &mut ExtCtxt<'_>, selflike_args: &[P<Expr>], struct_def: &'a VariantData, is_packed: bool ) -> Vec<FieldInfo>

Auto Trait Implementations§

§

impl<'a> !RefUnwindSafe for TraitDef<'a>

§

impl<'a> !Send for TraitDef<'a>

§

impl<'a> !Sync for TraitDef<'a>

§

impl<'a> Unpin for TraitDef<'a>

§

impl<'a> !UnwindSafe for TraitDef<'a>

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

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

source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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

§

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

The type returned in the event of a conversion error.
source§

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

Performs the conversion.

Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 144 bytes