1 //! Some code that abstracts away much of the boilerplate of writing
2 //! `derive` instances for traits. Among other things it manages getting
3 //! access to the fields of the 4 different sorts of structs and enum
4 //! variants, as well as creating the method and impl ast instances.
6 //! Supported features (fairly exhaustive):
8 //! - Methods taking any number of parameters of any type, and returning
9 //! any type, other than vectors, bottom and closures.
10 //! - Generating `impl`s for types with type parameters and lifetimes
11 //! (e.g., `Option<T>`), the parameters are automatically given the
12 //! current trait as a bound. (This includes separate type parameters
13 //! and lifetimes for methods.)
14 //! - Additional bounds on the type parameters (`TraitDef.additional_bounds`)
16 //! The most important thing for implementors is the `Substructure` and
17 //! `SubstructureFields` objects. The latter groups 5 possibilities of the
20 //! - `Struct`, when `Self` is a struct (including tuple structs, e.g
21 //! `struct T(i32, char)`).
22 //! - `EnumMatching`, when `Self` is an enum and all the arguments are the
23 //! same variant of the enum (e.g., `Some(1)`, `Some(3)` and `Some(4)`)
24 //! - `EnumTag` when `Self` is an enum, for comparing the enum tags.
25 //! - `StaticEnum` and `StaticStruct` for static methods, where the type
26 //! being derived upon is either an enum or struct respectively. (Any
27 //! argument with type Self is just grouped among the non-self
30 //! In the first two cases, the values from the corresponding fields in
31 //! all the arguments are grouped together.
33 //! The non-static cases have `Option<ident>` in several places associated
34 //! with field `expr`s. This represents the name of the field it is
35 //! associated with. It is only not `None` when the associated field has
36 //! an identifier in the source code. For example, the `x`s in the
40 //! # #![allow(dead_code)]
41 //! struct A { x : i32 }
51 //! The `i32`s in `B` and `C0` don't have an identifier, so the
52 //! `Option<ident>`s would be `None` for them.
54 //! In the static cases, the structure is summarized, either into the just
55 //! spans of the fields or a list of spans and the field idents (for tuple
56 //! structs and record structs, respectively), or a list of these, for
57 //! enums (one for each variant). For empty struct and empty enum
58 //! variants, it is represented as a count of 0.
60 //! # "`cs`" functions
62 //! The `cs_...` functions ("combine substructure") are designed to
63 //! make life easier by providing some pre-made recipes for common
64 //! threads; mostly calling the function being derived on all the
65 //! arguments and then combining them back together in some way (or
66 //! letting the user chose that). They are not meant to be the only
67 //! way to handle the structures that this code creates.
71 //! The following simplified `PartialEq` is used for in-code examples:
75 //! fn eq(&self, other: &Self) -> bool;
77 //! impl PartialEq for i32 {
78 //! fn eq(&self, other: &i32) -> bool {
84 //! Some examples of the values of `SubstructureFields` follow, using the
85 //! above `PartialEq`, `A`, `B` and `C`.
89 //! When generating the `expr` for the `A` impl, the `SubstructureFields` is
92 //! Struct(vec![FieldInfo {
94 //! name: Some(<ident of x>),
95 //! self_: <expr for &self.x>,
96 //! other: vec![<expr for &other.x]
100 //! For the `B` impl, called with `B(a)` and `B(b)`,
103 //! Struct(vec![FieldInfo {
104 //! span: <span of `i32`>,
106 //! self_: <expr for &a>
107 //! other: vec![<expr for &b>]
113 //! When generating the `expr` for a call with `self == C0(a)` and `other
114 //! == C0(b)`, the SubstructureFields is
117 //! EnumMatching(0, <ast::Variant for C0>,
119 //! span: <span of i32>
121 //! self_: <expr for &a>,
122 //! other: vec![<expr for &b>]
126 //! For `C1 {x}` and `C1 {x}`,
129 //! EnumMatching(1, <ast::Variant for C1>,
131 //! span: <span of x>
132 //! name: Some(<ident of x>),
133 //! self_: <expr for &self.x>,
134 //! other: vec![<expr for &other.x>]
142 //! &[<ident of self tag>, <ident of other tag>], <expr to combine with>)
144 //! Note that this setup doesn't allow for the brute-force "match every variant
145 //! against every other variant" approach, which is bad because it produces a
146 //! quadratic amount of code (see #15375).
150 //! A static method on the types above would result in,
153 //! StaticStruct(<ast::VariantData of A>, Named(vec![(<ident of x>, <span of x>)]))
155 //! StaticStruct(<ast::VariantData of B>, Unnamed(vec![<span of x>]))
157 //! StaticEnum(<ast::EnumDef of C>,
158 //! vec![(<ident of C0>, <span of C0>, Unnamed(vec![<span of i32>])),
159 //! (<ident of C1>, <span of C1>, Named(vec![(<ident of x>, <span of x>)]))])
162 pub use StaticFields::*;
163 pub use SubstructureFields::*;
166 use rustc_ast::ptr::P;
168 self as ast, BindingAnnotation, ByRef, EnumDef, Expr, GenericArg, GenericParamKind, Generics,
169 Mutability, PatKind, TyKind, VariantData,
171 use rustc_attr as attr;
172 use rustc_expand::base::{Annotatable, ExtCtxt};
173 use rustc_session::lint::builtin::BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE;
174 use rustc_span::symbol::{kw, sym, Ident, Symbol};
175 use rustc_span::{Span, DUMMY_SP};
176 use std::cell::RefCell;
180 use thin_vec::thin_vec;
181 use ty::{Bounds, Path, Ref, Self_, Ty};
185 pub struct TraitDef<'a> {
186 /// The span for the current #[derive(Foo)] header.
189 /// Path of the trait, including any type parameters
192 /// Whether to skip adding the current trait as a bound to the type parameters of the type.
193 pub skip_path_as_bound: bool,
195 /// Whether `Copy` is needed as an additional bound on type parameters in a packed struct.
196 pub needs_copy_as_bound_if_packed: bool,
198 /// Additional bounds required of any type parameters of the type,
199 /// other than the current trait
200 pub additional_bounds: Vec<Ty>,
202 /// Can this trait be derived for unions?
203 pub supports_unions: bool,
205 pub methods: Vec<MethodDef<'a>>,
207 pub associated_types: Vec<(Ident, Ty)>,
212 pub struct MethodDef<'a> {
213 /// name of the method
215 /// List of generics, e.g., `R: rand::Rng`
216 pub generics: Bounds,
218 /// Is there is a `&self` argument? If not, it is a static function.
219 pub explicit_self: bool,
221 /// Arguments other than the self argument.
222 pub nonself_args: Vec<(Ty, Symbol)>,
227 pub attributes: ast::AttrVec,
229 pub fieldless_variants_strategy: FieldlessVariantsStrategy,
231 pub combine_substructure: RefCell<CombineSubstructureFunc<'a>>,
234 /// How to handle fieldless enum variants.
236 pub enum FieldlessVariantsStrategy {
237 /// Combine fieldless variants into a single match arm.
238 /// This assumes that relevant information has been handled
239 /// by looking at the enum's discriminant.
241 /// Don't do anything special about fieldless variants. They are
242 /// handled like any other variant.
244 /// If all variants of the enum are fieldless, expand the special
245 /// `AllFieldLessEnum` substructure, so that the entire enum can be handled
247 SpecializeIfAllVariantsFieldless,
250 /// All the data about the data structure/method being derived upon.
251 pub struct Substructure<'a> {
253 pub type_ident: Ident,
254 /// Verbatim access to any non-selflike arguments, i.e. arguments that
255 /// don't have type `&Self`.
256 pub nonselflike_args: &'a [P<Expr>],
257 pub fields: &'a SubstructureFields<'a>,
260 /// Summary of the relevant parts of a struct/enum field.
261 pub struct FieldInfo {
263 /// None for tuple structs/normal enum variants, Some for normal
264 /// structs/struct enum variants.
265 pub name: Option<Ident>,
266 /// The expression corresponding to this field of `self`
267 /// (specifically, a reference to it).
268 pub self_expr: P<Expr>,
269 /// The expressions corresponding to references to this field in
270 /// the other selflike arguments.
271 pub other_selflike_exprs: Vec<P<Expr>>,
274 /// Fields for a static method
275 pub enum StaticFields {
276 /// Tuple and unit structs/enum variants like this.
277 Unnamed(Vec<Span>, bool /*is tuple*/),
278 /// Normal structs/struct variants.
279 Named(Vec<(Ident, Span)>),
282 /// A summary of the possible sets of fields.
283 pub enum SubstructureFields<'a> {
284 /// A non-static method where `Self` is a struct.
285 Struct(&'a ast::VariantData, Vec<FieldInfo>),
287 /// A non-static method handling the entire enum at once
288 /// (after it has been determined that none of the enum
289 /// variants has any fields).
290 AllFieldlessEnum(&'a ast::EnumDef),
292 /// Matching variants of the enum: variant index, variant count, ast::Variant,
293 /// fields: the field name is only non-`None` in the case of a struct
295 EnumMatching(usize, usize, &'a ast::Variant, Vec<FieldInfo>),
297 /// The tag of an enum. The first field is a `FieldInfo` for the tags, as
298 /// if they were fields. The second field is the expression to combine the
299 /// tag expression with; it will be `None` if no match is necessary.
300 EnumTag(FieldInfo, Option<P<Expr>>),
302 /// A static method where `Self` is a struct.
303 StaticStruct(&'a ast::VariantData, StaticFields),
305 /// A static method where `Self` is an enum.
306 StaticEnum(&'a ast::EnumDef, Vec<(Ident, Span, StaticFields)>),
309 /// Combine the values of all the fields together. The last argument is
310 /// all the fields of all the structures.
311 pub type CombineSubstructureFunc<'a> =
312 Box<dyn FnMut(&mut ExtCtxt<'_>, Span, &Substructure<'_>) -> BlockOrExpr + 'a>;
314 pub fn combine_substructure(
315 f: CombineSubstructureFunc<'_>,
316 ) -> RefCell<CombineSubstructureFunc<'_>> {
320 struct TypeParameter {
321 bound_generic_params: Vec<ast::GenericParam>,
325 /// The code snippets built up for derived code are sometimes used as blocks
326 /// (e.g. in a function body) and sometimes used as expressions (e.g. in a match
327 /// arm). This structure avoids committing to either form until necessary,
328 /// avoiding the insertion of any unnecessary blocks.
330 /// The statements come before the expression.
331 pub struct BlockOrExpr(Vec<ast::Stmt>, Option<P<Expr>>);
334 pub fn new_stmts(stmts: Vec<ast::Stmt>) -> BlockOrExpr {
335 BlockOrExpr(stmts, None)
338 pub fn new_expr(expr: P<Expr>) -> BlockOrExpr {
339 BlockOrExpr(vec![], Some(expr))
342 pub fn new_mixed(stmts: Vec<ast::Stmt>, expr: Option<P<Expr>>) -> BlockOrExpr {
343 BlockOrExpr(stmts, expr)
346 // Converts it into a block.
347 fn into_block(mut self, cx: &ExtCtxt<'_>, span: Span) -> P<ast::Block> {
348 if let Some(expr) = self.1 {
349 self.0.push(cx.stmt_expr(expr));
351 cx.block(span, self.0)
354 // Converts it into an expression.
355 fn into_expr(self, cx: &ExtCtxt<'_>, span: Span) -> P<Expr> {
356 if self.0.is_empty() {
358 None => cx.expr_block(cx.block(span, vec![])),
361 } else if self.0.len() == 1
362 && let ast::StmtKind::Expr(expr) = &self.0[0].kind
365 // There's only a single statement expression. Pull it out.
368 // Multiple statements and/or expressions.
369 cx.expr_block(self.into_block(cx, span))
374 /// This method helps to extract all the type parameters referenced from a
375 /// type. For a type parameter `<T>`, it looks for either a `TyPath` that
376 /// is not global and starts with `T`, or a `TyQPath`.
377 /// Also include bound generic params from the input type.
378 fn find_type_parameters(
380 ty_param_names: &[Symbol],
382 ) -> Vec<TypeParameter> {
383 use rustc_ast::visit;
385 struct Visitor<'a, 'b> {
387 ty_param_names: &'a [Symbol],
388 bound_generic_params_stack: Vec<ast::GenericParam>,
389 type_params: Vec<TypeParameter>,
392 impl<'a, 'b> visit::Visitor<'a> for Visitor<'a, 'b> {
393 fn visit_ty(&mut self, ty: &'a ast::Ty) {
394 if let ast::TyKind::Path(_, path) = &ty.kind
395 && let Some(segment) = path.segments.first()
396 && self.ty_param_names.contains(&segment.ident.name)
398 self.type_params.push(TypeParameter {
399 bound_generic_params: self.bound_generic_params_stack.clone(),
404 visit::walk_ty(self, ty)
407 // Place bound generic params on a stack, to extract them when a type is encountered.
408 fn visit_poly_trait_ref(&mut self, trait_ref: &'a ast::PolyTraitRef) {
409 let stack_len = self.bound_generic_params_stack.len();
410 self.bound_generic_params_stack.extend(trait_ref.bound_generic_params.iter().cloned());
412 visit::walk_poly_trait_ref(self, trait_ref);
414 self.bound_generic_params_stack.truncate(stack_len);
417 fn visit_mac_call(&mut self, mac: &ast::MacCall) {
418 self.cx.span_err(mac.span(), "`derive` cannot be used on items with type macros");
422 let mut visitor = Visitor {
425 bound_generic_params_stack: Vec::new(),
426 type_params: Vec::new(),
428 visit::Visitor::visit_ty(&mut visitor, ty);
433 impl<'a> TraitDef<'a> {
436 cx: &mut ExtCtxt<'_>,
437 mitem: &ast::MetaItem,
438 item: &'a Annotatable,
439 push: &mut dyn FnMut(Annotatable),
441 self.expand_ext(cx, mitem, item, push, false);
446 cx: &mut ExtCtxt<'_>,
447 mitem: &ast::MetaItem,
448 item: &'a Annotatable,
449 push: &mut dyn FnMut(Annotatable),
453 Annotatable::Item(item) => {
454 let is_packed = item.attrs.iter().any(|attr| {
455 for r in attr::find_repr_attrs(&cx.sess, attr) {
456 if let attr::ReprPacked(_) = r {
463 let newitem = match &item.kind {
464 ast::ItemKind::Struct(struct_def, generics) => self.expand_struct_def(
472 ast::ItemKind::Enum(enum_def, generics) => {
473 // We ignore `is_packed` here, because `repr(packed)`
474 // enums cause an error later on.
476 // This can only cause further compilation errors
477 // downstream in blatantly illegal code, so it is fine.
478 self.expand_enum_def(cx, enum_def, item.ident, generics, from_scratch)
480 ast::ItemKind::Union(struct_def, generics) => {
481 if self.supports_unions {
482 self.expand_struct_def(
491 cx.span_err(mitem.span, "this trait cannot be derived for unions");
497 // Keep the lint attributes of the previous item to control how the
498 // generated implementations are linted
499 let mut attrs = newitem.attrs.clone();
512 .contains(&a.name_or_empty())
516 push(Annotatable::Item(P(ast::Item { attrs, ..(*newitem).clone() })))
522 /// Given that we are deriving a trait `DerivedTrait` for a type like:
524 /// ```ignore (only-for-syntax-highlight)
525 /// struct Struct<'a, ..., 'z, A, B: DeclaredTrait, C, ..., Z> where C: WhereTrait {
528 /// b1: <B as DeclaredTrait>::Item,
529 /// c1: <C as WhereTrait>::Item,
530 /// c2: Option<<C as WhereTrait>::Item>,
535 /// create an impl like:
537 /// ```ignore (only-for-syntax-highlight)
538 /// impl<'a, ..., 'z, A, B: DeclaredTrait, C, ... Z> where
540 /// A: DerivedTrait + B1 + ... + BN,
541 /// B: DerivedTrait + B1 + ... + BN,
542 /// C: DerivedTrait + B1 + ... + BN,
543 /// B::Item: DerivedTrait + B1 + ... + BN,
544 /// <C as WhereTrait>::Item: DerivedTrait + B1 + ... + BN,
551 /// where B1, ..., BN are the bounds given by `bounds_paths`.'. Z is a phantom type, and
552 /// therefore does not get bound by the derived trait.
553 fn create_derived_impl(
555 cx: &mut ExtCtxt<'_>,
558 field_tys: Vec<P<ast::Ty>>,
559 methods: Vec<P<ast::AssocItem>>,
562 let trait_path = self.path.to_path(cx, self.span, type_ident, generics);
564 // Transform associated types from `deriving::ty::Ty` into `ast::AssocItem`
565 let associated_types = self.associated_types.iter().map(|&(ident, ref type_def)| {
567 id: ast::DUMMY_NODE_ID,
570 vis: ast::Visibility {
571 span: self.span.shrink_to_lo(),
572 kind: ast::VisibilityKind::Inherited,
575 attrs: ast::AttrVec::new(),
576 kind: ast::AssocItemKind::Type(Box::new(ast::TyAlias {
577 defaultness: ast::Defaultness::Final,
578 generics: Generics::default(),
580 ast::TyAliasWhereClause::default(),
581 ast::TyAliasWhereClause::default(),
583 where_predicates_split: 0,
585 ty: Some(type_def.to_ty(cx, self.span, type_ident, generics)),
591 let mut where_clause = ast::WhereClause::default();
592 where_clause.span = generics.where_clause.span;
593 let ctxt = self.span.ctxt();
594 let span = generics.span.with_ctxt(ctxt);
596 // Create the generic parameters
597 let params: Vec<_> = generics
600 .map(|param| match ¶m.kind {
601 GenericParamKind::Lifetime { .. } => param.clone(),
602 GenericParamKind::Type { .. } => {
603 // Extra restrictions on the generics parameters to the
604 // type being derived upon.
605 let bounds: Vec<_> = self
610 p.to_path(cx, self.span, type_ident, generics),
615 // Add a bound for the current trait.
616 self.skip_path_as_bound
618 .then(|| cx.trait_bound(trait_path.clone(), self.is_const)),
621 // Add a `Copy` bound if required.
622 if is_packed && self.needs_copy_as_bound_if_packed {
623 let p = deriving::path_std!(marker::Copy);
625 p.to_path(cx, self.span, type_ident, generics),
633 // Also add in any bounds from the declaration.
634 param.bounds.iter().cloned(),
638 cx.typaram(param.ident.span.with_ctxt(ctxt), param.ident, bounds, None)
640 GenericParamKind::Const { ty, kw_span, .. } => {
641 let const_nodefault_kind = GenericParamKind::Const {
643 kw_span: kw_span.with_ctxt(ctxt),
645 // We can't have default values inside impl block
648 let mut param_clone = param.clone();
649 param_clone.kind = const_nodefault_kind;
655 // and similarly for where clauses
656 where_clause.predicates.extend(generics.where_clause.predicates.iter().map(|clause| {
658 ast::WherePredicate::BoundPredicate(wb) => {
659 let span = wb.span.with_ctxt(ctxt);
660 ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
665 ast::WherePredicate::RegionPredicate(wr) => {
666 let span = wr.span.with_ctxt(ctxt);
667 ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate {
672 ast::WherePredicate::EqPredicate(we) => {
673 let span = we.span.with_ctxt(ctxt);
674 ast::WherePredicate::EqPredicate(ast::WhereEqPredicate { span, ..we.clone() })
680 // Extra scope required here so ty_params goes out of scope before params is moved
682 let mut ty_params = params
684 .filter(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
687 if ty_params.peek().is_some() {
688 let ty_param_names: Vec<Symbol> =
689 ty_params.map(|ty_param| ty_param.ident.name).collect();
691 for field_ty in field_tys {
692 let field_ty_params = find_type_parameters(&field_ty, &ty_param_names, cx);
694 for field_ty_param in field_ty_params {
695 // if we have already handled this type, skip it
696 if let ast::TyKind::Path(_, p) = &field_ty_param.ty.kind
697 && let [sole_segment] = &*p.segments
698 && ty_param_names.contains(&sole_segment.ident.name)
702 let mut bounds: Vec<_> = self
707 p.to_path(cx, self.span, type_ident, generics),
713 // Require the current trait.
714 bounds.push(cx.trait_bound(trait_path.clone(), self.is_const));
716 // Add a `Copy` bound if required.
717 if is_packed && self.needs_copy_as_bound_if_packed {
718 let p = deriving::path_std!(marker::Copy);
719 bounds.push(cx.trait_bound(
720 p.to_path(cx, self.span, type_ident, generics),
725 let predicate = ast::WhereBoundPredicate {
727 bound_generic_params: field_ty_param.bound_generic_params,
728 bounded_ty: field_ty_param.ty,
732 let predicate = ast::WherePredicate::BoundPredicate(predicate);
733 where_clause.predicates.push(predicate);
739 let trait_generics = Generics { params, where_clause, span };
741 // Create the reference to the trait.
742 let trait_ref = cx.trait_ref(trait_path);
744 let self_params: Vec<_> = generics
747 .map(|param| match param.kind {
748 GenericParamKind::Lifetime { .. } => {
749 GenericArg::Lifetime(cx.lifetime(param.ident.span.with_ctxt(ctxt), param.ident))
751 GenericParamKind::Type { .. } => {
752 GenericArg::Type(cx.ty_ident(param.ident.span.with_ctxt(ctxt), param.ident))
754 GenericParamKind::Const { .. } => {
755 GenericArg::Const(cx.const_ident(param.ident.span.with_ctxt(ctxt), param.ident))
760 // Create the type of `self`.
761 let path = cx.path_all(self.span, false, vec![type_ident], self_params);
762 let self_type = cx.ty_path(path);
764 let attr = cx.attr_word(sym::automatically_derived, self.span);
765 let attrs = thin_vec![attr];
766 let opt_trait_ref = Some(trait_ref);
772 ast::ItemKind::Impl(Box::new(ast::Impl {
773 unsafety: ast::Unsafe::No,
774 polarity: ast::ImplPolarity::Positive,
775 defaultness: ast::Defaultness::Final,
776 constness: if self.is_const { ast::Const::Yes(DUMMY_SP) } else { ast::Const::No },
777 generics: trait_generics,
778 of_trait: opt_trait_ref,
780 items: methods.into_iter().chain(associated_types).collect(),
785 fn expand_struct_def(
787 cx: &mut ExtCtxt<'_>,
788 struct_def: &'a VariantData,
794 let field_tys: Vec<P<ast::Ty>> =
795 struct_def.fields().iter().map(|field| field.ty.clone()).collect();
801 let (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys) =
802 method_def.extract_arg_details(cx, self, type_ident, generics);
804 let body = if from_scratch || method_def.is_static() {
805 method_def.expand_static_struct_method_body(
813 method_def.expand_struct_method_body(
824 method_def.create_method(
836 self.create_derived_impl(cx, type_ident, generics, field_tys, methods, is_packed)
841 cx: &mut ExtCtxt<'_>,
842 enum_def: &'a EnumDef,
847 let mut field_tys = Vec::new();
849 for variant in &enum_def.variants {
850 field_tys.extend(variant.data.fields().iter().map(|field| field.ty.clone()));
857 let (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys) =
858 method_def.extract_arg_details(cx, self, type_ident, generics);
860 let body = if from_scratch || method_def.is_static() {
861 method_def.expand_static_enum_method_body(
869 method_def.expand_enum_method_body(
879 method_def.create_method(
891 let is_packed = false; // enums are never packed
892 self.create_derived_impl(cx, type_ident, generics, field_tys, methods, is_packed)
896 impl<'a> MethodDef<'a> {
897 fn call_substructure_method(
899 cx: &mut ExtCtxt<'_>,
900 trait_: &TraitDef<'_>,
902 nonselflike_args: &[P<Expr>],
903 fields: &SubstructureFields<'_>,
905 let span = trait_.span;
906 let substructure = Substructure { type_ident, nonselflike_args, fields };
907 let mut f = self.combine_substructure.borrow_mut();
908 let f: &mut CombineSubstructureFunc<'_> = &mut *f;
909 f(cx, span, &substructure)
914 cx: &mut ExtCtxt<'_>,
915 trait_: &TraitDef<'_>,
919 self.ret_ty.to_ty(cx, trait_.span, type_ident, generics)
922 fn is_static(&self) -> bool {
926 // The return value includes:
927 // - explicit_self: The `&self` arg, if present.
928 // - selflike_args: Expressions for `&self` (if present) and also any other
929 // args with the same type (e.g. the `other` arg in `PartialEq::eq`).
930 // - nonselflike_args: Expressions for all the remaining args.
931 // - nonself_arg_tys: Additional information about all the args other than
933 fn extract_arg_details(
935 cx: &mut ExtCtxt<'_>,
936 trait_: &TraitDef<'_>,
939 ) -> (Option<ast::ExplicitSelf>, Vec<P<Expr>>, Vec<P<Expr>>, Vec<(Ident, P<ast::Ty>)>) {
940 let mut selflike_args = Vec::new();
941 let mut nonselflike_args = Vec::new();
942 let mut nonself_arg_tys = Vec::new();
943 let span = trait_.span;
945 let explicit_self = if self.explicit_self {
946 let (self_expr, explicit_self) = ty::get_explicit_self(cx, span);
947 selflike_args.push(self_expr);
953 for (ty, name) in self.nonself_args.iter() {
954 let ast_ty = ty.to_ty(cx, span, type_ident, generics);
955 let ident = Ident::new(*name, span);
956 nonself_arg_tys.push((ident, ast_ty));
958 let arg_expr = cx.expr_ident(span, ident);
961 // Selflike (`&Self`) arguments only occur in non-static methods.
962 Ref(box Self_, _) if !self.is_static() => selflike_args.push(arg_expr),
963 Self_ => cx.span_bug(span, "`Self` in non-return position"),
964 _ => nonselflike_args.push(arg_expr),
968 (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys)
973 cx: &mut ExtCtxt<'_>,
974 trait_: &TraitDef<'_>,
977 explicit_self: Option<ast::ExplicitSelf>,
978 nonself_arg_tys: Vec<(Ident, P<ast::Ty>)>,
980 ) -> P<ast::AssocItem> {
981 let span = trait_.span;
982 // Create the generics that aren't for `Self`.
983 let fn_generics = self.generics.to_generics(cx, span, type_ident, generics);
986 let self_arg = explicit_self.map(|explicit_self| {
987 let ident = Ident::with_dummy_span(kw::SelfLower).with_span_pos(span);
988 ast::Param::from_self(ast::AttrVec::default(), explicit_self, ident)
991 nonself_arg_tys.into_iter().map(|(name, ty)| cx.param(span, name, ty));
992 self_arg.into_iter().chain(nonself_args).collect()
995 let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident);
997 let method_ident = Ident::new(self.name, span);
998 let fn_decl = cx.fn_decl(args, ast::FnRetTy::Ty(ret_type));
999 let body_block = body.into_block(cx, span);
1001 let trait_lo_sp = span.shrink_to_lo();
1003 let sig = ast::FnSig { header: ast::FnHeader::default(), decl: fn_decl, span };
1004 let defaultness = ast::Defaultness::Final;
1006 // Create the method.
1008 id: ast::DUMMY_NODE_ID,
1009 attrs: self.attributes.clone(),
1011 vis: ast::Visibility {
1013 kind: ast::VisibilityKind::Inherited,
1016 ident: method_ident,
1017 kind: ast::AssocItemKind::Fn(Box::new(ast::Fn {
1020 generics: fn_generics,
1021 body: Some(body_block),
1027 /// The normal case uses field access.
1029 /// #[derive(PartialEq)]
1031 /// struct A { x: u8, y: u8 }
1033 /// // equivalent to:
1034 /// impl PartialEq for A {
1035 /// fn eq(&self, other: &A) -> bool {
1036 /// self.x == other.x && self.y == other.y
1040 /// But if the struct is `repr(packed)`, we can't use something like
1041 /// `&self.x` because that might cause an unaligned ref. So for any trait
1042 /// method that takes a reference, we use a local block to force a copy.
1043 /// This requires that the field impl `Copy`.
1045 /// # struct A { x: u8, y: u8 }
1046 /// impl PartialEq for A {
1047 /// fn eq(&self, other: &A) -> bool {
1048 /// // Desugars to `{ self.x }.eq(&{ other.y }) && ...`
1049 /// { self.x } == { other.y } && { self.y } == { other.y }
1052 /// impl Hash for A {
1053 /// fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
1054 /// ::core::hash::Hash::hash(&{ self.x }, state);
1055 /// ::core::hash::Hash::hash(&{ self.y }, state)
1058 fn expand_struct_method_body<'b>(
1060 cx: &mut ExtCtxt<'_>,
1061 trait_: &TraitDef<'b>,
1062 struct_def: &'b VariantData,
1064 selflike_args: &[P<Expr>],
1065 nonselflike_args: &[P<Expr>],
1068 assert!(selflike_args.len() == 1 || selflike_args.len() == 2);
1070 let selflike_fields =
1071 trait_.create_struct_field_access_fields(cx, selflike_args, struct_def, is_packed);
1072 self.call_substructure_method(
1077 &Struct(struct_def, selflike_fields),
1081 fn expand_static_struct_method_body(
1083 cx: &mut ExtCtxt<'_>,
1084 trait_: &TraitDef<'_>,
1085 struct_def: &VariantData,
1087 nonselflike_args: &[P<Expr>],
1089 let summary = trait_.summarise_struct(cx, struct_def);
1091 self.call_substructure_method(
1096 &StaticStruct(struct_def, summary),
1101 /// #[derive(PartialEq)]
1108 /// is equivalent to:
1110 /// #![feature(core_intrinsics)]
1115 /// impl ::core::cmp::PartialEq for A {
1117 /// fn eq(&self, other: &A) -> bool {
1118 /// let __self_tag = ::core::intrinsics::discriminant_value(self);
1119 /// let __arg1_tag = ::core::intrinsics::discriminant_value(other);
1120 /// __self_tag == __arg1_tag &&
1121 /// match (self, other) {
1122 /// (A::A2(__self_0), A::A2(__arg1_0)) =>
1123 /// *__self_0 == *__arg1_0,
1129 /// Creates a tag check combined with a match for a tuple of all
1130 /// `selflike_args`, with an arm for each variant with fields, possibly an
1131 /// arm for each fieldless variant (if `unify_fieldless_variants` is not
1132 /// `Unify`), and possibly a default arm.
1133 fn expand_enum_method_body<'b>(
1135 cx: &mut ExtCtxt<'_>,
1136 trait_: &TraitDef<'b>,
1137 enum_def: &'b EnumDef,
1139 selflike_args: Vec<P<Expr>>,
1140 nonselflike_args: &[P<Expr>],
1142 let span = trait_.span;
1143 let variants = &enum_def.variants;
1145 // Traits that unify fieldless variants always use the tag(s).
1146 let unify_fieldless_variants =
1147 self.fieldless_variants_strategy == FieldlessVariantsStrategy::Unify;
1149 // There is no sensible code to be generated for *any* deriving on a
1150 // zero-variant enum. So we just generate a failing expression.
1151 if variants.is_empty() {
1152 return BlockOrExpr(vec![], Some(deriving::call_unreachable(cx, span)));
1155 let prefixes = iter::once("__self".to_string())
1161 .map(|(arg_count, _selflike_arg)| format!("__arg{}", arg_count)),
1163 .collect::<Vec<String>>();
1165 // Build a series of let statements mapping each selflike_arg
1166 // to its discriminant value.
1168 // e.g. for `PartialEq::eq` builds two statements:
1170 // let __self_tag = ::core::intrinsics::discriminant_value(self);
1171 // let __arg1_tag = ::core::intrinsics::discriminant_value(other);
1173 let get_tag_pieces = |cx: &ExtCtxt<'_>| {
1174 let tag_idents: Vec<_> = prefixes
1176 .map(|name| Ident::from_str_and_span(&format!("{}_tag", name), span))
1179 let mut tag_exprs: Vec<_> = tag_idents
1181 .map(|&ident| cx.expr_addr_of(span, cx.expr_ident(span, ident)))
1184 let self_expr = tag_exprs.remove(0);
1185 let other_selflike_exprs = tag_exprs;
1186 let tag_field = FieldInfo { span, name: None, self_expr, other_selflike_exprs };
1188 let tag_let_stmts: Vec<_> = iter::zip(&tag_idents, &selflike_args)
1189 .map(|(&ident, selflike_arg)| {
1190 let variant_value = deriving::call_intrinsic(
1193 sym::discriminant_value,
1194 vec![selflike_arg.clone()],
1196 cx.stmt_let(span, false, ident, variant_value)
1200 (tag_field, tag_let_stmts)
1203 // There are some special cases involving fieldless enums where no
1204 // match is necessary.
1205 let all_fieldless = variants.iter().all(|v| v.data.fields().is_empty());
1207 if variants.len() > 1 {
1208 match self.fieldless_variants_strategy {
1209 FieldlessVariantsStrategy::Unify => {
1210 // If the type is fieldless and the trait uses the tag and
1211 // there are multiple variants, we need just an operation on
1213 let (tag_field, mut tag_let_stmts) = get_tag_pieces(cx);
1214 let mut tag_check = self.call_substructure_method(
1219 &EnumTag(tag_field, None),
1221 tag_let_stmts.append(&mut tag_check.0);
1222 return BlockOrExpr(tag_let_stmts, tag_check.1);
1224 FieldlessVariantsStrategy::SpecializeIfAllVariantsFieldless => {
1225 return self.call_substructure_method(
1230 &AllFieldlessEnum(enum_def),
1233 FieldlessVariantsStrategy::Default => (),
1235 } else if variants.len() == 1 {
1236 // If there is a single variant, we don't need an operation on
1237 // the tag(s). Just use the most degenerate result.
1238 return self.call_substructure_method(
1243 &EnumMatching(0, 1, &variants[0], Vec::new()),
1248 // These arms are of the form:
1249 // (Variant1, Variant1, ...) => Body1
1250 // (Variant2, Variant2, ...) => Body2
1252 // where each tuple has length = selflike_args.len()
1253 let mut match_arms: Vec<ast::Arm> = variants
1256 .filter(|&(_, v)| !(unify_fieldless_variants && v.data.fields().is_empty()))
1257 .map(|(index, variant)| {
1258 // A single arm has form (&VariantK, &VariantK, ...) => BodyK
1259 // (see "Final wrinkle" note below for why.)
1261 let fields = trait_.create_struct_pattern_fields(cx, &variant.data, &prefixes);
1263 let sp = variant.span.with_ctxt(trait_.span.ctxt());
1264 let variant_path = cx.path(sp, vec![type_ident, variant.ident]);
1265 let by_ref = ByRef::No; // because enums can't be repr(packed)
1266 let mut subpats: Vec<_> = trait_.create_struct_patterns(
1274 // `(VariantK, VariantK, ...)` or just `VariantK`.
1275 let single_pat = if subpats.len() == 1 {
1276 subpats.pop().unwrap()
1278 cx.pat_tuple(span, subpats)
1281 // For the BodyK, we need to delegate to our caller,
1282 // passing it an EnumMatching to indicate which case
1285 // Now, for some given VariantK, we have built up
1286 // expressions for referencing every field of every
1287 // Self arg, assuming all are instances of VariantK.
1288 // Build up code associated with such a case.
1289 let substructure = EnumMatching(index, variants.len(), variant, fields);
1291 .call_substructure_method(
1298 .into_expr(cx, span);
1300 cx.arm(span, single_pat, arm_expr)
1304 // Add a default arm to the match, if necessary.
1305 let first_fieldless = variants.iter().find(|v| v.data.fields().is_empty());
1306 let default = match first_fieldless {
1307 Some(v) if unify_fieldless_variants => {
1308 // We need a default case that handles all the fieldless
1309 // variants. The index and actual variant aren't meaningful in
1310 // this case, so just use dummy values.
1312 self.call_substructure_method(
1317 &EnumMatching(0, variants.len(), v, Vec::new()),
1319 .into_expr(cx, span),
1322 _ if variants.len() > 1 && selflike_args.len() > 1 => {
1323 // Because we know that all the arguments will match if we reach
1324 // the match expression we add the unreachable intrinsics as the
1325 // result of the default which should help llvm in optimizing it.
1326 Some(deriving::call_unreachable(cx, span))
1330 if let Some(arm) = default {
1331 match_arms.push(cx.arm(span, cx.pat_wild(span), arm));
1334 // Create a match expression with one arm per discriminant plus
1335 // possibly a default arm, e.g.:
1336 // match (self, other) {
1337 // (Variant1, Variant1, ...) => Body1
1338 // (Variant2, Variant2, ...) => Body2,
1340 // _ => ::core::intrinsics::unreachable()
1342 let get_match_expr = |mut selflike_args: Vec<P<Expr>>| {
1343 let match_arg = if selflike_args.len() == 1 {
1344 selflike_args.pop().unwrap()
1346 cx.expr(span, ast::ExprKind::Tup(selflike_args))
1348 cx.expr_match(span, match_arg, match_arms)
1351 // If the trait uses the tag and there are multiple variants, we need
1352 // to add a tag check operation before the match. Otherwise, the match
1354 if unify_fieldless_variants && variants.len() > 1 {
1355 let (tag_field, mut tag_let_stmts) = get_tag_pieces(cx);
1357 // Combine a tag check with the match.
1358 let mut tag_check_plus_match = self.call_substructure_method(
1363 &EnumTag(tag_field, Some(get_match_expr(selflike_args))),
1365 tag_let_stmts.append(&mut tag_check_plus_match.0);
1366 BlockOrExpr(tag_let_stmts, tag_check_plus_match.1)
1368 BlockOrExpr(vec![], Some(get_match_expr(selflike_args)))
1372 fn expand_static_enum_method_body(
1374 cx: &mut ExtCtxt<'_>,
1375 trait_: &TraitDef<'_>,
1378 nonselflike_args: &[P<Expr>],
1380 let summary = enum_def
1384 let sp = v.span.with_ctxt(trait_.span.ctxt());
1385 let summary = trait_.summarise_struct(cx, &v.data);
1386 (v.ident, sp, summary)
1389 self.call_substructure_method(
1394 &StaticEnum(enum_def, summary),
1399 // general helper methods.
1400 impl<'a> TraitDef<'a> {
1401 fn summarise_struct(&self, cx: &mut ExtCtxt<'_>, struct_def: &VariantData) -> StaticFields {
1402 let mut named_idents = Vec::new();
1403 let mut just_spans = Vec::new();
1404 for field in struct_def.fields() {
1405 let sp = field.span.with_ctxt(self.span.ctxt());
1407 Some(ident) => named_idents.push((ident, sp)),
1408 _ => just_spans.push(sp),
1412 let is_tuple = matches!(struct_def, ast::VariantData::Tuple(..));
1413 match (just_spans.is_empty(), named_idents.is_empty()) {
1415 cx.span_bug(self.span, "a struct with named and unnamed fields in generic `derive`")
1418 (_, false) => Named(named_idents),
1420 (false, _) => Unnamed(just_spans, is_tuple),
1422 _ => Named(Vec::new()),
1426 fn create_struct_patterns(
1428 cx: &mut ExtCtxt<'_>,
1429 struct_path: ast::Path,
1430 struct_def: &'a VariantData,
1431 prefixes: &[String],
1433 ) -> Vec<P<ast::Pat>> {
1438 struct_def.fields().iter().enumerate().map(|(i, struct_field)| {
1439 let sp = struct_field.span.with_ctxt(self.span.ctxt());
1440 let ident = self.mk_pattern_ident(prefix, i);
1441 let path = ident.with_span_pos(sp);
1448 BindingAnnotation(by_ref, Mutability::Not),
1456 let struct_path = struct_path.clone();
1458 VariantData::Struct(..) => {
1459 let field_pats = pieces_iter
1460 .map(|(sp, ident, pat)| {
1461 if ident.is_none() {
1464 "a braced struct with unnamed fields in `derive`",
1468 ident: ident.unwrap(),
1469 is_shorthand: false,
1470 attrs: ast::AttrVec::new(),
1471 id: ast::DUMMY_NODE_ID,
1472 span: pat.span.with_ctxt(self.span.ctxt()),
1474 is_placeholder: false,
1478 cx.pat_struct(self.span, struct_path, field_pats)
1480 VariantData::Tuple(..) => {
1481 let subpats = pieces_iter.map(|(_, _, subpat)| subpat).collect();
1482 cx.pat_tuple_struct(self.span, struct_path, subpats)
1484 VariantData::Unit(..) => cx.pat_path(self.span, struct_path),
1490 fn create_fields<F>(&self, struct_def: &'a VariantData, mk_exprs: F) -> Vec<FieldInfo>
1492 F: Fn(usize, &ast::FieldDef, Span) -> Vec<P<ast::Expr>>,
1498 .map(|(i, struct_field)| {
1499 // For this field, get an expr for each selflike_arg. E.g. for
1500 // `PartialEq::eq`, one for each of `&self` and `other`.
1501 let sp = struct_field.span.with_ctxt(self.span.ctxt());
1502 let mut exprs: Vec<_> = mk_exprs(i, struct_field, sp);
1503 let self_expr = exprs.remove(0);
1504 let other_selflike_exprs = exprs;
1506 span: sp.with_ctxt(self.span.ctxt()),
1507 name: struct_field.ident,
1509 other_selflike_exprs,
1515 fn mk_pattern_ident(&self, prefix: &str, i: usize) -> Ident {
1516 Ident::from_str_and_span(&format!("{}_{}", prefix, i), self.span)
1519 fn create_struct_pattern_fields(
1521 cx: &mut ExtCtxt<'_>,
1522 struct_def: &'a VariantData,
1523 prefixes: &[String],
1524 ) -> Vec<FieldInfo> {
1525 self.create_fields(struct_def, |i, _struct_field, sp| {
1529 let ident = self.mk_pattern_ident(prefix, i);
1530 cx.expr_path(cx.path_ident(sp, ident))
1536 fn create_struct_field_access_fields(
1538 cx: &mut ExtCtxt<'_>,
1539 selflike_args: &[P<Expr>],
1540 struct_def: &'a VariantData,
1542 ) -> Vec<FieldInfo> {
1543 self.create_fields(struct_def, |i, struct_field, sp| {
1546 .map(|selflike_arg| {
1547 // Note: we must use `struct_field.span` rather than `sp` in the
1548 // `unwrap_or_else` case otherwise the hygiene is wrong and we get
1549 // "field `0` of struct `Point` is private" errors on tuple
1551 let mut field_expr = cx.expr(
1553 ast::ExprKind::Field(
1554 selflike_arg.clone(),
1555 struct_field.ident.unwrap_or_else(|| {
1556 Ident::from_str_and_span(&i.to_string(), struct_field.span)
1561 // In general, fields in packed structs are copied via a
1562 // block, e.g. `&{self.0}`. The two exceptions are `[u8]`
1563 // and `str` fields, which cannot be copied and also never
1564 // cause unaligned references. These exceptions are allowed
1565 // to handle the `FlexZeroSlice` type in the `zerovec`
1566 // crate within `icu4x-0.9.0`.
1568 // Once use of `icu4x-0.9.0` has dropped sufficiently, this
1569 // exception should be removed.
1570 let is_simple_path = |ty: &P<ast::Ty>, sym| {
1571 if let TyKind::Path(None, ast::Path { segments, .. }) = &ty.kind &&
1572 let [seg] = segments.as_slice() &&
1573 seg.ident.name == sym && seg.args.is_none()
1581 let exception = if let TyKind::Slice(ty) = &struct_field.ty.kind &&
1582 is_simple_path(ty, sym::u8)
1585 } else if is_simple_path(&struct_field.ty, sym::str) {
1591 if let Some(ty) = exception {
1592 cx.sess.parse_sess.buffer_lint_with_diagnostic(
1593 BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE,
1597 "{} slice in a packed struct that derives a built-in trait",
1600 rustc_lint_defs::BuiltinLintDiagnostics::ByteSliceInPackedStructWithDerive
1603 // Wrap the expression in `{...}`, causing a copy.
1604 field_expr = cx.expr_block(
1605 cx.block(struct_field.span, vec![cx.stmt_expr(field_expr)]),
1609 cx.expr_addr_of(sp, field_expr)
1616 /// The function passed to `cs_fold` is called repeatedly with a value of this
1617 /// type. It describes one part of the code generation. The result is always an
1619 pub enum CsFold<'a> {
1620 /// The basic case: a field expression for one or more selflike args. E.g.
1621 /// for `PartialEq::eq` this is something like `self.x == other.x`.
1622 Single(&'a FieldInfo),
1624 /// The combination of two field expressions. E.g. for `PartialEq::eq` this
1625 /// is something like `<field1 equality> && <field2 equality>`.
1626 Combine(Span, P<Expr>, P<Expr>),
1628 // The fallback case for a struct or enum variant with no fields.
1632 /// Folds over fields, combining the expressions for each field in a sequence.
1633 /// Statics may not be folded over.
1636 cx: &mut ExtCtxt<'_>,
1638 substructure: &Substructure<'_>,
1642 F: FnMut(&mut ExtCtxt<'_>, CsFold<'_>) -> P<Expr>,
1644 match substructure.fields {
1645 EnumMatching(.., all_fields) | Struct(_, all_fields) => {
1646 if all_fields.is_empty() {
1647 return f(cx, CsFold::Fieldless);
1650 let (base_field, rest) = if use_foldl {
1651 all_fields.split_first().unwrap()
1653 all_fields.split_last().unwrap()
1656 let base_expr = f(cx, CsFold::Single(base_field));
1658 let op = |old, field: &FieldInfo| {
1659 let new = f(cx, CsFold::Single(field));
1660 f(cx, CsFold::Combine(field.span, old, new))
1664 rest.iter().fold(base_expr, op)
1666 rest.iter().rfold(base_expr, op)
1669 EnumTag(tag_field, match_expr) => {
1670 let tag_check_expr = f(cx, CsFold::Single(tag_field));
1671 if let Some(match_expr) = match_expr {
1673 f(cx, CsFold::Combine(trait_span, tag_check_expr, match_expr.clone()))
1675 f(cx, CsFold::Combine(trait_span, match_expr.clone(), tag_check_expr))
1681 StaticEnum(..) | StaticStruct(..) => cx.span_bug(trait_span, "static function in `derive`"),
1682 AllFieldlessEnum(..) => cx.span_bug(trait_span, "fieldless enum in `derive`"),