compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

   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.
   5 //!
   6 //! Supported features (fairly exhaustive):
   7 //!
   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`)
  15 //!
  16 //! The most important thing for implementors is the `Substructure` and
  17 //! `SubstructureFields` objects. The latter groups 5 possibilities of the
  18 //! arguments:
  19 //!
  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
  28 //!   arguments.)
  29 //!
  30 //! In the first two cases, the values from the corresponding fields in
  31 //! all the arguments are grouped together.
  32 //!
  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
  37 //! following snippet
  38 //!
  39 //! ```rust
  40 //! # #![allow(dead_code)]
  41 //! struct A { x : i32 }
  42 //!
  43 //! struct B(i32);
  44 //!
  45 //! enum C {
  46 //!     C0(i32),
  47 //!     C1 { x: i32 }
  48 //! }
  49 //! ```
  50 //!
  51 //! The `i32`s in `B` and `C0` don't have an identifier, so the
  52 //! `Option<ident>`s would be `None` for them.
  53 //!
  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.
  59 //!
  60 //! # "`cs`" functions
  61 //!
  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.
  68 //!
  69 //! # Examples
  70 //!
  71 //! The following simplified `PartialEq` is used for in-code examples:
  72 //!
  73 //! ```rust
  74 //! trait PartialEq {
  75 //!     fn eq(&self, other: &Self) -> bool;
  76 //! }
  77 //! impl PartialEq for i32 {
  78 //!     fn eq(&self, other: &i32) -> bool {
  79 //!         *self == *other
  80 //!     }
  81 //! }
  82 //! ```
  83 //!
  84 //! Some examples of the values of `SubstructureFields` follow, using the
  85 //! above `PartialEq`, `A`, `B` and `C`.
  86 //!
  87 //! ## Structs
  88 //!
  89 //! When generating the `expr` for the `A` impl, the `SubstructureFields` is
  90 //!
  91 //! ```{.text}
  92 //! Struct(vec![FieldInfo {
  93 //!            span: <span of x>
  94 //!            name: Some(<ident of x>),
  95 //!            self_: <expr for &self.x>,
  96 //!            other: vec![<expr for &other.x]
  97 //!          }])
  98 //! ```
  99 //!
 100 //! For the `B` impl, called with `B(a)` and `B(b)`,
 101 //!
 102 //! ```{.text}
 103 //! Struct(vec![FieldInfo {
 104 //!           span: <span of `i32`>,
 105 //!           name: None,
 106 //!           self_: <expr for &a>
 107 //!           other: vec![<expr for &b>]
 108 //!          }])
 109 //! ```
 110 //!
 111 //! ## Enums
 112 //!
 113 //! When generating the `expr` for a call with `self == C0(a)` and `other
 114 //! == C0(b)`, the SubstructureFields is
 115 //!
 116 //! ```{.text}
 117 //! EnumMatching(0, <ast::Variant for C0>,
 118 //!              vec![FieldInfo {
 119 //!                 span: <span of i32>
 120 //!                 name: None,
 121 //!                 self_: <expr for &a>,
 122 //!                 other: vec![<expr for &b>]
 123 //!               }])
 124 //! ```
 125 //!
 126 //! For `C1 {x}` and `C1 {x}`,
 127 //!
 128 //! ```{.text}
 129 //! EnumMatching(1, <ast::Variant for C1>,
 130 //!              vec![FieldInfo {
 131 //!                 span: <span of x>
 132 //!                 name: Some(<ident of x>),
 133 //!                 self_: <expr for &self.x>,
 134 //!                 other: vec![<expr for &other.x>]
 135 //!                }])
 136 //! ```
 137 //!
 138 //! For the tags,
 139 //!
 140 //! ```{.text}
 141 //! EnumTag(
 142 //!     &[<ident of self tag>, <ident of other tag>], <expr to combine with>)
 143 //! ```
 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).
 147 //!
 148 //! ## Static
 149 //!
 150 //! A static method on the types above would result in,
 151 //!
 152 //! ```{.text}
 153 //! StaticStruct(<ast::VariantData of A>, Named(vec![(<ident of x>, <span of x>)]))
 154 //!
 155 //! StaticStruct(<ast::VariantData of B>, Unnamed(vec![<span of x>]))
 156 //!
 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>)]))])
 160 //! ```
 161
 162 pub use StaticFields::*;
 163 pub use SubstructureFields::*;
 164
 165 use crate::deriving;
 166 use rustc_ast::ptr::P;
 167 use rustc_ast::{
 168     self as ast, BindingAnnotation, ByRef, EnumDef, Expr, GenericArg, GenericParamKind, Generics,
 169     Mutability, PatKind, TyKind, VariantData,
 170 };
 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;
 177 use std::iter;
 178 use std::ops::Not;
 179 use std::vec;
 180 use thin_vec::thin_vec;
 181 use ty::{Bounds, Path, Ref, Self_, Ty};
 182
 183 pub mod ty;
 184
 185 pub struct TraitDef<'a> {
 186     /// The span for the current #[derive(Foo)] header.
 187     pub span: Span,
 188
 189     /// Path of the trait, including any type parameters
 190     pub path: Path,
 191
 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,
 194
 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,
 197
 198     /// Additional bounds required of any type parameters of the type,
 199     /// other than the current trait
 200     pub additional_bounds: Vec<Ty>,
 201
 202     /// Can this trait be derived for unions?
 203     pub supports_unions: bool,
 204
 205     pub methods: Vec<MethodDef<'a>>,
 206
 207     pub associated_types: Vec<(Ident, Ty)>,
 208
 209     pub is_const: bool,
 210 }
 211
 212 pub struct MethodDef<'a> {
 213     /// name of the method
 214     pub name: Symbol,
 215     /// List of generics, e.g., `R: rand::Rng`
 216     pub generics: Bounds,
 217
 218     /// Is there is a `&self` argument? If not, it is a static function.
 219     pub explicit_self: bool,
 220
 221     /// Arguments other than the self argument.
 222     pub nonself_args: Vec<(Ty, Symbol)>,
 223
 224     /// Returns type
 225     pub ret_ty: Ty,
 226
 227     pub attributes: ast::AttrVec,
 228
 229     pub fieldless_variants_strategy: FieldlessVariantsStrategy,
 230
 231     pub combine_substructure: RefCell<CombineSubstructureFunc<'a>>,
 232 }
 233
 234 /// How to handle fieldless enum variants.
 235 #[derive(PartialEq)]
 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.
 240     Unify,
 241     /// Don't do anything special about fieldless variants. They are
 242     /// handled like any other variant.
 243     Default,
 244     /// If all variants of the enum are fieldless, expand the special
 245     /// `AllFieldLessEnum` substructure, so that the entire enum can be handled
 246     /// at once.
 247     SpecializeIfAllVariantsFieldless,
 248 }
 249
 250 /// All the data about the data structure/method being derived upon.
 251 pub struct Substructure<'a> {
 252     /// ident of self
 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>,
 258 }
 259
 260 /// Summary of the relevant parts of a struct/enum field.
 261 pub struct FieldInfo {
 262     pub span: Span,
 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>>,
 272 }
 273
 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)>),
 280 }
 281
 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>),
 286
 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),
 291
 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
 294     /// variant.
 295     EnumMatching(usize, usize, &'a ast::Variant, Vec<FieldInfo>),
 296
 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>>),
 301
 302     /// A static method where `Self` is a struct.
 303     StaticStruct(&'a ast::VariantData, StaticFields),
 304
 305     /// A static method where `Self` is an enum.
 306     StaticEnum(&'a ast::EnumDef, Vec<(Ident, Span, StaticFields)>),
 307 }
 308
 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>;
 313
 314 pub fn combine_substructure(
 315     f: CombineSubstructureFunc<'_>,
 316 ) -> RefCell<CombineSubstructureFunc<'_>> {
 317     RefCell::new(f)
 318 }
 319
 320 struct TypeParameter {
 321     bound_generic_params: Vec<ast::GenericParam>,
 322     ty: P<ast::Ty>,
 323 }
 324
 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.
 329 ///
 330 /// The statements come before the expression.
 331 pub struct BlockOrExpr(Vec<ast::Stmt>, Option<P<Expr>>);
 332
 333 impl BlockOrExpr {
 334     pub fn new_stmts(stmts: Vec<ast::Stmt>) -> BlockOrExpr {
 335         BlockOrExpr(stmts, None)
 336     }
 337
 338     pub fn new_expr(expr: P<Expr>) -> BlockOrExpr {
 339         BlockOrExpr(vec![], Some(expr))
 340     }
 341
 342     pub fn new_mixed(stmts: Vec<ast::Stmt>, expr: Option<P<Expr>>) -> BlockOrExpr {
 343         BlockOrExpr(stmts, expr)
 344     }
 345
 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));
 350         }
 351         cx.block(span, self.0)
 352     }
 353
 354     // Converts it into an expression.
 355     fn into_expr(self, cx: &ExtCtxt<'_>, span: Span) -> P<Expr> {
 356         if self.0.is_empty() {
 357             match self.1 {
 358                 None => cx.expr_block(cx.block(span, vec![])),
 359                 Some(expr) => expr,
 360             }
 361         } else if self.0.len() == 1
 362             && let ast::StmtKind::Expr(expr) = &self.0[0].kind
 363             && self.1.is_none()
 364         {
 365             // There's only a single statement expression. Pull it out.
 366             expr.clone()
 367         } else {
 368             // Multiple statements and/or expressions.
 369             cx.expr_block(self.into_block(cx, span))
 370         }
 371     }
 372 }
 373
 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(
 379     ty: &ast::Ty,
 380     ty_param_names: &[Symbol],
 381     cx: &ExtCtxt<'_>,
 382 ) -> Vec<TypeParameter> {
 383     use rustc_ast::visit;
 384
 385     struct Visitor<'a, 'b> {
 386         cx: &'a ExtCtxt<'b>,
 387         ty_param_names: &'a [Symbol],
 388         bound_generic_params_stack: Vec<ast::GenericParam>,
 389         type_params: Vec<TypeParameter>,
 390     }
 391
 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)
 397             {
 398                 self.type_params.push(TypeParameter {
 399                     bound_generic_params: self.bound_generic_params_stack.clone(),
 400                     ty: P(ty.clone()),
 401                 });
 402             }
 403
 404             visit::walk_ty(self, ty)
 405         }
 406
 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());
 411
 412             visit::walk_poly_trait_ref(self, trait_ref);
 413
 414             self.bound_generic_params_stack.truncate(stack_len);
 415         }
 416
 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");
 419         }
 420     }
 421
 422     let mut visitor = Visitor {
 423         cx,
 424         ty_param_names,
 425         bound_generic_params_stack: Vec::new(),
 426         type_params: Vec::new(),
 427     };
 428     visit::Visitor::visit_ty(&mut visitor, ty);
 429
 430     visitor.type_params
 431 }
 432
 433 impl<'a> TraitDef<'a> {
 434     pub fn expand(
 435         self,
 436         cx: &mut ExtCtxt<'_>,
 437         mitem: &ast::MetaItem,
 438         item: &'a Annotatable,
 439         push: &mut dyn FnMut(Annotatable),
 440     ) {
 441         self.expand_ext(cx, mitem, item, push, false);
 442     }
 443
 444     pub fn expand_ext(
 445         self,
 446         cx: &mut ExtCtxt<'_>,
 447         mitem: &ast::MetaItem,
 448         item: &'a Annotatable,
 449         push: &mut dyn FnMut(Annotatable),
 450         from_scratch: bool,
 451     ) {
 452         match item {
 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 {
 457                             return true;
 458                         }
 459                     }
 460                     false
 461                 });
 462
 463                 let newitem = match &item.kind {
 464                     ast::ItemKind::Struct(struct_def, generics) => self.expand_struct_def(
 465                         cx,
 466                         &struct_def,
 467                         item.ident,
 468                         generics,
 469                         from_scratch,
 470                         is_packed,
 471                     ),
 472                     ast::ItemKind::Enum(enum_def, generics) => {
 473                         // We ignore `is_packed` here, because `repr(packed)`
 474                         // enums cause an error later on.
 475                         //
 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)
 479                     }
 480                     ast::ItemKind::Union(struct_def, generics) => {
 481                         if self.supports_unions {
 482                             self.expand_struct_def(
 483                                 cx,
 484                                 &struct_def,
 485                                 item.ident,
 486                                 generics,
 487                                 from_scratch,
 488                                 is_packed,
 489                             )
 490                         } else {
 491                             cx.span_err(mitem.span, "this trait cannot be derived for unions");
 492                             return;
 493                         }
 494                     }
 495                     _ => unreachable!(),
 496                 };
 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();
 500                 attrs.extend(
 501                     item.attrs
 502                         .iter()
 503                         .filter(|a| {
 504                             [
 505                                 sym::allow,
 506                                 sym::warn,
 507                                 sym::deny,
 508                                 sym::forbid,
 509                                 sym::stable,
 510                                 sym::unstable,
 511                             ]
 512                             .contains(&a.name_or_empty())
 513                         })
 514                         .cloned(),
 515                 );
 516                 push(Annotatable::Item(P(ast::Item { attrs, ..(*newitem).clone() })))
 517             }
 518             _ => unreachable!(),
 519         }
 520     }
 521
 522     /// Given that we are deriving a trait `DerivedTrait` for a type like:
 523     ///
 524     /// ```ignore (only-for-syntax-highlight)
 525     /// struct Struct<'a, ..., 'z, A, B: DeclaredTrait, C, ..., Z> where C: WhereTrait {
 526     ///     a: A,
 527     ///     b: B::Item,
 528     ///     b1: <B as DeclaredTrait>::Item,
 529     ///     c1: <C as WhereTrait>::Item,
 530     ///     c2: Option<<C as WhereTrait>::Item>,
 531     ///     ...
 532     /// }
 533     /// ```
 534     ///
 535     /// create an impl like:
 536     ///
 537     /// ```ignore (only-for-syntax-highlight)
 538     /// impl<'a, ..., 'z, A, B: DeclaredTrait, C, ... Z> where
 539     ///     C:                       WhereTrait,
 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,
 545     ///     ...
 546     /// {
 547     ///     ...
 548     /// }
 549     /// ```
 550     ///
 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(
 554         &self,
 555         cx: &mut ExtCtxt<'_>,
 556         type_ident: Ident,
 557         generics: &Generics,
 558         field_tys: Vec<P<ast::Ty>>,
 559         methods: Vec<P<ast::AssocItem>>,
 560         is_packed: bool,
 561     ) -> P<ast::Item> {
 562         let trait_path = self.path.to_path(cx, self.span, type_ident, generics);
 563
 564         // Transform associated types from `deriving::ty::Ty` into `ast::AssocItem`
 565         let associated_types = self.associated_types.iter().map(|&(ident, ref type_def)| {
 566             P(ast::AssocItem {
 567                 id: ast::DUMMY_NODE_ID,
 568                 span: self.span,
 569                 ident,
 570                 vis: ast::Visibility {
 571                     span: self.span.shrink_to_lo(),
 572                     kind: ast::VisibilityKind::Inherited,
 573                     tokens: None,
 574                 },
 575                 attrs: ast::AttrVec::new(),
 576                 kind: ast::AssocItemKind::Type(Box::new(ast::TyAlias {
 577                     defaultness: ast::Defaultness::Final,
 578                     generics: Generics::default(),
 579                     where_clauses: (
 580                         ast::TyAliasWhereClause::default(),
 581                         ast::TyAliasWhereClause::default(),
 582                     ),
 583                     where_predicates_split: 0,
 584                     bounds: Vec::new(),
 585                     ty: Some(type_def.to_ty(cx, self.span, type_ident, generics)),
 586                 })),
 587                 tokens: None,
 588             })
 589         });
 590
 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);
 595
 596         // Create the generic parameters
 597         let params: Vec<_> = generics
 598             .params
 599             .iter()
 600             .map(|param| match &param.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
 606                         .additional_bounds
 607                         .iter()
 608                         .map(|p| cx.trait_bound(p.to_path(cx, self.span, type_ident, generics)))
 609                         .chain(
 610                             // Add a bound for the current trait.
 611                             self.skip_path_as_bound
 612                                 .not()
 613                                 .then(|| cx.trait_bound(trait_path.clone())),
 614                         )
 615                         .chain({
 616                             // Add a `Copy` bound if required.
 617                             if is_packed && self.needs_copy_as_bound_if_packed {
 618                                 let p = deriving::path_std!(marker::Copy);
 619                                 Some(cx.trait_bound(p.to_path(cx, self.span, type_ident, generics)))
 620                             } else {
 621                                 None
 622                             }
 623                         })
 624                         .chain(
 625                             // Also add in any bounds from the declaration.
 626                             param.bounds.iter().cloned(),
 627                         )
 628                         .collect();
 629
 630                     cx.typaram(param.ident.span.with_ctxt(ctxt), param.ident, bounds, None)
 631                 }
 632                 GenericParamKind::Const { ty, kw_span, .. } => {
 633                     let const_nodefault_kind = GenericParamKind::Const {
 634                         ty: ty.clone(),
 635                         kw_span: kw_span.with_ctxt(ctxt),
 636
 637                         // We can't have default values inside impl block
 638                         default: None,
 639                     };
 640                     let mut param_clone = param.clone();
 641                     param_clone.kind = const_nodefault_kind;
 642                     param_clone
 643                 }
 644             })
 645             .collect();
 646
 647         // and similarly for where clauses
 648         where_clause.predicates.extend(generics.where_clause.predicates.iter().map(|clause| {
 649             match clause {
 650                 ast::WherePredicate::BoundPredicate(wb) => {
 651                     let span = wb.span.with_ctxt(ctxt);
 652                     ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
 653                         span,
 654                         ..wb.clone()
 655                     })
 656                 }
 657                 ast::WherePredicate::RegionPredicate(wr) => {
 658                     let span = wr.span.with_ctxt(ctxt);
 659                     ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate {
 660                         span,
 661                         ..wr.clone()
 662                     })
 663                 }
 664                 ast::WherePredicate::EqPredicate(we) => {
 665                     let span = we.span.with_ctxt(ctxt);
 666                     ast::WherePredicate::EqPredicate(ast::WhereEqPredicate { span, ..we.clone() })
 667                 }
 668             }
 669         }));
 670
 671         {
 672             // Extra scope required here so ty_params goes out of scope before params is moved
 673
 674             let mut ty_params = params
 675                 .iter()
 676                 .filter(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
 677                 .peekable();
 678
 679             if ty_params.peek().is_some() {
 680                 let ty_param_names: Vec<Symbol> =
 681                     ty_params.map(|ty_param| ty_param.ident.name).collect();
 682
 683                 for field_ty in field_tys {
 684                     let field_ty_params = find_type_parameters(&field_ty, &ty_param_names, cx);
 685
 686                     for field_ty_param in field_ty_params {
 687                         // if we have already handled this type, skip it
 688                         if let ast::TyKind::Path(_, p) = &field_ty_param.ty.kind
 689                             && let [sole_segment] = &*p.segments
 690                             && ty_param_names.contains(&sole_segment.ident.name)
 691                         {
 692                             continue;
 693                         }
 694                         let mut bounds: Vec<_> = self
 695                             .additional_bounds
 696                             .iter()
 697                             .map(|p| cx.trait_bound(p.to_path(cx, self.span, type_ident, generics)))
 698                             .collect();
 699
 700                         // Require the current trait.
 701                         bounds.push(cx.trait_bound(trait_path.clone()));
 702
 703                         // Add a `Copy` bound if required.
 704                         if is_packed && self.needs_copy_as_bound_if_packed {
 705                             let p = deriving::path_std!(marker::Copy);
 706                             bounds.push(
 707                                 cx.trait_bound(p.to_path(cx, self.span, type_ident, generics)),
 708                             );
 709                         }
 710
 711                         let predicate = ast::WhereBoundPredicate {
 712                             span: self.span,
 713                             bound_generic_params: field_ty_param.bound_generic_params,
 714                             bounded_ty: field_ty_param.ty,
 715                             bounds,
 716                         };
 717
 718                         let predicate = ast::WherePredicate::BoundPredicate(predicate);
 719                         where_clause.predicates.push(predicate);
 720                     }
 721                 }
 722             }
 723         }
 724
 725         let trait_generics = Generics { params, where_clause, span };
 726
 727         // Create the reference to the trait.
 728         let trait_ref = cx.trait_ref(trait_path);
 729
 730         let self_params: Vec<_> = generics
 731             .params
 732             .iter()
 733             .map(|param| match param.kind {
 734                 GenericParamKind::Lifetime { .. } => {
 735                     GenericArg::Lifetime(cx.lifetime(param.ident.span.with_ctxt(ctxt), param.ident))
 736                 }
 737                 GenericParamKind::Type { .. } => {
 738                     GenericArg::Type(cx.ty_ident(param.ident.span.with_ctxt(ctxt), param.ident))
 739                 }
 740                 GenericParamKind::Const { .. } => {
 741                     GenericArg::Const(cx.const_ident(param.ident.span.with_ctxt(ctxt), param.ident))
 742                 }
 743             })
 744             .collect();
 745
 746         // Create the type of `self`.
 747         let path = cx.path_all(self.span, false, vec![type_ident], self_params);
 748         let self_type = cx.ty_path(path);
 749
 750         let attr = cx.attr_word(sym::automatically_derived, self.span);
 751         let attrs = thin_vec![attr];
 752         let opt_trait_ref = Some(trait_ref);
 753
 754         cx.item(
 755             self.span,
 756             Ident::empty(),
 757             attrs,
 758             ast::ItemKind::Impl(Box::new(ast::Impl {
 759                 unsafety: ast::Unsafe::No,
 760                 polarity: ast::ImplPolarity::Positive,
 761                 defaultness: ast::Defaultness::Final,
 762                 constness: if self.is_const { ast::Const::Yes(DUMMY_SP) } else { ast::Const::No },
 763                 generics: trait_generics,
 764                 of_trait: opt_trait_ref,
 765                 self_ty: self_type,
 766                 items: methods.into_iter().chain(associated_types).collect(),
 767             })),
 768         )
 769     }
 770
 771     fn expand_struct_def(
 772         &self,
 773         cx: &mut ExtCtxt<'_>,
 774         struct_def: &'a VariantData,
 775         type_ident: Ident,
 776         generics: &Generics,
 777         from_scratch: bool,
 778         is_packed: bool,
 779     ) -> P<ast::Item> {
 780         let field_tys: Vec<P<ast::Ty>> =
 781             struct_def.fields().iter().map(|field| field.ty.clone()).collect();
 782
 783         let methods = self
 784             .methods
 785             .iter()
 786             .map(|method_def| {
 787                 let (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys) =
 788                     method_def.extract_arg_details(cx, self, type_ident, generics);
 789
 790                 let body = if from_scratch || method_def.is_static() {
 791                     method_def.expand_static_struct_method_body(
 792                         cx,
 793                         self,
 794                         struct_def,
 795                         type_ident,
 796                         &nonselflike_args,
 797                     )
 798                 } else {
 799                     method_def.expand_struct_method_body(
 800                         cx,
 801                         self,
 802                         struct_def,
 803                         type_ident,
 804                         &selflike_args,
 805                         &nonselflike_args,
 806                         is_packed,
 807                     )
 808                 };
 809
 810                 method_def.create_method(
 811                     cx,
 812                     self,
 813                     type_ident,
 814                     generics,
 815                     explicit_self,
 816                     nonself_arg_tys,
 817                     body,
 818                 )
 819             })
 820             .collect();
 821
 822         self.create_derived_impl(cx, type_ident, generics, field_tys, methods, is_packed)
 823     }
 824
 825     fn expand_enum_def(
 826         &self,
 827         cx: &mut ExtCtxt<'_>,
 828         enum_def: &'a EnumDef,
 829         type_ident: Ident,
 830         generics: &Generics,
 831         from_scratch: bool,
 832     ) -> P<ast::Item> {
 833         let mut field_tys = Vec::new();
 834
 835         for variant in &enum_def.variants {
 836             field_tys.extend(variant.data.fields().iter().map(|field| field.ty.clone()));
 837         }
 838
 839         let methods = self
 840             .methods
 841             .iter()
 842             .map(|method_def| {
 843                 let (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys) =
 844                     method_def.extract_arg_details(cx, self, type_ident, generics);
 845
 846                 let body = if from_scratch || method_def.is_static() {
 847                     method_def.expand_static_enum_method_body(
 848                         cx,
 849                         self,
 850                         enum_def,
 851                         type_ident,
 852                         &nonselflike_args,
 853                     )
 854                 } else {
 855                     method_def.expand_enum_method_body(
 856                         cx,
 857                         self,
 858                         enum_def,
 859                         type_ident,
 860                         selflike_args,
 861                         &nonselflike_args,
 862                     )
 863                 };
 864
 865                 method_def.create_method(
 866                     cx,
 867                     self,
 868                     type_ident,
 869                     generics,
 870                     explicit_self,
 871                     nonself_arg_tys,
 872                     body,
 873                 )
 874             })
 875             .collect();
 876
 877         let is_packed = false; // enums are never packed
 878         self.create_derived_impl(cx, type_ident, generics, field_tys, methods, is_packed)
 879     }
 880 }
 881
 882 impl<'a> MethodDef<'a> {
 883     fn call_substructure_method(
 884         &self,
 885         cx: &mut ExtCtxt<'_>,
 886         trait_: &TraitDef<'_>,
 887         type_ident: Ident,
 888         nonselflike_args: &[P<Expr>],
 889         fields: &SubstructureFields<'_>,
 890     ) -> BlockOrExpr {
 891         let span = trait_.span;
 892         let substructure = Substructure { type_ident, nonselflike_args, fields };
 893         let mut f = self.combine_substructure.borrow_mut();
 894         let f: &mut CombineSubstructureFunc<'_> = &mut *f;
 895         f(cx, span, &substructure)
 896     }
 897
 898     fn get_ret_ty(
 899         &self,
 900         cx: &mut ExtCtxt<'_>,
 901         trait_: &TraitDef<'_>,
 902         generics: &Generics,
 903         type_ident: Ident,
 904     ) -> P<ast::Ty> {
 905         self.ret_ty.to_ty(cx, trait_.span, type_ident, generics)
 906     }
 907
 908     fn is_static(&self) -> bool {
 909         !self.explicit_self
 910     }
 911
 912     // The return value includes:
 913     // - explicit_self: The `&self` arg, if present.
 914     // - selflike_args: Expressions for `&self` (if present) and also any other
 915     //   args with the same type (e.g. the `other` arg in `PartialEq::eq`).
 916     // - nonselflike_args: Expressions for all the remaining args.
 917     // - nonself_arg_tys: Additional information about all the args other than
 918     //   `&self`.
 919     fn extract_arg_details(
 920         &self,
 921         cx: &mut ExtCtxt<'_>,
 922         trait_: &TraitDef<'_>,
 923         type_ident: Ident,
 924         generics: &Generics,
 925     ) -> (Option<ast::ExplicitSelf>, Vec<P<Expr>>, Vec<P<Expr>>, Vec<(Ident, P<ast::Ty>)>) {
 926         let mut selflike_args = Vec::new();
 927         let mut nonselflike_args = Vec::new();
 928         let mut nonself_arg_tys = Vec::new();
 929         let span = trait_.span;
 930
 931         let explicit_self = if self.explicit_self {
 932             let (self_expr, explicit_self) = ty::get_explicit_self(cx, span);
 933             selflike_args.push(self_expr);
 934             Some(explicit_self)
 935         } else {
 936             None
 937         };
 938
 939         for (ty, name) in self.nonself_args.iter() {
 940             let ast_ty = ty.to_ty(cx, span, type_ident, generics);
 941             let ident = Ident::new(*name, span);
 942             nonself_arg_tys.push((ident, ast_ty));
 943
 944             let arg_expr = cx.expr_ident(span, ident);
 945
 946             match ty {
 947                 // Selflike (`&Self`) arguments only occur in non-static methods.
 948                 Ref(box Self_, _) if !self.is_static() => selflike_args.push(arg_expr),
 949                 Self_ => cx.span_bug(span, "`Self` in non-return position"),
 950                 _ => nonselflike_args.push(arg_expr),
 951             }
 952         }
 953
 954         (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys)
 955     }
 956
 957     fn create_method(
 958         &self,
 959         cx: &mut ExtCtxt<'_>,
 960         trait_: &TraitDef<'_>,
 961         type_ident: Ident,
 962         generics: &Generics,
 963         explicit_self: Option<ast::ExplicitSelf>,
 964         nonself_arg_tys: Vec<(Ident, P<ast::Ty>)>,
 965         body: BlockOrExpr,
 966     ) -> P<ast::AssocItem> {
 967         let span = trait_.span;
 968         // Create the generics that aren't for `Self`.
 969         let fn_generics = self.generics.to_generics(cx, span, type_ident, generics);
 970
 971         let args = {
 972             let self_arg = explicit_self.map(|explicit_self| {
 973                 let ident = Ident::with_dummy_span(kw::SelfLower).with_span_pos(span);
 974                 ast::Param::from_self(ast::AttrVec::default(), explicit_self, ident)
 975             });
 976             let nonself_args =
 977                 nonself_arg_tys.into_iter().map(|(name, ty)| cx.param(span, name, ty));
 978             self_arg.into_iter().chain(nonself_args).collect()
 979         };
 980
 981         let ret_type = self.get_ret_ty(cx, trait_, generics, type_ident);
 982
 983         let method_ident = Ident::new(self.name, span);
 984         let fn_decl = cx.fn_decl(args, ast::FnRetTy::Ty(ret_type));
 985         let body_block = body.into_block(cx, span);
 986
 987         let trait_lo_sp = span.shrink_to_lo();
 988
 989         let sig = ast::FnSig { header: ast::FnHeader::default(), decl: fn_decl, span };
 990         let defaultness = ast::Defaultness::Final;
 991
 992         // Create the method.
 993         P(ast::AssocItem {
 994             id: ast::DUMMY_NODE_ID,
 995             attrs: self.attributes.clone(),
 996             span,
 997             vis: ast::Visibility {
 998                 span: trait_lo_sp,
 999                 kind: ast::VisibilityKind::Inherited,
1000                 tokens: None,
1001             },
1002             ident: method_ident,
1003             kind: ast::AssocItemKind::Fn(Box::new(ast::Fn {
1004                 defaultness,
1005                 sig,
1006                 generics: fn_generics,
1007                 body: Some(body_block),
1008             })),
1009             tokens: None,
1010         })
1011     }
1012
1013     /// The normal case uses field access.
1014     /// ```
1015     /// #[derive(PartialEq)]
1016     /// # struct Dummy;
1017     /// struct A { x: u8, y: u8 }
1018     ///
1019     /// // equivalent to:
1020     /// impl PartialEq for A {
1021     ///     fn eq(&self, other: &A) -> bool {
1022     ///         self.x == other.x && self.y == other.y
1023     ///     }
1024     /// }
1025     /// ```
1026     /// But if the struct is `repr(packed)`, we can't use something like
1027     /// `&self.x` because that might cause an unaligned ref. So for any trait
1028     /// method that takes a reference, we use a local block to force a copy.
1029     /// This requires that the field impl `Copy`.
1030     /// ```
1031     /// # struct A { x: u8, y: u8 }
1032     /// impl PartialEq for A {
1033     ///     fn eq(&self, other: &A) -> bool {
1034     ///         // Desugars to `{ self.x }.eq(&{ other.y }) && ...`
1035     ///         { self.x } == { other.y } && { self.y } == { other.y }
1036     ///     }
1037     /// }
1038     /// impl Hash for A {
1039     ///     fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
1040     ///         ::core::hash::Hash::hash(&{ self.x }, state);
1041     ///         ::core::hash::Hash::hash(&{ self.y }, state)
1042     ///     }
1043     /// }
1044     fn expand_struct_method_body<'b>(
1045         &self,
1046         cx: &mut ExtCtxt<'_>,
1047         trait_: &TraitDef<'b>,
1048         struct_def: &'b VariantData,
1049         type_ident: Ident,
1050         selflike_args: &[P<Expr>],
1051         nonselflike_args: &[P<Expr>],
1052         is_packed: bool,
1053     ) -> BlockOrExpr {
1054         assert!(selflike_args.len() == 1 || selflike_args.len() == 2);
1055
1056         let selflike_fields =
1057             trait_.create_struct_field_access_fields(cx, selflike_args, struct_def, is_packed);
1058         self.call_substructure_method(
1059             cx,
1060             trait_,
1061             type_ident,
1062             nonselflike_args,
1063             &Struct(struct_def, selflike_fields),
1064         )
1065     }
1066
1067     fn expand_static_struct_method_body(
1068         &self,
1069         cx: &mut ExtCtxt<'_>,
1070         trait_: &TraitDef<'_>,
1071         struct_def: &VariantData,
1072         type_ident: Ident,
1073         nonselflike_args: &[P<Expr>],
1074     ) -> BlockOrExpr {
1075         let summary = trait_.summarise_struct(cx, struct_def);
1076
1077         self.call_substructure_method(
1078             cx,
1079             trait_,
1080             type_ident,
1081             nonselflike_args,
1082             &StaticStruct(struct_def, summary),
1083         )
1084     }
1085
1086     /// ```
1087     /// #[derive(PartialEq)]
1088     /// # struct Dummy;
1089     /// enum A {
1090     ///     A1,
1091     ///     A2(i32)
1092     /// }
1093     /// ```
1094     /// is equivalent to:
1095     /// ```
1096     /// #![feature(core_intrinsics)]
1097     /// enum A {
1098     ///     A1,
1099     ///     A2(i32)
1100     /// }
1101     /// impl ::core::cmp::PartialEq for A {
1102     ///     #[inline]
1103     ///     fn eq(&self, other: &A) -> bool {
1104     ///         let __self_tag = ::core::intrinsics::discriminant_value(self);
1105     ///         let __arg1_tag = ::core::intrinsics::discriminant_value(other);
1106     ///         __self_tag == __arg1_tag &&
1107     ///             match (self, other) {
1108     ///                 (A::A2(__self_0), A::A2(__arg1_0)) =>
1109     ///                     *__self_0 == *__arg1_0,
1110     ///                 _ => true,
1111     ///             }
1112     ///     }
1113     /// }
1114     /// ```
1115     /// Creates a tag check combined with a match for a tuple of all
1116     /// `selflike_args`, with an arm for each variant with fields, possibly an
1117     /// arm for each fieldless variant (if `unify_fieldless_variants` is not
1118     /// `Unify`), and possibly a default arm.
1119     fn expand_enum_method_body<'b>(
1120         &self,
1121         cx: &mut ExtCtxt<'_>,
1122         trait_: &TraitDef<'b>,
1123         enum_def: &'b EnumDef,
1124         type_ident: Ident,
1125         selflike_args: Vec<P<Expr>>,
1126         nonselflike_args: &[P<Expr>],
1127     ) -> BlockOrExpr {
1128         let span = trait_.span;
1129         let variants = &enum_def.variants;
1130
1131         // Traits that unify fieldless variants always use the tag(s).
1132         let unify_fieldless_variants =
1133             self.fieldless_variants_strategy == FieldlessVariantsStrategy::Unify;
1134
1135         // There is no sensible code to be generated for *any* deriving on a
1136         // zero-variant enum. So we just generate a failing expression.
1137         if variants.is_empty() {
1138             return BlockOrExpr(vec![], Some(deriving::call_unreachable(cx, span)));
1139         }
1140
1141         let prefixes = iter::once("__self".to_string())
1142             .chain(
1143                 selflike_args
1144                     .iter()
1145                     .enumerate()
1146                     .skip(1)
1147                     .map(|(arg_count, _selflike_arg)| format!("__arg{}", arg_count)),
1148             )
1149             .collect::<Vec<String>>();
1150
1151         // Build a series of let statements mapping each selflike_arg
1152         // to its discriminant value.
1153         //
1154         // e.g. for `PartialEq::eq` builds two statements:
1155         // ```
1156         // let __self_tag = ::core::intrinsics::discriminant_value(self);
1157         // let __arg1_tag = ::core::intrinsics::discriminant_value(other);
1158         // ```
1159         let get_tag_pieces = |cx: &ExtCtxt<'_>| {
1160             let tag_idents: Vec<_> = prefixes
1161                 .iter()
1162                 .map(|name| Ident::from_str_and_span(&format!("{}_tag", name), span))
1163                 .collect();
1164
1165             let mut tag_exprs: Vec<_> = tag_idents
1166                 .iter()
1167                 .map(|&ident| cx.expr_addr_of(span, cx.expr_ident(span, ident)))
1168                 .collect();
1169
1170             let self_expr = tag_exprs.remove(0);
1171             let other_selflike_exprs = tag_exprs;
1172             let tag_field = FieldInfo { span, name: None, self_expr, other_selflike_exprs };
1173
1174             let tag_let_stmts: Vec<_> = iter::zip(&tag_idents, &selflike_args)
1175                 .map(|(&ident, selflike_arg)| {
1176                     let variant_value = deriving::call_intrinsic(
1177                         cx,
1178                         span,
1179                         sym::discriminant_value,
1180                         vec![selflike_arg.clone()],
1181                     );
1182                     cx.stmt_let(span, false, ident, variant_value)
1183                 })
1184                 .collect();
1185
1186             (tag_field, tag_let_stmts)
1187         };
1188
1189         // There are some special cases involving fieldless enums where no
1190         // match is necessary.
1191         let all_fieldless = variants.iter().all(|v| v.data.fields().is_empty());
1192         if all_fieldless {
1193             if variants.len() > 1 {
1194                 match self.fieldless_variants_strategy {
1195                     FieldlessVariantsStrategy::Unify => {
1196                         // If the type is fieldless and the trait uses the tag and
1197                         // there are multiple variants, we need just an operation on
1198                         // the tag(s).
1199                         let (tag_field, mut tag_let_stmts) = get_tag_pieces(cx);
1200                         let mut tag_check = self.call_substructure_method(
1201                             cx,
1202                             trait_,
1203                             type_ident,
1204                             nonselflike_args,
1205                             &EnumTag(tag_field, None),
1206                         );
1207                         tag_let_stmts.append(&mut tag_check.0);
1208                         return BlockOrExpr(tag_let_stmts, tag_check.1);
1209                     }
1210                     FieldlessVariantsStrategy::SpecializeIfAllVariantsFieldless => {
1211                         return self.call_substructure_method(
1212                             cx,
1213                             trait_,
1214                             type_ident,
1215                             nonselflike_args,
1216                             &AllFieldlessEnum(enum_def),
1217                         );
1218                     }
1219                     FieldlessVariantsStrategy::Default => (),
1220                 }
1221             } else if variants.len() == 1 {
1222                 // If there is a single variant, we don't need an operation on
1223                 // the tag(s). Just use the most degenerate result.
1224                 return self.call_substructure_method(
1225                     cx,
1226                     trait_,
1227                     type_ident,
1228                     nonselflike_args,
1229                     &EnumMatching(0, 1, &variants[0], Vec::new()),
1230                 );
1231             }
1232         }
1233
1234         // These arms are of the form:
1235         // (Variant1, Variant1, ...) => Body1
1236         // (Variant2, Variant2, ...) => Body2
1237         // ...
1238         // where each tuple has length = selflike_args.len()
1239         let mut match_arms: Vec<ast::Arm> = variants
1240             .iter()
1241             .enumerate()
1242             .filter(|&(_, v)| !(unify_fieldless_variants && v.data.fields().is_empty()))
1243             .map(|(index, variant)| {
1244                 // A single arm has form (&VariantK, &VariantK, ...) => BodyK
1245                 // (see "Final wrinkle" note below for why.)
1246
1247                 let fields = trait_.create_struct_pattern_fields(cx, &variant.data, &prefixes);
1248
1249                 let sp = variant.span.with_ctxt(trait_.span.ctxt());
1250                 let variant_path = cx.path(sp, vec![type_ident, variant.ident]);
1251                 let by_ref = ByRef::No; // because enums can't be repr(packed)
1252                 let mut subpats: Vec<_> = trait_.create_struct_patterns(
1253                     cx,
1254                     variant_path,
1255                     &variant.data,
1256                     &prefixes,
1257                     by_ref,
1258                 );
1259
1260                 // `(VariantK, VariantK, ...)` or just `VariantK`.
1261                 let single_pat = if subpats.len() == 1 {
1262                     subpats.pop().unwrap()
1263                 } else {
1264                     cx.pat_tuple(span, subpats)
1265                 };
1266
1267                 // For the BodyK, we need to delegate to our caller,
1268                 // passing it an EnumMatching to indicate which case
1269                 // we are in.
1270                 //
1271                 // Now, for some given VariantK, we have built up
1272                 // expressions for referencing every field of every
1273                 // Self arg, assuming all are instances of VariantK.
1274                 // Build up code associated with such a case.
1275                 let substructure = EnumMatching(index, variants.len(), variant, fields);
1276                 let arm_expr = self
1277                     .call_substructure_method(
1278                         cx,
1279                         trait_,
1280                         type_ident,
1281                         nonselflike_args,
1282                         &substructure,
1283                     )
1284                     .into_expr(cx, span);
1285
1286                 cx.arm(span, single_pat, arm_expr)
1287             })
1288             .collect();
1289
1290         // Add a default arm to the match, if necessary.
1291         let first_fieldless = variants.iter().find(|v| v.data.fields().is_empty());
1292         let default = match first_fieldless {
1293             Some(v) if unify_fieldless_variants => {
1294                 // We need a default case that handles all the fieldless
1295                 // variants. The index and actual variant aren't meaningful in
1296                 // this case, so just use dummy values.
1297                 Some(
1298                     self.call_substructure_method(
1299                         cx,
1300                         trait_,
1301                         type_ident,
1302                         nonselflike_args,
1303                         &EnumMatching(0, variants.len(), v, Vec::new()),
1304                     )
1305                     .into_expr(cx, span),
1306                 )
1307             }
1308             _ if variants.len() > 1 && selflike_args.len() > 1 => {
1309                 // Because we know that all the arguments will match if we reach
1310                 // the match expression we add the unreachable intrinsics as the
1311                 // result of the default which should help llvm in optimizing it.
1312                 Some(deriving::call_unreachable(cx, span))
1313             }
1314             _ => None,
1315         };
1316         if let Some(arm) = default {
1317             match_arms.push(cx.arm(span, cx.pat_wild(span), arm));
1318         }
1319
1320         // Create a match expression with one arm per discriminant plus
1321         // possibly a default arm, e.g.:
1322         //      match (self, other) {
1323         //          (Variant1, Variant1, ...) => Body1
1324         //          (Variant2, Variant2, ...) => Body2,
1325         //          ...
1326         //          _ => ::core::intrinsics::unreachable()
1327         //      }
1328         let get_match_expr = |mut selflike_args: Vec<P<Expr>>| {
1329             let match_arg = if selflike_args.len() == 1 {
1330                 selflike_args.pop().unwrap()
1331             } else {
1332                 cx.expr(span, ast::ExprKind::Tup(selflike_args))
1333             };
1334             cx.expr_match(span, match_arg, match_arms)
1335         };
1336
1337         // If the trait uses the tag and there are multiple variants, we need
1338         // to add a tag check operation before the match. Otherwise, the match
1339         // is enough.
1340         if unify_fieldless_variants && variants.len() > 1 {
1341             let (tag_field, mut tag_let_stmts) = get_tag_pieces(cx);
1342
1343             // Combine a tag check with the match.
1344             let mut tag_check_plus_match = self.call_substructure_method(
1345                 cx,
1346                 trait_,
1347                 type_ident,
1348                 nonselflike_args,
1349                 &EnumTag(tag_field, Some(get_match_expr(selflike_args))),
1350             );
1351             tag_let_stmts.append(&mut tag_check_plus_match.0);
1352             BlockOrExpr(tag_let_stmts, tag_check_plus_match.1)
1353         } else {
1354             BlockOrExpr(vec![], Some(get_match_expr(selflike_args)))
1355         }
1356     }
1357
1358     fn expand_static_enum_method_body(
1359         &self,
1360         cx: &mut ExtCtxt<'_>,
1361         trait_: &TraitDef<'_>,
1362         enum_def: &EnumDef,
1363         type_ident: Ident,
1364         nonselflike_args: &[P<Expr>],
1365     ) -> BlockOrExpr {
1366         let summary = enum_def
1367             .variants
1368             .iter()
1369             .map(|v| {
1370                 let sp = v.span.with_ctxt(trait_.span.ctxt());
1371                 let summary = trait_.summarise_struct(cx, &v.data);
1372                 (v.ident, sp, summary)
1373             })
1374             .collect();
1375         self.call_substructure_method(
1376             cx,
1377             trait_,
1378             type_ident,
1379             nonselflike_args,
1380             &StaticEnum(enum_def, summary),
1381         )
1382     }
1383 }
1384
1385 // general helper methods.
1386 impl<'a> TraitDef<'a> {
1387     fn summarise_struct(&self, cx: &mut ExtCtxt<'_>, struct_def: &VariantData) -> StaticFields {
1388         let mut named_idents = Vec::new();
1389         let mut just_spans = Vec::new();
1390         for field in struct_def.fields() {
1391             let sp = field.span.with_ctxt(self.span.ctxt());
1392             match field.ident {
1393                 Some(ident) => named_idents.push((ident, sp)),
1394                 _ => just_spans.push(sp),
1395             }
1396         }
1397
1398         let is_tuple = matches!(struct_def, ast::VariantData::Tuple(..));
1399         match (just_spans.is_empty(), named_idents.is_empty()) {
1400             (false, false) => {
1401                 cx.span_bug(self.span, "a struct with named and unnamed fields in generic `derive`")
1402             }
1403             // named fields
1404             (_, false) => Named(named_idents),
1405             // unnamed fields
1406             (false, _) => Unnamed(just_spans, is_tuple),
1407             // empty
1408             _ => Named(Vec::new()),
1409         }
1410     }
1411
1412     fn create_struct_patterns(
1413         &self,
1414         cx: &mut ExtCtxt<'_>,
1415         struct_path: ast::Path,
1416         struct_def: &'a VariantData,
1417         prefixes: &[String],
1418         by_ref: ByRef,
1419     ) -> Vec<P<ast::Pat>> {
1420         prefixes
1421             .iter()
1422             .map(|prefix| {
1423                 let pieces_iter =
1424                     struct_def.fields().iter().enumerate().map(|(i, struct_field)| {
1425                         let sp = struct_field.span.with_ctxt(self.span.ctxt());
1426                         let ident = self.mk_pattern_ident(prefix, i);
1427                         let path = ident.with_span_pos(sp);
1428                         (
1429                             sp,
1430                             struct_field.ident,
1431                             cx.pat(
1432                                 path.span,
1433                                 PatKind::Ident(
1434                                     BindingAnnotation(by_ref, Mutability::Not),
1435                                     path,
1436                                     None,
1437                                 ),
1438                             ),
1439                         )
1440                     });
1441
1442                 let struct_path = struct_path.clone();
1443                 match *struct_def {
1444                     VariantData::Struct(..) => {
1445                         let field_pats = pieces_iter
1446                             .map(|(sp, ident, pat)| {
1447                                 if ident.is_none() {
1448                                     cx.span_bug(
1449                                         sp,
1450                                         "a braced struct with unnamed fields in `derive`",
1451                                     );
1452                                 }
1453                                 ast::PatField {
1454                                     ident: ident.unwrap(),
1455                                     is_shorthand: false,
1456                                     attrs: ast::AttrVec::new(),
1457                                     id: ast::DUMMY_NODE_ID,
1458                                     span: pat.span.with_ctxt(self.span.ctxt()),
1459                                     pat,
1460                                     is_placeholder: false,
1461                                 }
1462                             })
1463                             .collect();
1464                         cx.pat_struct(self.span, struct_path, field_pats)
1465                     }
1466                     VariantData::Tuple(..) => {
1467                         let subpats = pieces_iter.map(|(_, _, subpat)| subpat).collect();
1468                         cx.pat_tuple_struct(self.span, struct_path, subpats)
1469                     }
1470                     VariantData::Unit(..) => cx.pat_path(self.span, struct_path),
1471                 }
1472             })
1473             .collect()
1474     }
1475
1476     fn create_fields<F>(&self, struct_def: &'a VariantData, mk_exprs: F) -> Vec<FieldInfo>
1477     where
1478         F: Fn(usize, &ast::FieldDef, Span) -> Vec<P<ast::Expr>>,
1479     {
1480         struct_def
1481             .fields()
1482             .iter()
1483             .enumerate()
1484             .map(|(i, struct_field)| {
1485                 // For this field, get an expr for each selflike_arg. E.g. for
1486                 // `PartialEq::eq`, one for each of `&self` and `other`.
1487                 let sp = struct_field.span.with_ctxt(self.span.ctxt());
1488                 let mut exprs: Vec<_> = mk_exprs(i, struct_field, sp);
1489                 let self_expr = exprs.remove(0);
1490                 let other_selflike_exprs = exprs;
1491                 FieldInfo {
1492                     span: sp.with_ctxt(self.span.ctxt()),
1493                     name: struct_field.ident,
1494                     self_expr,
1495                     other_selflike_exprs,
1496                 }
1497             })
1498             .collect()
1499     }
1500
1501     fn mk_pattern_ident(&self, prefix: &str, i: usize) -> Ident {
1502         Ident::from_str_and_span(&format!("{}_{}", prefix, i), self.span)
1503     }
1504
1505     fn create_struct_pattern_fields(
1506         &self,
1507         cx: &mut ExtCtxt<'_>,
1508         struct_def: &'a VariantData,
1509         prefixes: &[String],
1510     ) -> Vec<FieldInfo> {
1511         self.create_fields(struct_def, |i, _struct_field, sp| {
1512             prefixes
1513                 .iter()
1514                 .map(|prefix| {
1515                     let ident = self.mk_pattern_ident(prefix, i);
1516                     cx.expr_path(cx.path_ident(sp, ident))
1517                 })
1518                 .collect()
1519         })
1520     }
1521
1522     fn create_struct_field_access_fields(
1523         &self,
1524         cx: &mut ExtCtxt<'_>,
1525         selflike_args: &[P<Expr>],
1526         struct_def: &'a VariantData,
1527         is_packed: bool,
1528     ) -> Vec<FieldInfo> {
1529         self.create_fields(struct_def, |i, struct_field, sp| {
1530             selflike_args
1531                 .iter()
1532                 .map(|selflike_arg| {
1533                     // Note: we must use `struct_field.span` rather than `sp` in the
1534                     // `unwrap_or_else` case otherwise the hygiene is wrong and we get
1535                     // "field `0` of struct `Point` is private" errors on tuple
1536                     // structs.
1537                     let mut field_expr = cx.expr(
1538                         sp,
1539                         ast::ExprKind::Field(
1540                             selflike_arg.clone(),
1541                             struct_field.ident.unwrap_or_else(|| {
1542                                 Ident::from_str_and_span(&i.to_string(), struct_field.span)
1543                             }),
1544                         ),
1545                     );
1546                     // In general, fields in packed structs are copied via a
1547                     // block, e.g. `&{self.0}`. The one exception is `[u8]`
1548                     // fields, which cannot be copied and also never cause
1549                     // unaligned references. This exception is allowed to
1550                     // handle the `FlexZeroSlice` type in the `zerovec` crate
1551                     // within `icu4x-0.9.0`.
1552                     //
1553                     // Once use of `icu4x-0.9.0` has dropped sufficiently, this
1554                     // exception should be removed.
1555                     let is_u8_slice = if let TyKind::Slice(ty) = &struct_field.ty.kind &&
1556                         let TyKind::Path(None, rustc_ast::Path { segments, .. }) = &ty.kind &&
1557                         let [seg] = segments.as_slice() &&
1558                         seg.ident.name == sym::u8 && seg.args.is_none()
1559                     {
1560                         true
1561                     } else {
1562                         false
1563                     };
1564                     if is_packed {
1565                         if is_u8_slice {
1566                             cx.sess.parse_sess.buffer_lint_with_diagnostic(
1567                                 BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE,
1568                                 sp,
1569                                 ast::CRATE_NODE_ID,
1570                                 "byte slice in a packed struct that derives a built-in trait",
1571                                 rustc_lint_defs::BuiltinLintDiagnostics::ByteSliceInPackedStructWithDerive
1572                             );
1573                         } else {
1574                             // Wrap the expression in `{...}`, causing a copy.
1575                             field_expr = cx.expr_block(
1576                                 cx.block(struct_field.span, vec![cx.stmt_expr(field_expr)]),
1577                             );
1578                         }
1579                     }
1580                     cx.expr_addr_of(sp, field_expr)
1581                 })
1582                 .collect()
1583         })
1584     }
1585 }
1586
1587 /// The function passed to `cs_fold` is called repeatedly with a value of this
1588 /// type. It describes one part of the code generation. The result is always an
1589 /// expression.
1590 pub enum CsFold<'a> {
1591     /// The basic case: a field expression for one or more selflike args. E.g.
1592     /// for `PartialEq::eq` this is something like `self.x == other.x`.
1593     Single(&'a FieldInfo),
1594
1595     /// The combination of two field expressions. E.g. for `PartialEq::eq` this
1596     /// is something like `<field1 equality> && <field2 equality>`.
1597     Combine(Span, P<Expr>, P<Expr>),
1598
1599     // The fallback case for a struct or enum variant with no fields.
1600     Fieldless,
1601 }
1602
1603 /// Folds over fields, combining the expressions for each field in a sequence.
1604 /// Statics may not be folded over.
1605 pub fn cs_fold<F>(
1606     use_foldl: bool,
1607     cx: &mut ExtCtxt<'_>,
1608     trait_span: Span,
1609     substructure: &Substructure<'_>,
1610     mut f: F,
1611 ) -> P<Expr>
1612 where
1613     F: FnMut(&mut ExtCtxt<'_>, CsFold<'_>) -> P<Expr>,
1614 {
1615     match substructure.fields {
1616         EnumMatching(.., all_fields) | Struct(_, all_fields) => {
1617             if all_fields.is_empty() {
1618                 return f(cx, CsFold::Fieldless);
1619             }
1620
1621             let (base_field, rest) = if use_foldl {
1622                 all_fields.split_first().unwrap()
1623             } else {
1624                 all_fields.split_last().unwrap()
1625             };
1626
1627             let base_expr = f(cx, CsFold::Single(base_field));
1628
1629             let op = |old, field: &FieldInfo| {
1630                 let new = f(cx, CsFold::Single(field));
1631                 f(cx, CsFold::Combine(field.span, old, new))
1632             };
1633
1634             if use_foldl {
1635                 rest.iter().fold(base_expr, op)
1636             } else {
1637                 rest.iter().rfold(base_expr, op)
1638             }
1639         }
1640         EnumTag(tag_field, match_expr) => {
1641             let tag_check_expr = f(cx, CsFold::Single(tag_field));
1642             if let Some(match_expr) = match_expr {
1643                 if use_foldl {
1644                     f(cx, CsFold::Combine(trait_span, tag_check_expr, match_expr.clone()))
1645                 } else {
1646                     f(cx, CsFold::Combine(trait_span, match_expr.clone(), tag_check_expr))
1647                 }
1648             } else {
1649                 tag_check_expr
1650             }
1651         }
1652         StaticEnum(..) | StaticStruct(..) => cx.span_bug(trait_span, "static function in `derive`"),
1653         AllFieldlessEnum(..) => cx.span_bug(trait_span, "fieldless enum in `derive`"),
1654     }
1655 }