1//! Some code that abstracts away much of the boilerplate of writing2//! `derive` instances for traits. Among other things it manages getting3//! access to the fields of the 4 different sorts of structs and enum4//! 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 returning9//!   any type, other than vectors, bottom and closures.10//! - Generating `impl`s for types with type parameters and lifetimes11//!   (e.g., `Option<T>`), the parameters are automatically given the12//!   current trait as a bound. (This includes separate type parameters13//!   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` and17//! `SubstructureFields` objects. The latter groups 5 possibilities of the18//! arguments:19//!20//! - `Struct`, when `Self` is a struct (including tuple structs, e.g21//!   `struct T(i32, char)`).22//! - `EnumMatching`, when `Self` is an enum and all the arguments are the23//!   same variant of the enum (e.g., `Some(1)`, `Some(3)` and `Some(4)`)24//! - `EnumDiscr` when `Self` is an enum, for comparing the enum discriminants.25//! - `StaticEnum` and `StaticStruct` for static methods, where the type26//!   being derived upon is either an enum or struct respectively. (Any27//!   argument with type Self is just grouped among the non-self28//!   arguments.)29//!30//! In the first two cases, the values from the corresponding fields in31//! all the arguments are grouped together.32//!33//! The non-static cases have `Option<ident>` in several places associated34//! with field `expr`s. This represents the name of the field it is35//! associated with. It is only not `None` when the associated field has36//! an identifier in the source code. For example, the `x`s in the37//! following snippet38//!39//! ```rust40//! struct A {41//!     x: i32,42//! }43//!44//! struct B(i32);45//!46//! enum C {47//!     C0(i32),48//!     C1 { x: i32 }49//! }50//! ```51//!52//! The `i32`s in `B` and `C0` don't have an identifier, so the53//! `Option<ident>`s would be `None` for them.54//!55//! In the static cases, the structure is summarized, either into the just56//! spans of the fields or a list of spans and the field idents (for tuple57//! structs and record structs, respectively), or a list of these, for58//! enums (one for each variant). For empty struct and empty enum59//! variants, it is represented as a count of 0.60//!61//! # "`cs`" functions62//!63//! The `cs_...` functions ("combine substructure") are designed to64//! make life easier by providing some pre-made recipes for common65//! threads; mostly calling the function being derived on all the66//! arguments and then combining them back together in some way (or67//! letting the user chose that). They are not meant to be the only68//! way to handle the structures that this code creates.69//!70//! # Examples71//!72//! The following simplified `PartialEq` is used for in-code examples:73//!74//! ```rust75//! trait PartialEq {76//!     fn eq(&self, other: &Self) -> bool;77//! }78//!79//! impl PartialEq for i32 {80//!     fn eq(&self, other: &i32) -> bool {81//!         *self == *other82//!     }83//! }84//! ```85//!86//! Some examples of the values of `SubstructureFields` follow, using the87//! above `PartialEq`, `A`, `B` and `C`.88//!89//! ## Structs90//!91//! When generating the `expr` for the `A` impl, the `SubstructureFields` is92//!93//! ```text94//! Struct(vec![FieldInfo {95//!     span: <span of x>,96//!     name: Some(<ident of x>),97//!     self_: <expr for &self.x>,98//!     other: vec![<expr for &other.x>],99//! }])100//! ```101//!102//! For the `B` impl, called with `B(a)` and `B(b)`,103//!104//! ```text105//! Struct(vec![FieldInfo {106//!     span: <span of i32>,107//!     name: None,108//!     self_: <expr for &a>,109//!     other: vec![<expr for &b>],110//! }])111//! ```112//!113//! ## Enums114//!115//! When generating the `expr` for a call with `self == C0(a)` and `other116//! == C0(b)`, the SubstructureFields is117//!118//! ```text119//! EnumMatching(120//!     0,121//!     <ast::Variant for C0>,122//!     vec![FieldInfo {123//!         span: <span of i32>,124//!         name: None,125//!         self_: <expr for &a>,126//!         other: vec![<expr for &b>],127//!     }],128//! )129//! ```130//!131//! For `C1 {x}` and `C1 {x}`,132//!133//! ```text134//! EnumMatching(135//!     1,136//!     <ast::Variant for C1>,137//!     vec![FieldInfo {138//!         span: <span of x>,139//!         name: Some(<ident of x>),140//!         self_: <expr for &self.x>,141//!         other: vec![<expr for &other.x>],142//!     }],143//! )144//! ```145//!146//! For the discriminants,147//!148//! ```text149//! EnumDiscr(150//!     &[<ident of self discriminant>, <ident of other discriminant>],151//!     <expr to combine with>,152//! )153//! ```154//!155//! Note that this setup doesn't allow for the brute-force "match every variant156//! against every other variant" approach, which is bad because it produces a157//! quadratic amount of code (see #15375).158//!159//! ## Static160//!161//! A static method on the types above would result in,162//!163//! ```text164//! StaticStruct(<ast::VariantData of A>, Named(vec![(<ident of x>, <span of x>)]))165//!166//! StaticStruct(<ast::VariantData of B>, Unnamed(vec![<span of x>]))167//!168//! StaticEnum(169//!     <ast::EnumDef of C>,170//!     vec![171//!         (<ident of C0>, <span of C0>, Unnamed(vec![<span of i32>])),172//!         (<ident of C1>, <span of C1>, Named(vec![(<ident of x>, <span of x>)])),173//!     ],174//! )175//! ```176177use std::cell::RefCell;178use std::ops::Not;179use std::{iter, vec};180181pub(crate) use StaticFields::*;182pub(crate) use SubstructureFields::*;183use rustc_ast::token::{IdentIsRaw, LitKind, Token, TokenKind};184use rustc_ast::tokenstream::{DelimSpan, Spacing, TokenTree};185use rustc_ast::{186    self as ast, AnonConst, AttrArgs, BindingMode, ByRef, DelimArgs, EnumDef, Expr, GenericArg,187    GenericParamKind, Generics, Mutability, PatKind, Safety, VariantData,188};189use rustc_attr_parsing::AttributeParser;190use rustc_expand::base::{Annotatable, ExtCtxt};191use rustc_hir::Attribute;192use rustc_hir::attrs::{AttributeKind, ReprPacked};193use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};194use thin_vec::{ThinVec, thin_vec};195use ty::{Bounds, Path, Ref, Self_, Ty};196197use crate::{deriving, errors};198199pub(crate) mod ty;200201pub(crate) struct TraitDef<'a> {202    /// The span for the current #[derive(Foo)] header.203    pub span: Span,204205    /// Path of the trait, including any type parameters206    pub path: Path,207208    /// Whether to skip adding the current trait as a bound to the type parameters of the type.209    pub skip_path_as_bound: bool,210211    /// Whether `Copy` is needed as an additional bound on type parameters in a packed struct.212    pub needs_copy_as_bound_if_packed: bool,213214    /// Additional bounds required of any type parameters of the type,215    /// other than the current trait216    pub additional_bounds: Vec<Ty>,217218    /// Can this trait be derived for unions?219    pub supports_unions: bool,220221    pub methods: Vec<MethodDef<'a>>,222223    pub associated_types: Vec<(Ident, Ty)>,224225    pub is_const: bool,226227    pub is_staged_api_crate: bool,228229    /// The safety of the `impl`.230    pub safety: Safety,231232    /// Whether the added `impl` should appear in rustdoc output.233    pub document: bool,234}235236pub(crate) struct MethodDef<'a> {237    /// name of the method238    pub name: Symbol,239    /// List of generics, e.g., `R: rand::Rng`240    pub generics: Bounds,241242    /// Is there is a `&self` argument? If not, it is a static function.243    pub explicit_self: bool,244245    /// Arguments other than the self argument.246    pub nonself_args: Vec<(Ty, Symbol)>,247248    /// Returns type249    pub ret_ty: Ty,250251    pub attributes: ast::AttrVec,252253    pub fieldless_variants_strategy: FieldlessVariantsStrategy,254255    pub combine_substructure: RefCell<CombineSubstructureFunc<'a>>,256}257258/// How to handle fieldless enum variants.259#[derive(PartialEq)]260pub(crate) enum FieldlessVariantsStrategy {261    /// Combine fieldless variants into a single match arm.262    /// This assumes that relevant information has been handled263    /// by looking at the enum's discriminant.264    Unify,265    /// Don't do anything special about fieldless variants. They are266    /// handled like any other variant.267    Default,268    /// If all variants of the enum are fieldless, expand the special269    /// `AllFieldLessEnum` substructure, so that the entire enum can be handled270    /// at once.271    SpecializeIfAllVariantsFieldless,272}273274/// All the data about the data structure/method being derived upon.275pub(crate) struct Substructure<'a> {276    /// ident of self277    pub type_ident: Ident,278    /// Verbatim access to any non-selflike arguments, i.e. arguments that279    /// don't have type `&Self`.280    pub nonselflike_args: &'a [Box<Expr>],281    pub fields: &'a SubstructureFields<'a>,282}283284/// Summary of the relevant parts of a struct/enum field.285pub(crate) struct FieldInfo {286    pub span: Span,287    /// None for tuple structs/normal enum variants, Some for normal288    /// structs/struct enum variants.289    pub name: Option<Ident>,290    /// The expression corresponding to this field of `self`291    /// (specifically, a reference to it).292    pub self_expr: Box<Expr>,293    /// The expressions corresponding to references to this field in294    /// the other selflike arguments.295    pub other_selflike_exprs: Vec<Box<Expr>>,296    pub maybe_scalar: bool,297}298299#[derive(Copy, Clone)]300pub(crate) enum IsTuple {301    No,302    Yes,303}304305/// Fields for a static method306pub(crate) enum StaticFields<'a> {307    /// Tuple and unit structs/enum variants like this.308    Unnamed(Vec<Span>, IsTuple),309    /// Normal structs/struct variants.310    Named(Vec<(Ident, Span, Option<&'a AnonConst>)>),311}312313/// A summary of the possible sets of fields.314pub(crate) enum SubstructureFields<'a> {315    /// A non-static method where `Self` is a struct.316    Struct(&'a ast::VariantData, Vec<FieldInfo>),317318    /// A non-static method handling the entire enum at once319    /// (after it has been determined that none of the enum320    /// variants has any fields).321    AllFieldlessEnum(&'a ast::EnumDef),322323    /// Matching variants of the enum: variant index, ast::Variant,324    /// fields: the field name is only non-`None` in the case of a struct325    /// variant.326    EnumMatching(&'a ast::Variant, Vec<FieldInfo>),327328    /// The discriminant of an enum. The first field is a `FieldInfo` for the discriminants, as329    /// if they were fields. The second field is the expression to combine the330    /// discriminant expression with; it will be `None` if no match is necessary.331    EnumDiscr(FieldInfo, Option<Box<Expr>>),332333    /// A static method where `Self` is a struct.334    StaticStruct(&'a ast::VariantData, StaticFields<'a>),335336    /// A static method where `Self` is an enum.337    StaticEnum(&'a ast::EnumDef),338}339340/// Combine the values of all the fields together. The last argument is341/// all the fields of all the structures.342pub(crate) type CombineSubstructureFunc<'a> =343    Box<dyn FnMut(&ExtCtxt<'_>, Span, &Substructure<'_>) -> BlockOrExpr + 'a>;344345pub(crate) fn combine_substructure(346    f: CombineSubstructureFunc<'_>,347) -> RefCell<CombineSubstructureFunc<'_>> {348    RefCell::new(f)349}350351struct TypeParameter {352    bound_generic_params: ThinVec<ast::GenericParam>,353    ty: Box<ast::Ty>,354}355356/// The code snippets built up for derived code are sometimes used as blocks357/// (e.g. in a function body) and sometimes used as expressions (e.g. in a match358/// arm). This structure avoids committing to either form until necessary,359/// avoiding the insertion of any unnecessary blocks.360///361/// The statements come before the expression.362pub(crate) struct BlockOrExpr(ThinVec<ast::Stmt>, Option<Box<Expr>>);363364impl BlockOrExpr {365    pub(crate) fn new_stmts(stmts: ThinVec<ast::Stmt>) -> BlockOrExpr {366        BlockOrExpr(stmts, None)367    }368369    pub(crate) fn new_expr(expr: Box<Expr>) -> BlockOrExpr {370        BlockOrExpr(ThinVec::new(), Some(expr))371    }372373    pub(crate) fn new_mixed(stmts: ThinVec<ast::Stmt>, expr: Option<Box<Expr>>) -> BlockOrExpr {374        BlockOrExpr(stmts, expr)375    }376377    // Converts it into a block.378    fn into_block(mut self, cx: &ExtCtxt<'_>, span: Span) -> Box<ast::Block> {379        if let Some(expr) = self.1 {380            self.0.push(cx.stmt_expr(expr));381        }382        cx.block(span, self.0)383    }384385    // Converts it into an expression.386    fn into_expr(self, cx: &ExtCtxt<'_>, span: Span) -> Box<Expr> {387        if self.0.is_empty() {388            match self.1 {389                None => cx.expr_block(cx.block(span, ThinVec::new())),390                Some(expr) => expr,391            }392        } else if let [stmt] = self.0.as_slice()393            && let ast::StmtKind::Expr(expr) = &stmt.kind394            && self.1.is_none()395        {396            // There's only a single statement expression. Pull it out.397            expr.clone()398        } else {399            // Multiple statements and/or expressions.400            cx.expr_block(self.into_block(cx, span))401        }402    }403}404405/// This method helps to extract all the type parameters referenced from a406/// type. For a type parameter `<T>`, it looks for either a `TyPath` that407/// is not global and starts with `T`, or a `TyQPath`.408/// Also include bound generic params from the input type.409fn find_type_parameters(410    ty: &ast::Ty,411    ty_param_names: &[Symbol],412    cx: &ExtCtxt<'_>,413) -> Vec<TypeParameter> {414    use rustc_ast::visit;415416    struct Visitor<'a, 'b> {417        cx: &'a ExtCtxt<'b>,418        ty_param_names: &'a [Symbol],419        bound_generic_params_stack: ThinVec<ast::GenericParam>,420        type_params: Vec<TypeParameter>,421    }422423    impl<'a, 'b> visit::Visitor<'a> for Visitor<'a, 'b> {424        fn visit_ty(&mut self, ty: &'a ast::Ty) {425            let stack_len = self.bound_generic_params_stack.len();426            if let ast::TyKind::FnPtr(fn_ptr) = &ty.kind427                && !fn_ptr.generic_params.is_empty()428            {429                // Given a field `x: for<'a> fn(T::SomeType<'a>)`, we wan't to account for `'a` so430                // that we generate `where for<'a> T::SomeType<'a>: ::core::clone::Clone`. #122622431                self.bound_generic_params_stack.extend(fn_ptr.generic_params.iter().cloned());432            }433434            if let ast::TyKind::Path(_, path) = &ty.kind435                && let Some(segment) = path.segments.first()436                && self.ty_param_names.contains(&segment.ident.name)437            {438                self.type_params.push(TypeParameter {439                    bound_generic_params: self.bound_generic_params_stack.clone(),440                    ty: Box::new(ty.clone()),441                });442            }443444            visit::walk_ty(self, ty);445            self.bound_generic_params_stack.truncate(stack_len);446        }447448        // Place bound generic params on a stack, to extract them when a type is encountered.449        fn visit_poly_trait_ref(&mut self, trait_ref: &'a ast::PolyTraitRef) {450            let stack_len = self.bound_generic_params_stack.len();451            self.bound_generic_params_stack.extend(trait_ref.bound_generic_params.iter().cloned());452453            visit::walk_poly_trait_ref(self, trait_ref);454455            self.bound_generic_params_stack.truncate(stack_len);456        }457458        fn visit_mac_call(&mut self, mac: &ast::MacCall) {459            self.cx.dcx().emit_err(errors::DeriveMacroCall { span: mac.span() });460        }461    }462463    let mut visitor = Visitor {464        cx,465        ty_param_names,466        bound_generic_params_stack: ThinVec::new(),467        type_params: Vec::new(),468    };469    visit::Visitor::visit_ty(&mut visitor, ty);470471    visitor.type_params472}473474impl<'a> TraitDef<'a> {475    pub(crate) fn expand(476        self,477        cx: &ExtCtxt<'_>,478        mitem: &ast::MetaItem,479        item: &'a Annotatable,480        push: &mut dyn FnMut(Annotatable),481    ) {482        self.expand_ext(cx, mitem, item, push, false);483    }484485    pub(crate) fn expand_ext(486        self,487        cx: &ExtCtxt<'_>,488        mitem: &ast::MetaItem,489        item: &'a Annotatable,490        push: &mut dyn FnMut(Annotatable),491        from_scratch: bool,492    ) {493        match item {494            Annotatable::Item(item) => {495                let is_packed = matches!(496                    AttributeParser::parse_limited(cx.sess, &item.attrs, &[sym::repr]),497                    Some(Attribute::Parsed(AttributeKind::Repr { reprs, .. })) if reprs.iter().any(|(x, _)| matches!(x, ReprPacked(..)))498                );499500                let newitem = match &item.kind {501                    ast::ItemKind::Struct(ident, generics, struct_def) => self.expand_struct_def(502                        cx,503                        struct_def,504                        *ident,505                        generics,506                        from_scratch,507                        is_packed,508                    ),509                    ast::ItemKind::Enum(ident, generics, enum_def) => {510                        // We ignore `is_packed` here, because `repr(packed)`511                        // enums cause an error later on.512                        //513                        // This can only cause further compilation errors514                        // downstream in blatantly illegal code, so it is fine.515                        self.expand_enum_def(cx, enum_def, *ident, generics, from_scratch)516                    }517                    ast::ItemKind::Union(ident, generics, struct_def) => {518                        if self.supports_unions {519                            self.expand_struct_def(520                                cx,521                                struct_def,522                                *ident,523                                generics,524                                from_scratch,525                                is_packed,526                            )527                        } else {528                            cx.dcx().emit_err(errors::DeriveUnion { span: mitem.span });529                            return;530                        }531                    }532                    _ => unreachable!(),533                };534                // Keep the lint attributes of the previous item to control how the535                // generated implementations are linted536                let mut attrs = newitem.attrs.clone();537                attrs.extend(538                    item.attrs539                        .iter()540                        .filter(|a| {541                            a.has_any_name(&[542                                sym::allow,543                                sym::warn,544                                sym::deny,545                                sym::forbid,546                                sym::stable,547                                sym::unstable,548                            ])549                        })550                        .cloned(),551                );552                push(Annotatable::Item(Box::new(ast::Item { attrs, ..(*newitem).clone() })))553            }554            _ => unreachable!(),555        }556    }557558    /// Given that we are deriving a trait `DerivedTrait` for a type like:559    ///560    /// ```ignore (only-for-syntax-highlight)561    /// struct Struct<'a, ..., 'z, A, B: DeclaredTrait, C, ..., Z>562    /// where563    ///     C: WhereTrait,564    /// {565    ///     a: A,566    ///     b: B::Item,567    ///     b1: <B as DeclaredTrait>::Item,568    ///     c1: <C as WhereTrait>::Item,569    ///     c2: Option<<C as WhereTrait>::Item>,570    ///     ...571    /// }572    /// ```573    ///574    /// create an impl like:575    ///576    /// ```ignore (only-for-syntax-highlight)577    /// impl<'a, ..., 'z, A, B: DeclaredTrait, C, ..., Z>578    /// where579    ///     C: WhereTrait,580    ///     A: DerivedTrait + B1 + ... + BN,581    ///     B: DerivedTrait + B1 + ... + BN,582    ///     C: DerivedTrait + B1 + ... + BN,583    ///     B::Item: DerivedTrait + B1 + ... + BN,584    ///     <C as WhereTrait>::Item: DerivedTrait + B1 + ... + BN,585    ///     ...586    /// {587    ///     ...588    /// }589    /// ```590    ///591    /// where B1, ..., BN are the bounds given by `bounds_paths`.'. Z is a phantom type, and592    /// therefore does not get bound by the derived trait.593    fn create_derived_impl(594        &self,595        cx: &ExtCtxt<'_>,596        type_ident: Ident,597        generics: &Generics,598        field_tys: Vec<&ast::Ty>,599        methods: Vec<Box<ast::AssocItem>>,600        is_packed: bool,601    ) -> Box<ast::Item> {602        let trait_path = self.path.to_path(cx, self.span, type_ident, generics);603604        // Transform associated types from `deriving::ty::Ty` into `ast::AssocItem`605        let associated_types = self.associated_types.iter().map(|&(ident, ref type_def)| {606            Box::new(ast::AssocItem {607                id: ast::DUMMY_NODE_ID,608                span: self.span,609                vis: ast::Visibility {610                    span: self.span.shrink_to_lo(),611                    kind: ast::VisibilityKind::Inherited,612                    tokens: None,613                },614                attrs: ast::AttrVec::new(),615                kind: ast::AssocItemKind::Type(Box::new(ast::TyAlias {616                    defaultness: ast::Defaultness::Implicit,617                    ident,618                    generics: Generics::default(),619                    after_where_clause: ast::WhereClause::default(),620                    bounds: Vec::new(),621                    ty: Some(type_def.to_ty(cx, self.span, type_ident, generics)),622                })),623                tokens: None,624            })625        });626627        let mut where_clause = ast::WhereClause::default();628        where_clause.span = generics.where_clause.span;629        let ctxt = self.span.ctxt();630        let span = generics.span.with_ctxt(ctxt);631632        // Create the generic parameters633        let params: ThinVec<_> = generics634            .params635            .iter()636            .map(|param| match &param.kind {637                GenericParamKind::Lifetime { .. } => param.clone(),638                GenericParamKind::Type { .. } => {639                    // Extra restrictions on the generics parameters to the640                    // type being derived upon.641                    let span = param.ident.span.with_ctxt(ctxt);642                    let bounds: Vec<_> = self643                        .additional_bounds644                        .iter()645                        .map(|p| {646                            cx.trait_bound(p.to_path(cx, span, type_ident, generics), self.is_const)647                        })648                        .chain(649                            // Add a bound for the current trait.650                            self.skip_path_as_bound.not().then(|| {651                                let mut trait_path = trait_path.clone();652                                trait_path.span = span;653                                cx.trait_bound(trait_path, self.is_const)654                            }),655                        )656                        .chain({657                            // Add a `Copy` bound if required.658                            if is_packed && self.needs_copy_as_bound_if_packed {659                                let p = deriving::path_std!(marker::Copy);660                                Some(cx.trait_bound(661                                    p.to_path(cx, span, type_ident, generics),662                                    self.is_const,663                                ))664                            } else {665                                None666                            }667                        })668                        .chain(669                            // Also add in any bounds from the declaration.670                            param.bounds.iter().cloned(),671                        )672                        .collect();673674                    cx.typaram(span, param.ident, bounds, None)675                }676                GenericParamKind::Const { ty, span, .. } => {677                    let const_nodefault_kind = GenericParamKind::Const {678                        ty: ty.clone(),679                        span: span.with_ctxt(ctxt),680681                        // We can't have default values inside impl block682                        default: None,683                    };684                    let mut param_clone = param.clone();685                    param_clone.kind = const_nodefault_kind;686                    param_clone687                }688            })689            .map(|mut param| {690                // Remove all attributes, because there might be helper attributes691                // from other macros that will not be valid in the expanded implementation.692                param.attrs.clear();693                param694            })695            .collect();696697        // and similarly for where clauses698        where_clause.predicates.extend(generics.where_clause.predicates.iter().map(|clause| {699            ast::WherePredicate {700                attrs: clause.attrs.clone(),701                kind: clause.kind.clone(),702                id: ast::DUMMY_NODE_ID,703                span: clause.span.with_ctxt(ctxt),704                is_placeholder: false,705            }706        }));707708        let ty_param_names: Vec<Symbol> = params709            .iter()710            .filter(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))711            .map(|ty_param| ty_param.ident.name)712            .collect();713714        if !ty_param_names.is_empty() {715            for field_ty in field_tys {716                let field_ty_params = find_type_parameters(&field_ty, &ty_param_names, cx);717718                for field_ty_param in field_ty_params {719                    // if we have already handled this type, skip it720                    if let ast::TyKind::Path(_, p) = &field_ty_param.ty.kind721                        && let [sole_segment] = &*p.segments722                        && ty_param_names.contains(&sole_segment.ident.name)723                    {724                        continue;725                    }726                    let mut bounds: Vec<_> = self727                        .additional_bounds728                        .iter()729                        .map(|p| {730                            cx.trait_bound(731                                p.to_path(cx, self.span, type_ident, generics),732                                self.is_const,733                            )734                        })735                        .collect();736737                    // Require the current trait.738                    if !self.skip_path_as_bound {739                        bounds.push(cx.trait_bound(trait_path.clone(), self.is_const));740                    }741742                    // Add a `Copy` bound if required.743                    if is_packed && self.needs_copy_as_bound_if_packed {744                        let p = deriving::path_std!(marker::Copy);745                        bounds.push(cx.trait_bound(746                            p.to_path(cx, self.span, type_ident, generics),747                            self.is_const,748                        ));749                    }750751                    if !bounds.is_empty() {752                        let predicate = ast::WhereBoundPredicate {753                            bound_generic_params: field_ty_param.bound_generic_params,754                            bounded_ty: field_ty_param.ty,755                            bounds,756                        };757758                        let kind = ast::WherePredicateKind::BoundPredicate(predicate);759                        let predicate = ast::WherePredicate {760                            attrs: ThinVec::new(),761                            kind,762                            id: ast::DUMMY_NODE_ID,763                            span: self.span,764                            is_placeholder: false,765                        };766                        where_clause.predicates.push(predicate);767                    }768                }769            }770        }771772        let trait_generics = Generics { params, where_clause, span };773774        // Create the reference to the trait.775        let trait_ref = cx.trait_ref(trait_path);776777        let self_params: Vec<_> = generics778            .params779            .iter()780            .map(|param| match param.kind {781                GenericParamKind::Lifetime { .. } => {782                    GenericArg::Lifetime(cx.lifetime(param.ident.span.with_ctxt(ctxt), param.ident))783                }784                GenericParamKind::Type { .. } => {785                    GenericArg::Type(cx.ty_ident(param.ident.span.with_ctxt(ctxt), param.ident))786                }787                GenericParamKind::Const { .. } => {788                    GenericArg::Const(cx.const_ident(param.ident.span.with_ctxt(ctxt), param.ident))789                }790            })791            .collect();792793        // Create the type of `self`.794        let path =795            cx.path_all(type_ident.span.with_ctxt(ctxt), false, vec![type_ident], self_params);796        let self_type = cx.ty_path(path);797        let rustc_const_unstable =798            cx.path_ident(self.span, Ident::new(sym::rustc_const_unstable, self.span));799800        let mut attrs = thin_vec![cx.attr_word(sym::automatically_derived, self.span),];801802        // Only add `rustc_const_unstable` attributes if `derive_const` is used within libcore/libstd,803        // Other crates don't need stability attributes, so adding them is not useful, but libcore needs them804        // on all const trait impls.805        if self.is_const && self.is_staged_api_crate {806            attrs.push(807                cx.attr_nested(808                    rustc_ast::AttrItem {809                        unsafety: Safety::Default,810                        path: rustc_const_unstable,811                        args: rustc_ast::ast::AttrItemKind::Unparsed(AttrArgs::Delimited(812                            DelimArgs {813                                dspan: DelimSpan::from_single(self.span),814                                delim: rustc_ast::token::Delimiter::Parenthesis,815                                tokens: [816                                    TokenKind::Ident(sym::feature, IdentIsRaw::No),817                                    TokenKind::Eq,818                                    TokenKind::lit(LitKind::Str, sym::derive_const, None),819                                    TokenKind::Comma,820                                    TokenKind::Ident(sym::issue, IdentIsRaw::No),821                                    TokenKind::Eq,822                                    TokenKind::lit(LitKind::Str, sym::derive_const_issue, None),823                                ]824                                .into_iter()825                                .map(|kind| {826                                    TokenTree::Token(827                                        Token { kind, span: self.span },828                                        Spacing::Alone,829                                    )830                                })831                                .collect(),832                            },833                        )),834                        tokens: None,835                    },836                    self.span,837                ),838            )839        }840841        if !self.document {842            attrs.push(cx.attr_nested_word(sym::doc, sym::hidden, self.span));843        }844845        cx.item(846            self.span,847            attrs,848            ast::ItemKind::Impl(ast::Impl {849                generics: trait_generics,850                of_trait: Some(Box::new(ast::TraitImplHeader {851                    safety: self.safety,852                    polarity: ast::ImplPolarity::Positive,853                    defaultness: ast::Defaultness::Implicit,854                    trait_ref,855                })),856                constness: if self.is_const { ast::Const::Yes(DUMMY_SP) } else { ast::Const::No },857                self_ty: self_type,858                items: methods.into_iter().chain(associated_types).collect(),859            }),860        )861    }862863    fn expand_struct_def(864        &self,865        cx: &ExtCtxt<'_>,866        struct_def: &'a VariantData,867        type_ident: Ident,868        generics: &Generics,869        from_scratch: bool,870        is_packed: bool,871    ) -> Box<ast::Item> {872        let field_tys = Vec::from_iter(struct_def.fields().iter().map(|field| &*field.ty));873874        let methods = self875            .methods876            .iter()877            .map(|method_def| {878                let (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys) =879                    method_def.extract_arg_details(cx, self, type_ident, generics);880881                let body = if from_scratch || method_def.is_static() {882                    method_def.expand_static_struct_method_body(883                        cx,884                        self,885                        struct_def,886                        type_ident,887                        &nonselflike_args,888                    )889                } else {890                    method_def.expand_struct_method_body(891                        cx,892                        self,893                        struct_def,894                        type_ident,895                        &selflike_args,896                        &nonselflike_args,897                        is_packed,898                    )899                };900901                method_def.create_method(902                    cx,903                    self,904                    type_ident,905                    generics,906                    explicit_self,907                    nonself_arg_tys,908                    body,909                )910            })911            .collect();912913        self.create_derived_impl(cx, type_ident, generics, field_tys, methods, is_packed)914    }915916    fn expand_enum_def(917        &self,918        cx: &ExtCtxt<'_>,919        enum_def: &'a EnumDef,920        type_ident: Ident,921        generics: &Generics,922        from_scratch: bool,923    ) -> Box<ast::Item> {924        let field_tys = Vec::from_iter(925            enum_def926                .variants927                .iter()928                .flat_map(|variant| variant.data.fields())929                .map(|field| &*field.ty),930        );931932        let methods = self933            .methods934            .iter()935            .map(|method_def| {936                let (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys) =937                    method_def.extract_arg_details(cx, self, type_ident, generics);938939                let body = if from_scratch || method_def.is_static() {940                    method_def.expand_static_enum_method_body(941                        cx,942                        self,943                        enum_def,944                        type_ident,945                        &nonselflike_args,946                    )947                } else {948                    method_def.expand_enum_method_body(949                        cx,950                        self,951                        enum_def,952                        type_ident,953                        selflike_args,954                        &nonselflike_args,955                    )956                };957958                method_def.create_method(959                    cx,960                    self,961                    type_ident,962                    generics,963                    explicit_self,964                    nonself_arg_tys,965                    body,966                )967            })968            .collect();969970        let is_packed = false; // enums are never packed971        self.create_derived_impl(cx, type_ident, generics, field_tys, methods, is_packed)972    }973}974975impl<'a> MethodDef<'a> {976    fn call_substructure_method(977        &self,978        cx: &ExtCtxt<'_>,979        trait_: &TraitDef<'_>,980        type_ident: Ident,981        nonselflike_args: &[Box<Expr>],982        fields: &SubstructureFields<'_>,983    ) -> BlockOrExpr {984        let span = trait_.span;985        let substructure = Substructure { type_ident, nonselflike_args, fields };986        let mut f = self.combine_substructure.borrow_mut();987        let f: &mut CombineSubstructureFunc<'_> = &mut *f;988        f(cx, span, &substructure)989    }990991    fn is_static(&self) -> bool {992        !self.explicit_self993    }994995    // The return value includes:996    // - explicit_self: The `&self` arg, if present.997    // - selflike_args: Expressions for `&self` (if present) and also any other998    //   args with the same type (e.g. the `other` arg in `PartialEq::eq`).999    // - nonselflike_args: Expressions for all the remaining args.1000    // - nonself_arg_tys: Additional information about all the args other than1001    //   `&self`.1002    fn extract_arg_details(1003        &self,1004        cx: &ExtCtxt<'_>,1005        trait_: &TraitDef<'_>,1006        type_ident: Ident,1007        generics: &Generics,1008    ) -> (Option<ast::ExplicitSelf>, ThinVec<Box<Expr>>, Vec<Box<Expr>>, Vec<(Ident, Box<ast::Ty>)>)1009    {1010        let mut selflike_args = ThinVec::new();1011        let mut nonselflike_args = Vec::new();1012        let mut nonself_arg_tys = Vec::new();1013        let span = trait_.span;10141015        let explicit_self = self.explicit_self.then(|| {1016            let (self_expr, explicit_self) = ty::get_explicit_self(cx, span);1017            selflike_args.push(self_expr);1018            explicit_self1019        });10201021        for (ty, name) in self.nonself_args.iter() {1022            let ast_ty = ty.to_ty(cx, span, type_ident, generics);1023            let ident = Ident::new(*name, span);1024            nonself_arg_tys.push((ident, ast_ty));10251026            let arg_expr = cx.expr_ident(span, ident);10271028            match ty {1029                // Selflike (`&Self`) arguments only occur in non-static methods.1030                Ref(box Self_, _) if !self.is_static() => selflike_args.push(arg_expr),1031                Self_ => cx.dcx().span_bug(span, "`Self` in non-return position"),1032                _ => nonselflike_args.push(arg_expr),1033            }1034        }10351036        (explicit_self, selflike_args, nonselflike_args, nonself_arg_tys)1037    }10381039    fn create_method(1040        &self,1041        cx: &ExtCtxt<'_>,1042        trait_: &TraitDef<'_>,1043        type_ident: Ident,1044        generics: &Generics,1045        explicit_self: Option<ast::ExplicitSelf>,1046        nonself_arg_tys: Vec<(Ident, Box<ast::Ty>)>,1047        body: BlockOrExpr,1048    ) -> Box<ast::AssocItem> {1049        let span = trait_.span;1050        // Create the generics that aren't for `Self`.1051        let fn_generics = self.generics.to_generics(cx, span, type_ident, generics);10521053        let args = {1054            let self_arg = explicit_self.map(|explicit_self| {1055                let ident = Ident::new(kw::SelfLower, span);1056                ast::Param::from_self(ast::AttrVec::default(), explicit_self, ident)1057            });1058            let nonself_args =1059                nonself_arg_tys.into_iter().map(|(name, ty)| cx.param(span, name, ty));1060            self_arg.into_iter().chain(nonself_args).collect()1061        };10621063        let ret_type = if let Ty::Unit = &self.ret_ty {1064            ast::FnRetTy::Default(span)1065        } else {1066            ast::FnRetTy::Ty(self.ret_ty.to_ty(cx, span, type_ident, generics))1067        };10681069        let method_ident = Ident::new(self.name, span);1070        let fn_decl = cx.fn_decl(args, ret_type);1071        let body_block = body.into_block(cx, span);10721073        let trait_lo_sp = span.shrink_to_lo();10741075        let sig = ast::FnSig { header: ast::FnHeader::default(), decl: fn_decl, span };1076        let defaultness = ast::Defaultness::Implicit;10771078        // Create the method.1079        Box::new(ast::AssocItem {1080            id: ast::DUMMY_NODE_ID,1081            attrs: self.attributes.clone(),1082            span,1083            vis: ast::Visibility {1084                span: trait_lo_sp,1085                kind: ast::VisibilityKind::Inherited,1086                tokens: None,1087            },1088            kind: ast::AssocItemKind::Fn(Box::new(ast::Fn {1089                defaultness,1090                sig,1091                ident: method_ident,1092                generics: fn_generics,1093                contract: None,1094                body: Some(body_block),1095                define_opaque: None,1096                eii_impls: ThinVec::new(),1097            })),1098            tokens: None,1099        })1100    }11011102    /// The normal case uses field access.1103    ///1104    /// ```1105    /// #[derive(PartialEq)]1106    /// # struct Dummy;1107    /// struct A { x: u8, y: u8 }1108    ///1109    /// // equivalent to:1110    /// impl PartialEq for A {1111    ///     fn eq(&self, other: &A) -> bool {1112    ///         self.x == other.x && self.y == other.y1113    ///     }1114    /// }1115    /// ```1116    ///1117    /// But if the struct is `repr(packed)`, we can't use something like1118    /// `&self.x` because that might cause an unaligned ref. So for any trait1119    /// method that takes a reference, we use a local block to force a copy.1120    /// This requires that the field impl `Copy`.1121    ///1122    /// ```rust,ignore (example)1123    /// # struct A { x: u8, y: u8 }1124    /// impl PartialEq for A {1125    ///     fn eq(&self, other: &A) -> bool {1126    ///         // Desugars to `{ self.x }.eq(&{ other.y }) && ...`1127    ///         { self.x } == { other.y } && { self.y } == { other.y }1128    ///     }1129    /// }1130    /// impl Hash for A {1131    ///     fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {1132    ///         ::core::hash::Hash::hash(&{ self.x }, state);1133    ///         ::core::hash::Hash::hash(&{ self.y }, state);1134    ///     }1135    /// }1136    /// ```1137    fn expand_struct_method_body<'b>(1138        &self,1139        cx: &ExtCtxt<'_>,1140        trait_: &TraitDef<'b>,1141        struct_def: &'b VariantData,1142        type_ident: Ident,1143        selflike_args: &[Box<Expr>],1144        nonselflike_args: &[Box<Expr>],1145        is_packed: bool,1146    ) -> BlockOrExpr {1147        assert!(selflike_args.len() == 1 || selflike_args.len() == 2);11481149        let selflike_fields =1150            trait_.create_struct_field_access_fields(cx, selflike_args, struct_def, is_packed);1151        self.call_substructure_method(1152            cx,1153            trait_,1154            type_ident,1155            nonselflike_args,1156            &Struct(struct_def, selflike_fields),1157        )1158    }11591160    fn expand_static_struct_method_body(1161        &self,1162        cx: &ExtCtxt<'_>,1163        trait_: &TraitDef<'a>,1164        struct_def: &'a VariantData,1165        type_ident: Ident,1166        nonselflike_args: &[Box<Expr>],1167    ) -> BlockOrExpr {1168        let summary = trait_.summarise_struct(cx, struct_def);11691170        self.call_substructure_method(1171            cx,1172            trait_,1173            type_ident,1174            nonselflike_args,1175            &StaticStruct(struct_def, summary),1176        )1177    }11781179    /// ```1180    /// #[derive(PartialEq)]1181    /// # struct Dummy;1182    /// enum A {1183    ///     A1,1184    ///     A2(i32)1185    /// }1186    /// ```1187    ///1188    /// is equivalent to:1189    ///1190    /// ```1191    /// #![feature(core_intrinsics)]1192    /// enum A {1193    ///     A1,1194    ///     A2(i32)1195    /// }1196    /// impl ::core::cmp::PartialEq for A {1197    ///     #[inline]1198    ///     fn eq(&self, other: &A) -> bool {1199    ///         let __self_discr = ::core::intrinsics::discriminant_value(self);1200    ///         let __arg1_discr = ::core::intrinsics::discriminant_value(other);1201    ///         __self_discr == __arg1_discr1202    ///             && match (self, other) {1203    ///                 (A::A2(__self_0), A::A2(__arg1_0)) => *__self_0 == *__arg1_0,1204    ///                 _ => true,1205    ///             }1206    ///     }1207    /// }1208    /// ```1209    ///1210    /// Creates a discriminant check combined with a match for a tuple of all1211    /// `selflike_args`, with an arm for each variant with fields, possibly an1212    /// arm for each fieldless variant (if `unify_fieldless_variants` is not1213    /// `Unify`), and possibly a default arm.1214    fn expand_enum_method_body<'b>(1215        &self,1216        cx: &ExtCtxt<'_>,1217        trait_: &TraitDef<'b>,1218        enum_def: &'b EnumDef,1219        type_ident: Ident,1220        mut selflike_args: ThinVec<Box<Expr>>,1221        nonselflike_args: &[Box<Expr>],1222    ) -> BlockOrExpr {1223        assert!(1224            !selflike_args.is_empty(),1225            "static methods must use `expand_static_enum_method_body`",1226        );12271228        let span = trait_.span;1229        let variants = &enum_def.variants;12301231        // Traits that unify fieldless variants always use the discriminant(s).1232        let unify_fieldless_variants =1233            self.fieldless_variants_strategy == FieldlessVariantsStrategy::Unify;12341235        // For zero-variant enum, this function body is unreachable. Generate1236        // `match *self {}`. This produces machine code identical to `unsafe {1237        // core::intrinsics::unreachable() }` while being safe and stable.1238        if variants.is_empty() {1239            selflike_args.truncate(1);1240            let match_arg = cx.expr_deref(span, selflike_args.pop().unwrap());1241            let match_arms = ThinVec::new();1242            let expr = cx.expr_match(span, match_arg, match_arms);1243            return BlockOrExpr(ThinVec::new(), Some(expr));1244        }12451246        let prefixes = iter::once("__self".to_string())1247            .chain(1248                selflike_args1249                    .iter()1250                    .enumerate()1251                    .skip(1)1252                    .map(|(arg_count, _selflike_arg)| format!("__arg{arg_count}")),1253            )1254            .collect::<Vec<String>>();12551256        // Build a series of let statements mapping each selflike_arg1257        // to its discriminant value.1258        //1259        // e.g. for `PartialEq::eq` builds two statements:1260        // ```1261        // let __self_discr = ::core::intrinsics::discriminant_value(self);1262        // let __arg1_discr = ::core::intrinsics::discriminant_value(other);1263        // ```1264        let get_discr_pieces = |cx: &ExtCtxt<'_>| {1265            let discr_idents: Vec<_> = prefixes1266                .iter()1267                .map(|name| Ident::from_str_and_span(&format!("{name}_discr"), span))1268                .collect();12691270            let mut discr_exprs: Vec<_> = discr_idents1271                .iter()1272                .map(|&ident| cx.expr_addr_of(span, cx.expr_ident(span, ident)))1273                .collect();12741275            let self_expr = discr_exprs.remove(0);1276            let other_selflike_exprs = discr_exprs;1277            let discr_field =1278                FieldInfo { span, name: None, self_expr, other_selflike_exprs, maybe_scalar: true };12791280            let discr_let_stmts: ThinVec<_> = iter::zip(&discr_idents, &selflike_args)1281                .map(|(&ident, selflike_arg)| {1282                    let variant_value = deriving::call_intrinsic(1283                        cx,1284                        span,1285                        sym::discriminant_value,1286                        thin_vec![selflike_arg.clone()],1287                    );1288                    cx.stmt_let(span, false, ident, variant_value)1289                })1290                .collect();12911292            (discr_field, discr_let_stmts)1293        };12941295        // There are some special cases involving fieldless enums where no1296        // match is necessary.1297        let all_fieldless = variants.iter().all(|v| v.data.fields().is_empty());1298        if all_fieldless {1299            if variants.len() > 1 {1300                match self.fieldless_variants_strategy {1301                    FieldlessVariantsStrategy::Unify => {1302                        // If the type is fieldless and the trait uses the discriminant and1303                        // there are multiple variants, we need just an operation on1304                        // the discriminant(s).1305                        let (discr_field, mut discr_let_stmts) = get_discr_pieces(cx);1306                        let mut discr_check = self.call_substructure_method(1307                            cx,1308                            trait_,1309                            type_ident,1310                            nonselflike_args,1311                            &EnumDiscr(discr_field, None),1312                        );1313                        discr_let_stmts.append(&mut discr_check.0);1314                        return BlockOrExpr(discr_let_stmts, discr_check.1);1315                    }1316                    FieldlessVariantsStrategy::SpecializeIfAllVariantsFieldless => {1317                        return self.call_substructure_method(1318                            cx,1319                            trait_,1320                            type_ident,1321                            nonselflike_args,1322                            &AllFieldlessEnum(enum_def),1323                        );1324                    }1325                    FieldlessVariantsStrategy::Default => (),1326                }1327            } else if let [variant] = variants.as_slice() {1328                // If there is a single variant, we don't need an operation on1329                // the discriminant(s). Just use the most degenerate result.1330                return self.call_substructure_method(1331                    cx,1332                    trait_,1333                    type_ident,1334                    nonselflike_args,1335                    &EnumMatching(variant, Vec::new()),1336                );1337            }1338        }13391340        // These arms are of the form:1341        // (Variant1, Variant1, ...) => Body11342        // (Variant2, Variant2, ...) => Body21343        // ...1344        // where each tuple has length = selflike_args.len()1345        let mut match_arms: ThinVec<ast::Arm> = variants1346            .iter()1347            .filter(|&v| !(unify_fieldless_variants && v.data.fields().is_empty()))1348            .map(|variant| {1349                // A single arm has form (&VariantK, &VariantK, ...) => BodyK1350                // (see "Final wrinkle" note below for why.)13511352                let fields = trait_.create_struct_pattern_fields(cx, &variant.data, &prefixes);13531354                let sp = variant.span.with_ctxt(trait_.span.ctxt());1355                let variant_path = cx.path(sp, vec![type_ident, variant.ident]);1356                let by_ref = ByRef::No; // because enums can't be repr(packed)1357                let mut subpats = trait_.create_struct_patterns(1358                    cx,1359                    variant_path,1360                    &variant.data,1361                    &prefixes,1362                    by_ref,1363                );13641365                // `(VariantK, VariantK, ...)` or just `VariantK`.1366                let single_pat = if subpats.len() == 1 {1367                    subpats.pop().unwrap()1368                } else {1369                    cx.pat_tuple(span, subpats)1370                };13711372                // For the BodyK, we need to delegate to our caller,1373                // passing it an EnumMatching to indicate which case1374                // we are in.1375                //1376                // Now, for some given VariantK, we have built up1377                // expressions for referencing every field of every1378                // Self arg, assuming all are instances of VariantK.1379                // Build up code associated with such a case.1380                let substructure = EnumMatching(variant, fields);1381                let arm_expr = self1382                    .call_substructure_method(1383                        cx,1384                        trait_,1385                        type_ident,1386                        nonselflike_args,1387                        &substructure,1388                    )1389                    .into_expr(cx, span);13901391                cx.arm(span, single_pat, arm_expr)1392            })1393            .collect();13941395        // Add a default arm to the match, if necessary.1396        let first_fieldless = variants.iter().find(|v| v.data.fields().is_empty());1397        let default = match first_fieldless {1398            Some(v) if unify_fieldless_variants => {1399                // We need a default case that handles all the fieldless1400                // variants. The index and actual variant aren't meaningful in1401                // this case, so just use dummy values.1402                Some(1403                    self.call_substructure_method(1404                        cx,1405                        trait_,1406                        type_ident,1407                        nonselflike_args,1408                        &EnumMatching(v, Vec::new()),1409                    )1410                    .into_expr(cx, span),1411                )1412            }1413            _ if variants.len() > 1 && selflike_args.len() > 1 => {1414                // Because we know that all the arguments will match if we reach1415                // the match expression we add the unreachable intrinsics as the1416                // result of the default which should help llvm in optimizing it.1417                Some(deriving::call_unreachable(cx, span))1418            }1419            _ => None,1420        };1421        if let Some(arm) = default {1422            match_arms.push(cx.arm(span, cx.pat_wild(span), arm));1423        }14241425        // Create a match expression with one arm per discriminant plus1426        // possibly a default arm, e.g.:1427        //      match (self, other) {1428        //          (Variant1, Variant1, ...) => Body11429        //          (Variant2, Variant2, ...) => Body2,1430        //          ...1431        //          _ => ::core::intrinsics::unreachable(),1432        //      }1433        let get_match_expr = |mut selflike_args: ThinVec<Box<Expr>>| {1434            let match_arg = if selflike_args.len() == 1 {1435                selflike_args.pop().unwrap()1436            } else {1437                cx.expr(span, ast::ExprKind::Tup(selflike_args))1438            };1439            cx.expr_match(span, match_arg, match_arms)1440        };14411442        // If the trait uses the discriminant and there are multiple variants, we need1443        // to add a discriminant check operation before the match. Otherwise, the match1444        // is enough.1445        if unify_fieldless_variants && variants.len() > 1 {1446            let (discr_field, mut discr_let_stmts) = get_discr_pieces(cx);14471448            // Combine a discriminant check with the match.1449            let mut discr_check_plus_match = self.call_substructure_method(1450                cx,1451                trait_,1452                type_ident,1453                nonselflike_args,1454                &EnumDiscr(discr_field, Some(get_match_expr(selflike_args))),1455            );1456            discr_let_stmts.append(&mut discr_check_plus_match.0);1457            BlockOrExpr(discr_let_stmts, discr_check_plus_match.1)1458        } else {1459            BlockOrExpr(ThinVec::new(), Some(get_match_expr(selflike_args)))1460        }1461    }14621463    fn expand_static_enum_method_body(1464        &self,1465        cx: &ExtCtxt<'_>,1466        trait_: &TraitDef<'_>,1467        enum_def: &EnumDef,1468        type_ident: Ident,1469        nonselflike_args: &[Box<Expr>],1470    ) -> BlockOrExpr {1471        self.call_substructure_method(1472            cx,1473            trait_,1474            type_ident,1475            nonselflike_args,1476            &StaticEnum(enum_def),1477        )1478    }1479}14801481// general helper methods.1482impl<'a> TraitDef<'a> {1483    fn summarise_struct(&self, cx: &ExtCtxt<'_>, struct_def: &'a VariantData) -> StaticFields<'a> {1484        let mut named_idents = Vec::new();1485        let mut just_spans = Vec::new();1486        for field in struct_def.fields() {1487            let sp = field.span.with_ctxt(self.span.ctxt());1488            match field.ident {1489                Some(ident) => named_idents.push((ident, sp, field.default.as_ref())),1490                _ => just_spans.push(sp),1491            }1492        }14931494        let is_tuple = match struct_def {1495            ast::VariantData::Tuple(..) => IsTuple::Yes,1496            _ => IsTuple::No,1497        };1498        match (just_spans.is_empty(), named_idents.is_empty()) {1499            (false, false) => cx1500                .dcx()1501                .span_bug(self.span, "a struct with named and unnamed fields in generic `derive`"),1502            // named fields1503            (_, false) => Named(named_idents),1504            // unnamed fields1505            (false, _) => Unnamed(just_spans, is_tuple),1506            // empty1507            _ => Named(Vec::new()),1508        }1509    }15101511    fn create_struct_patterns(1512        &self,1513        cx: &ExtCtxt<'_>,1514        struct_path: ast::Path,1515        struct_def: &'a VariantData,1516        prefixes: &[String],1517        by_ref: ByRef,1518    ) -> ThinVec<ast::Pat> {1519        prefixes1520            .iter()1521            .map(|prefix| {1522                let pieces_iter =1523                    struct_def.fields().iter().enumerate().map(|(i, struct_field)| {1524                        let sp = struct_field.span.with_ctxt(self.span.ctxt());1525                        let ident = self.mk_pattern_ident(prefix, i);1526                        let path = ident.with_span_pos(sp);1527                        (1528                            sp,1529                            struct_field.ident,1530                            cx.pat(1531                                path.span,1532                                PatKind::Ident(BindingMode(by_ref, Mutability::Not), path, None),1533                            ),1534                        )1535                    });15361537                let struct_path = struct_path.clone();1538                match *struct_def {1539                    VariantData::Struct { .. } => {1540                        let field_pats = pieces_iter1541                            .map(|(sp, ident, pat)| {1542                                if ident.is_none() {1543                                    cx.dcx().span_bug(1544                                        sp,1545                                        "a braced struct with unnamed fields in `derive`",1546                                    );1547                                }1548                                ast::PatField {1549                                    ident: ident.unwrap(),1550                                    is_shorthand: false,1551                                    attrs: ast::AttrVec::new(),1552                                    id: ast::DUMMY_NODE_ID,1553                                    span: pat.span.with_ctxt(self.span.ctxt()),1554                                    pat: Box::new(pat),1555                                    is_placeholder: false,1556                                }1557                            })1558                            .collect();1559                        cx.pat_struct(self.span, struct_path, field_pats)1560                    }1561                    VariantData::Tuple(..) => {1562                        let subpats = pieces_iter.map(|(_, _, subpat)| subpat).collect();1563                        cx.pat_tuple_struct(self.span, struct_path, subpats)1564                    }1565                    VariantData::Unit(..) => cx.pat_path(self.span, struct_path),1566                }1567            })1568            .collect()1569    }15701571    fn create_fields<F>(&self, struct_def: &'a VariantData, mk_exprs: F) -> Vec<FieldInfo>1572    where1573        F: Fn(usize, &ast::FieldDef, Span) -> Vec<Box<ast::Expr>>,1574    {1575        struct_def1576            .fields()1577            .iter()1578            .enumerate()1579            .map(|(i, struct_field)| {1580                // For this field, get an expr for each selflike_arg. E.g. for1581                // `PartialEq::eq`, one for each of `&self` and `other`.1582                let sp = struct_field.span.with_ctxt(self.span.ctxt());1583                let mut exprs: Vec<_> = mk_exprs(i, struct_field, sp);1584                let self_expr = exprs.remove(0);1585                let other_selflike_exprs = exprs;1586                FieldInfo {1587                    span: sp.with_ctxt(self.span.ctxt()),1588                    name: struct_field.ident,1589                    self_expr,1590                    other_selflike_exprs,1591                    maybe_scalar: struct_field.ty.peel_refs().kind.maybe_scalar(),1592                }1593            })1594            .collect()1595    }15961597    fn mk_pattern_ident(&self, prefix: &str, i: usize) -> Ident {1598        Ident::from_str_and_span(&format!("{prefix}_{i}"), self.span)1599    }16001601    fn create_struct_pattern_fields(1602        &self,1603        cx: &ExtCtxt<'_>,1604        struct_def: &'a VariantData,1605        prefixes: &[String],1606    ) -> Vec<FieldInfo> {1607        self.create_fields(struct_def, |i, _struct_field, sp| {1608            prefixes1609                .iter()1610                .map(|prefix| {1611                    let ident = self.mk_pattern_ident(prefix, i);1612                    cx.expr_path(cx.path_ident(sp, ident))1613                })1614                .collect()1615        })1616    }16171618    fn create_struct_field_access_fields(1619        &self,1620        cx: &ExtCtxt<'_>,1621        selflike_args: &[Box<Expr>],1622        struct_def: &'a VariantData,1623        is_packed: bool,1624    ) -> Vec<FieldInfo> {1625        self.create_fields(struct_def, |i, struct_field, sp| {1626            selflike_args1627                .iter()1628                .map(|selflike_arg| {1629                    // Note: we must use `struct_field.span` rather than `sp` in the1630                    // `unwrap_or_else` case otherwise the hygiene is wrong and we get1631                    // "field `0` of struct `Point` is private" errors on tuple1632                    // structs.1633                    let mut field_expr = cx.expr(1634                        sp,1635                        ast::ExprKind::Field(1636                            selflike_arg.clone(),1637                            struct_field.ident.unwrap_or_else(|| {1638                                Ident::from_str_and_span(&i.to_string(), struct_field.span)1639                            }),1640                        ),1641                    );1642                    if is_packed {1643                        // Fields in packed structs are wrapped in a block, e.g. `&{self.0}`,1644                        // causing a copy instead of a (potentially misaligned) reference.1645                        field_expr = cx.expr_block(1646                            cx.block(struct_field.span, thin_vec![cx.stmt_expr(field_expr)]),1647                        );1648                    }1649                    cx.expr_addr_of(sp, field_expr)1650                })1651                .collect()1652        })1653    }1654}16551656/// The function passed to `cs_fold` is called repeatedly with a value of this1657/// type. It describes one part of the code generation. The result is always an1658/// expression.1659pub(crate) enum CsFold<'a> {1660    /// The basic case: a field expression for one or more selflike args. E.g.1661    /// for `PartialEq::eq` this is something like `self.x == other.x`.1662    Single(&'a FieldInfo),16631664    /// The combination of two field expressions. E.g. for `PartialEq::eq` this1665    /// is something like `<field1 equality> && <field2 equality>`.1666    Combine(Span, Box<Expr>, Box<Expr>),16671668    // The fallback case for a struct or enum variant with no fields.1669    Fieldless,1670}16711672/// Folds over fields, combining the expressions for each field in a sequence.1673/// Statics may not be folded over.1674pub(crate) fn cs_fold<F>(1675    use_foldl: bool,1676    cx: &ExtCtxt<'_>,1677    trait_span: Span,1678    substructure: &Substructure<'_>,1679    mut f: F,1680) -> Box<Expr>1681where1682    F: FnMut(&ExtCtxt<'_>, CsFold<'_>) -> Box<Expr>,1683{1684    match substructure.fields {1685        EnumMatching(.., all_fields) | Struct(_, all_fields) => {1686            if all_fields.is_empty() {1687                return f(cx, CsFold::Fieldless);1688            }16891690            let (base_field, rest) = if use_foldl {1691                all_fields.split_first().unwrap()1692            } else {1693                all_fields.split_last().unwrap()1694            };16951696            let base_expr = f(cx, CsFold::Single(base_field));16971698            let op = |old, field: &FieldInfo| {1699                let new = f(cx, CsFold::Single(field));1700                f(cx, CsFold::Combine(field.span, old, new))1701            };17021703            if use_foldl {1704                rest.iter().fold(base_expr, op)1705            } else {1706                rest.iter().rfold(base_expr, op)1707            }1708        }1709        EnumDiscr(discr_field, match_expr) => {1710            let discr_check_expr = f(cx, CsFold::Single(discr_field));1711            if let Some(match_expr) = match_expr {1712                if use_foldl {1713                    f(cx, CsFold::Combine(trait_span, discr_check_expr, match_expr.clone()))1714                } else {1715                    f(cx, CsFold::Combine(trait_span, match_expr.clone(), discr_check_expr))1716                }1717            } else {1718                discr_check_expr1719            }1720        }1721        StaticEnum(..) | StaticStruct(..) => {1722            cx.dcx().span_bug(trait_span, "static function in `derive`")1723        }1724        AllFieldlessEnum(..) => cx.dcx().span_bug(trait_span, "fieldless enum in `derive`"),1725    }1726}