Struct rustc_builtin_macros::deriving::generic::TraitDef

pub struct TraitDef<'a> {
    pub span: Span,
    pub path: Path,
    pub skip_path_as_bound: 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.

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 fn expand(
    self,
    cx: &mut ExtCtxt<'_>,
    mitem: &MetaItem,
    item: &'a Annotatable,
    push: &mut dyn FnMut(Annotatable)
)

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

fn create_derived_impl(
    &self,
    cx: &mut ExtCtxt<'_>,
    type_ident: Ident,
    generics: &Generics,
    field_tys: Vec<P<Ty>>,
    methods: Vec<P<AssocItem>>
) -> 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: &mut ExtCtxt<'_>,
    struct_def: &'a VariantData,
    type_ident: Ident,
    generics: &Generics,
    from_scratch: bool,
    copy_fields: bool
) -> P<Item>

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

impl<'a> TraitDef<'a>

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

fn create_struct_patterns(
    &self,
    cx: &mut ExtCtxt<'_>,
    struct_path: Path,
    struct_def: &'a VariantData,
    prefixes: &[String],
    by_ref: ByRef
) -> Vec<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: &mut ExtCtxt<'_>,
    struct_def: &'a VariantData,
    prefixes: &[String]
) -> Vec<FieldInfo>

fn create_struct_field_access_fields(
    &self,
    cx: &mut ExtCtxt<'_>,
    selflike_args: &[P<Expr>],
    struct_def: &'a VariantData,
    copy_fields: 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