compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs

   1 use crate::deriving::generic::ty::*;
   2 use crate::deriving::generic::*;
   3 use crate::deriving::path_std;
   4
   5 use rustc_ast::{self as ast, MetaItem};
   6 use rustc_data_structures::fx::FxHashSet;
   7 use rustc_expand::base::{Annotatable, ExtCtxt};
   8 use rustc_span::symbol::{sym, Ident};
   9 use rustc_span::Span;
  10 use thin_vec::thin_vec;
  11
  12 pub fn expand_deriving_eq(
  13     cx: &mut ExtCtxt<'_>,
  14     span: Span,
  15     mitem: &MetaItem,
  16     item: &Annotatable,
  17     push: &mut dyn FnMut(Annotatable),
  18 ) {
  19     let span = cx.with_def_site_ctxt(span);
  20     let inline = cx.meta_word(span, sym::inline);
  21     let hidden = rustc_ast::attr::mk_nested_word_item(Ident::new(sym::hidden, span));
  22     let doc = rustc_ast::attr::mk_list_item(Ident::new(sym::doc, span), vec![hidden]);
  23     let no_coverage = cx.meta_word(span, sym::no_coverage);
  24     let attrs = thin_vec![cx.attribute(inline), cx.attribute(doc), cx.attribute(no_coverage)];
  25     let trait_def = TraitDef {
  26         span,
  27         path: path_std!(cmp::Eq),
  28         skip_path_as_bound: false,
  29         additional_bounds: Vec::new(),
  30         generics: Bounds::empty(),
  31         supports_unions: true,
  32         methods: vec![MethodDef {
  33             name: sym::assert_receiver_is_total_eq,
  34             generics: Bounds::empty(),
  35             explicit_self: true,
  36             nonself_args: vec![],
  37             ret_ty: Unit,
  38             attributes: attrs,
  39             unify_fieldless_variants: true,
  40             combine_substructure: combine_substructure(Box::new(|a, b, c| {
  41                 cs_total_eq_assert(a, b, c)
  42             })),
  43         }],
  44         associated_types: Vec::new(),
  45     };
  46
  47     super::inject_impl_of_structural_trait(cx, span, item, path_std!(marker::StructuralEq), push);
  48
  49     trait_def.expand_ext(cx, mitem, item, push, true)
  50 }
  51
  52 fn cs_total_eq_assert(
  53     cx: &mut ExtCtxt<'_>,
  54     trait_span: Span,
  55     substr: &Substructure<'_>,
  56 ) -> BlockOrExpr {
  57     let mut stmts = Vec::new();
  58     let mut seen_type_names = FxHashSet::default();
  59     let mut process_variant = |variant: &ast::VariantData| {
  60         for field in variant.fields() {
  61             // This basic redundancy checking only prevents duplication of
  62             // assertions like `AssertParamIsEq<Foo>` where the type is a
  63             // simple name. That's enough to get a lot of cases, though.
  64             if let Some(name) = field.ty.kind.is_simple_path() && !seen_type_names.insert(name) {
  65                 // Already produced an assertion for this type.
  66             } else {
  67                 // let _: AssertParamIsEq<FieldTy>;
  68                 super::assert_ty_bounds(
  69                     cx,
  70                     &mut stmts,
  71                     field.ty.clone(),
  72                     field.span,
  73                     &[sym::cmp, sym::AssertParamIsEq],
  74                 );
  75             }
  76         }
  77     };
  78
  79     match *substr.fields {
  80         StaticStruct(vdata, ..) => {
  81             process_variant(vdata);
  82         }
  83         StaticEnum(enum_def, ..) => {
  84             for variant in &enum_def.variants {
  85                 process_variant(&variant.data);
  86             }
  87         }
  88         _ => cx.span_bug(trait_span, "unexpected substructure in `derive(Eq)`"),
  89     }
  90     BlockOrExpr::new_stmts(stmts)
  91 }