compiler/rustc_builtin_macros/src/deriving/clone.rs

   1 use crate::deriving::generic::ty::*;
   2 use crate::deriving::generic::*;
   3 use crate::deriving::path_std;
   4 use rustc_ast::{self as ast, Generics, ItemKind, MetaItem, VariantData};
   5 use rustc_data_structures::fx::FxHashSet;
   6 use rustc_expand::base::{Annotatable, ExtCtxt};
   7 use rustc_span::symbol::{kw, sym, Ident};
   8 use rustc_span::Span;
   9 use thin_vec::thin_vec;
  10
  11 pub fn expand_deriving_clone(
  12     cx: &mut ExtCtxt<'_>,
  13     span: Span,
  14     mitem: &MetaItem,
  15     item: &Annotatable,
  16     push: &mut dyn FnMut(Annotatable),
  17     is_const: bool,
  18 ) {
  19     // The simple form is `fn clone(&self) -> Self { *self }`, possibly with
  20     // some additional `AssertParamIsClone` assertions.
  21     //
  22     // We can use the simple form if either of the following are true.
  23     // - The type derives Copy and there are no generic parameters. (If we
  24     //   used the simple form with generics, we'd have to bound the generics
  25     //   with Clone + Copy, and then there'd be no Clone impl at all if the
  26     //   user fills in something that is Clone but not Copy. After
  27     //   specialization we can remove this no-generics limitation.)
  28     // - The item is a union. (Unions with generic parameters still can derive
  29     //   Clone because they require Copy for deriving, Clone alone is not
  30     //   enough. Whether Clone is implemented for fields is irrelevant so we
  31     //   don't assert it.)
  32     let bounds;
  33     let substructure;
  34     let is_simple;
  35     match item {
  36         Annotatable::Item(annitem) => match &annitem.kind {
  37             ItemKind::Struct(_, Generics { params, .. })
  38             | ItemKind::Enum(_, Generics { params, .. }) => {
  39                 let container_id = cx.current_expansion.id.expn_data().parent.expect_local();
  40                 let has_derive_copy = cx.resolver.has_derive_copy(container_id);
  41                 if has_derive_copy
  42                     && !params
  43                         .iter()
  44                         .any(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
  45                 {
  46                     bounds = vec![];
  47                     is_simple = true;
  48                     substructure = combine_substructure(Box::new(|c, s, sub| {
  49                         cs_clone_simple("Clone", c, s, sub, false)
  50                     }));
  51                 } else {
  52                     bounds = vec![];
  53                     is_simple = false;
  54                     substructure =
  55                         combine_substructure(Box::new(|c, s, sub| cs_clone("Clone", c, s, sub)));
  56                 }
  57             }
  58             ItemKind::Union(..) => {
  59                 bounds = vec![Path(path_std!(marker::Copy))];
  60                 is_simple = true;
  61                 substructure = combine_substructure(Box::new(|c, s, sub| {
  62                     cs_clone_simple("Clone", c, s, sub, true)
  63                 }));
  64             }
  65             _ => cx.span_bug(span, "`#[derive(Clone)]` on wrong item kind"),
  66         },
  67
  68         _ => cx.span_bug(span, "`#[derive(Clone)]` on trait item or impl item"),
  69     }
  70
  71     let attrs = thin_vec![cx.attr_word(sym::inline, span)];
  72     let trait_def = TraitDef {
  73         span,
  74         path: path_std!(clone::Clone),
  75         skip_path_as_bound: false,
  76         additional_bounds: bounds,
  77         supports_unions: true,
  78         methods: vec![MethodDef {
  79             name: sym::clone,
  80             generics: Bounds::empty(),
  81             explicit_self: true,
  82             nonself_args: Vec::new(),
  83             ret_ty: Self_,
  84             attributes: attrs,
  85             fieldless_variants_strategy: FieldlessVariantsStrategy::Default,
  86             combine_substructure: substructure,
  87         }],
  88         associated_types: Vec::new(),
  89         is_const,
  90     };
  91
  92     trait_def.expand_ext(cx, mitem, item, push, is_simple)
  93 }
  94
  95 fn cs_clone_simple(
  96     name: &str,
  97     cx: &mut ExtCtxt<'_>,
  98     trait_span: Span,
  99     substr: &Substructure<'_>,
 100     is_union: bool,
 101 ) -> BlockOrExpr {
 102     let mut stmts = Vec::new();
 103     let mut seen_type_names = FxHashSet::default();
 104     let mut process_variant = |variant: &VariantData| {
 105         for field in variant.fields() {
 106             // This basic redundancy checking only prevents duplication of
 107             // assertions like `AssertParamIsClone<Foo>` where the type is a
 108             // simple name. That's enough to get a lot of cases, though.
 109             if let Some(name) = field.ty.kind.is_simple_path() && !seen_type_names.insert(name) {
 110                 // Already produced an assertion for this type.
 111             } else {
 112                 // let _: AssertParamIsClone<FieldTy>;
 113                 super::assert_ty_bounds(
 114                     cx,
 115                     &mut stmts,
 116                     field.ty.clone(),
 117                     field.span,
 118                     &[sym::clone, sym::AssertParamIsClone],
 119                 );
 120             }
 121         }
 122     };
 123
 124     if is_union {
 125         // Just a single assertion for unions, that the union impls `Copy`.
 126         // let _: AssertParamIsCopy<Self>;
 127         let self_ty = cx.ty_path(cx.path_ident(trait_span, Ident::with_dummy_span(kw::SelfUpper)));
 128         super::assert_ty_bounds(
 129             cx,
 130             &mut stmts,
 131             self_ty,
 132             trait_span,
 133             &[sym::clone, sym::AssertParamIsCopy],
 134         );
 135     } else {
 136         match *substr.fields {
 137             StaticStruct(vdata, ..) => {
 138                 process_variant(vdata);
 139             }
 140             StaticEnum(enum_def, ..) => {
 141                 for variant in &enum_def.variants {
 142                     process_variant(&variant.data);
 143                 }
 144             }
 145             _ => cx.span_bug(
 146                 trait_span,
 147                 &format!("unexpected substructure in simple `derive({})`", name),
 148             ),
 149         }
 150     }
 151     BlockOrExpr::new_mixed(stmts, Some(cx.expr_deref(trait_span, cx.expr_self(trait_span))))
 152 }
 153
 154 fn cs_clone(
 155     name: &str,
 156     cx: &mut ExtCtxt<'_>,
 157     trait_span: Span,
 158     substr: &Substructure<'_>,
 159 ) -> BlockOrExpr {
 160     let ctor_path;
 161     let all_fields;
 162     let fn_path = cx.std_path(&[sym::clone, sym::Clone, sym::clone]);
 163     let subcall = |cx: &mut ExtCtxt<'_>, field: &FieldInfo| {
 164         let args = vec![field.self_expr.clone()];
 165         cx.expr_call_global(field.span, fn_path.clone(), args)
 166     };
 167
 168     let vdata;
 169     match substr.fields {
 170         Struct(vdata_, af) => {
 171             ctor_path = cx.path(trait_span, vec![substr.type_ident]);
 172             all_fields = af;
 173             vdata = *vdata_;
 174         }
 175         EnumMatching(.., variant, af) => {
 176             ctor_path = cx.path(trait_span, vec![substr.type_ident, variant.ident]);
 177             all_fields = af;
 178             vdata = &variant.data;
 179         }
 180         EnumTag(..) | AllFieldlessEnum(..) => {
 181             cx.span_bug(trait_span, &format!("enum tags in `derive({})`", name,))
 182         }
 183         StaticEnum(..) | StaticStruct(..) => {
 184             cx.span_bug(trait_span, &format!("associated function in `derive({})`", name))
 185         }
 186     }
 187
 188     let expr = match *vdata {
 189         VariantData::Struct(..) => {
 190             let fields = all_fields
 191                 .iter()
 192                 .map(|field| {
 193                     let Some(ident) = field.name else {
 194                         cx.span_bug(
 195                             trait_span,
 196                             &format!("unnamed field in normal struct in `derive({})`", name,),
 197                         );
 198                     };
 199                     let call = subcall(cx, field);
 200                     cx.field_imm(field.span, ident, call)
 201                 })
 202                 .collect::<Vec<_>>();
 203
 204             cx.expr_struct(trait_span, ctor_path, fields)
 205         }
 206         VariantData::Tuple(..) => {
 207             let subcalls = all_fields.iter().map(|f| subcall(cx, f)).collect();
 208             let path = cx.expr_path(ctor_path);
 209             cx.expr_call(trait_span, path, subcalls)
 210         }
 211         VariantData::Unit(..) => cx.expr_path(ctor_path),
 212     };
 213     BlockOrExpr::new_expr(expr)
 214 }