Struct TraitDef

pub(crate) 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

impl<'a> TraitDef<'a>

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

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

fn create_derived_impl( &self, cx: &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.

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

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

impl<'a> TraitDef<'a>

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

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

fn create_fields<F>( &self, struct_def: &'a VariantData, mk_exprs: F, ) -> Vec<FieldInfo>

where F: Fn(usize, &FieldDef, Span) -> Vec<P<Expr>>,

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

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

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

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