Implement #[skip] for builtin derives

clubby789 · clubby789 · commit 71d0aa0e3ae5 · 2024-02-13T20:56:21.000Z
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/eq.rs
@@ -38,9 +38,7 @@ pub fn expand_deriving_eq(
                 cx.attr_nested_word(sym::coverage, sym::off, span)
             ],
             fieldless_variants_strategy: FieldlessVariantsStrategy::Unify,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| {
-                cs_total_eq_assert(a, b, c)
-            })),
+            combine_substructure: combine_substructure(Box::new(cs_total_eq_assert)),
         }],
         associated_types: Vec::new(),
         is_const,
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/ord.rs
@@ -30,7 +30,7 @@ pub fn expand_deriving_ord(
             ret_ty: Path(path_std!(cmp::Ordering)),
             attributes: thin_vec![cx.attr_word(sym::inline, span)],
             fieldless_variants_strategy: FieldlessVariantsStrategy::Unify,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| cs_cmp(a, b, c))),
+            combine_substructure: combine_substructure(Box::new(cs_cmp)),
         }],
         associated_types: Vec::new(),
         is_const,
@@ -58,6 +58,7 @@ pub fn cs_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> Bl
         cx,
         span,
         substr,
+        sym::Ord,
         |cx, fold| match fold {
             CsFold::Single(field) => {
                 let [other_expr] = &field.other_selflike_exprs[..] else {
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_eq.rs
@@ -23,6 +23,7 @@ pub fn expand_deriving_partial_eq(
             cx,
             span,
             substr,
+            sym::PartialEq,
             |cx, fold| match fold {
                 CsFold::Single(field) => {
                     let [other_expr] = &field.other_selflike_exprs[..] else {
@@ -98,7 +99,7 @@ pub fn expand_deriving_partial_eq(
         ret_ty: Path(path_local!(bool)),
         attributes: thin_vec![cx.attr_word(sym::inline, span)],
         fieldless_variants_strategy: FieldlessVariantsStrategy::Unify,
-        combine_substructure: combine_substructure(Box::new(|a, b, c| cs_eq(a, b, c))),
+        combine_substructure: combine_substructure(Box::new(cs_eq)),
     }];
 
     let trait_def = TraitDef {
diff --git a/compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs b/compiler/rustc_builtin_macros/src/deriving/cmp/partial_ord.rs
@@ -92,6 +92,7 @@ fn cs_partial_cmp(
         cx,
         span,
         substr,
+        sym::PartialOrd,
         |cx, fold| match fold {
             CsFold::Single(field) => {
                 let [other_expr] = &field.other_selflike_exprs[..] else {
diff --git a/compiler/rustc_builtin_macros/src/deriving/debug.rs b/compiler/rustc_builtin_macros/src/deriving/debug.rs
@@ -36,9 +36,7 @@ pub fn expand_deriving_debug(
             attributes: thin_vec![cx.attr_word(sym::inline, span)],
             fieldless_variants_strategy:
                 FieldlessVariantsStrategy::SpecializeIfAllVariantsFieldless,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| {
-                show_substructure(a, b, c)
-            })),
+            combine_substructure: combine_substructure(Box::new(show_substructure)),
         }],
         associated_types: Vec::new(),
         is_const,
@@ -91,6 +89,10 @@ fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>
             cx.expr_addr_of(field.span, field.self_expr.clone())
         }
     }
+    let fields = fields
+        .iter()
+        .filter(|fi| !fi.skipped_derives.is_skipped(sym::Debug))
+        .collect::<ThinVec<_>>();
 
     if fields.is_empty() {
         // Special case for no fields.
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -188,6 +188,7 @@ use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_session::lint::builtin::BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{Span, DUMMY_SP};
+use smallvec::SmallVec;
 use std::cell::RefCell;
 use std::iter;
 use std::ops::Not;
@@ -263,6 +264,7 @@ pub enum FieldlessVariantsStrategy {
 }
 
 /// All the data about the data structure/method being derived upon.
+#[derive(Debug)]
 pub struct Substructure<'a> {
     /// ident of self
     pub type_ident: Ident,
@@ -273,6 +275,7 @@ pub struct Substructure<'a> {
 }
 
 /// Summary of the relevant parts of a struct/enum field.
+#[derive(Debug)]
 pub struct FieldInfo {
     pub span: Span,
     /// None for tuple structs/normal enum variants, Some for normal
@@ -284,9 +287,41 @@ pub struct FieldInfo {
     /// The expressions corresponding to references to this field in
     /// the other selflike arguments.
     pub other_selflike_exprs: Vec<P<Expr>>,
+    /// The derives for which this field should be ignored
+    pub skipped_derives: SkippedDerives,
+}
+
+/// Derives for which this field should be ignored
+#[derive(Debug)]
+pub enum SkippedDerives {
+    /// No `#[skip]`
+    None,
+    /// `#[skip(Trait, Names)]`
+    List(SmallVec<[Symbol; 1]>),
+    /// `#[skip]` with no arguments
+    All,
+}
+
+impl SkippedDerives {
+    pub fn add(&mut self, derive: Symbol) {
+        match self {
+            Self::None => *self = Self::List(SmallVec::from([derive])),
+            Self::List(idents) => idents.push(derive),
+            Self::All => (),
+        }
+    }
+
+    pub fn is_skipped(&self, derive: Symbol) -> bool {
+        match self {
+            Self::None => false,
+            Self::List(idents) => idents.contains(&derive),
+            Self::All => true,
+        }
+    }
 }
 
 /// Fields for a static method
+#[derive(Debug)]
 pub enum StaticFields {
     /// Tuple and unit structs/enum variants like this.
     Unnamed(Vec<Span>, bool /*is tuple*/),
@@ -295,6 +330,7 @@ pub enum StaticFields {
 }
 
 /// A summary of the possible sets of fields.
+#[derive(Debug)]
 pub enum SubstructureFields<'a> {
     /// A non-static method where `Self` is a struct.
     Struct(&'a ast::VariantData, Vec<FieldInfo>),
@@ -1213,7 +1249,13 @@ impl<'a> MethodDef<'a> {
 
             let self_expr = tag_exprs.remove(0);
             let other_selflike_exprs = tag_exprs;
-            let tag_field = FieldInfo { span, name: None, self_expr, other_selflike_exprs };
+            let tag_field = FieldInfo {
+                span,
+                name: None,
+                self_expr,
+                other_selflike_exprs,
+                skipped_derives: SkippedDerives::None,
+            };
 
             let tag_let_stmts: ThinVec<_> = iter::zip(&tag_idents, &selflike_args)
                 .map(|(&ident, selflike_arg)| {
@@ -1517,7 +1559,12 @@ impl<'a> TraitDef<'a> {
             .collect()
     }
 
-    fn create_fields<F>(&self, struct_def: &'a VariantData, mk_exprs: F) -> Vec<FieldInfo>
+    fn create_fields<F>(
+        &self,
+        cx: &ExtCtxt<'_>,
+        struct_def: &'a VariantData,
+        mk_exprs: F,
+    ) -> Vec<FieldInfo>
     where
         F: Fn(usize, &ast::FieldDef, Span) -> Vec<P<ast::Expr>>,
     {
@@ -1532,11 +1579,54 @@ impl<'a> TraitDef<'a> {
                 let mut exprs: Vec<_> = mk_exprs(i, struct_field, sp);
                 let self_expr = exprs.remove(0);
                 let other_selflike_exprs = exprs;
+                let mut skipped_derives = SkippedDerives::None;
+                let skip_enabled = cx.ecfg.features.derive_skip
+                    || struct_field.span.allows_unstable(sym::derive_skip);
+                for skip_attr in attr::filter_by_name(&struct_field.attrs, sym::skip) {
+                    if !skip_enabled {
+                        rustc_session::parse::feature_err(
+                            &cx.sess,
+                            sym::derive_skip,
+                            skip_attr.span,
+                            "the `#[skip]` attribute is experimental",
+                        )
+                        .emit();
+                    }
+                    let Some(skip_attr) = ast::Attribute::meta_kind(skip_attr) else {
+                        unreachable!()
+                    };
+
+                    // FIXME: better errors
+                    match skip_attr {
+                        ast::MetaItemKind::Word => {
+                            skipped_derives = SkippedDerives::All;
+                            break;
+                        }
+                        ast::MetaItemKind::List(items) => {
+                            for item in items {
+                                let ast::NestedMetaItem::MetaItem(ast::MetaItem {
+                                    path,
+                                    kind: ast::MetaItemKind::Word,
+                                    ..
+                                }) = item
+                                else {
+                                    cx.dcx().span_err(item.span(), "incorrect skip argument");
+                                    continue;
+                                };
+                                skipped_derives.add(path.segments[0].ident.name);
+                            }
+                        }
+                        ast::MetaItemKind::NameValue(lit) => {
+                            cx.dcx().span_err(lit.span, "invalid skip attribute");
+                        }
+                    }
+                }
                 FieldInfo {
                     span: sp.with_ctxt(self.span.ctxt()),
                     name: struct_field.ident,
                     self_expr,
                     other_selflike_exprs,
+                    skipped_derives,
                 }
             })
             .collect()
@@ -1552,7 +1642,7 @@ impl<'a> TraitDef<'a> {
         struct_def: &'a VariantData,
         prefixes: &[String],
     ) -> Vec<FieldInfo> {
-        self.create_fields(struct_def, |i, _struct_field, sp| {
+        self.create_fields(cx, struct_def, |i, _struct_field, sp| {
             prefixes
                 .iter()
                 .map(|prefix| {
@@ -1570,7 +1660,7 @@ impl<'a> TraitDef<'a> {
         struct_def: &'a VariantData,
         is_packed: bool,
     ) -> Vec<FieldInfo> {
-        self.create_fields(struct_def, |i, struct_field, sp| {
+        self.create_fields(cx, struct_def, |i, struct_field, sp| {
             selflike_args
                 .iter()
                 .map(|selflike_arg| {
@@ -1665,13 +1755,19 @@ pub fn cs_fold<F>(
     cx: &mut ExtCtxt<'_>,
     trait_span: Span,
     substructure: &Substructure<'_>,
+    trait_name: Symbol,
     mut f: F,
 ) -> P<Expr>
 where
     F: FnMut(&mut ExtCtxt<'_>, CsFold<'_>) -> P<Expr>,
 {
     match substructure.fields {
         EnumMatching(.., all_fields) | Struct(_, all_fields) => {
+            let all_fields = all_fields
+                .iter()
+                .filter(|fi| !fi.skipped_derives.is_skipped(trait_name))
+                .collect::<Vec<&FieldInfo>>();
+
             if all_fields.is_empty() {
                 return f(cx, CsFold::Fieldless);
             }
@@ -1684,7 +1780,7 @@ where
 
             let base_expr = f(cx, CsFold::Single(base_field));
 
-            let op = |old, field: &FieldInfo| {
+            let op = |old, field: &&FieldInfo| {
                 let new = f(cx, CsFold::Single(field));
                 f(cx, CsFold::Combine(field.span, old, new))
             };
diff --git a/compiler/rustc_builtin_macros/src/deriving/hash.rs b/compiler/rustc_builtin_macros/src/deriving/hash.rs
@@ -35,9 +35,7 @@ pub fn expand_deriving_hash(
             ret_ty: Unit,
             attributes: thin_vec![cx.attr_word(sym::inline, span)],
             fieldless_variants_strategy: FieldlessVariantsStrategy::Unify,
-            combine_substructure: combine_substructure(Box::new(|a, b, c| {
-                hash_substructure(a, b, c)
-            })),
+            combine_substructure: combine_substructure(Box::new(hash_substructure)),
         }],
         associated_types: Vec::new(),
         is_const,
@@ -66,8 +64,11 @@ fn hash_substructure(
 
     let (stmts, match_expr) = match substr.fields {
         Struct(_, fields) | EnumMatching(.., fields) => {
-            let stmts =
-                fields.iter().map(|field| call_hash(field.span, field.self_expr.clone())).collect();
+            let stmts = fields
+                .iter()
+                .filter(|fi| !fi.skipped_derives.is_skipped(sym::Hash))
+                .map(|field| call_hash(field.span, field.self_expr.clone()))
+                .collect();
             (stmts, None)
         }
         EnumTag(tag_field, match_expr) => {
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -438,6 +438,8 @@ declare_features! (
     (unstable, deprecated_safe, "1.61.0", Some(94978)),
     /// Allows having using `suggestion` in the `#[deprecated]` attribute.
     (unstable, deprecated_suggestion, "1.61.0", Some(94785)),
+    /// Allows using the `#[skip]` attribute in derives
+    (unstable, derive_skip, "CURRENT_RUSTC_VERSION", Some(121050)),
     /// Allows using the `#[diagnostic]` attribute tool namespace
     (unstable, diagnostic_namespace, "1.73.0", Some(111996)),
     /// Controls errors in trait implementations.
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -669,6 +669,7 @@ symbols! {
         derive,
         derive_const,
         derive_default_enum,
+        derive_skip,
         destruct,
         destructuring_assignment,
         diagnostic,
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
@@ -267,7 +267,7 @@ pub trait PartialEq<Rhs: ?Sized = Self> {
 
 /// Derive macro generating an impl of the trait [`PartialEq`].
 /// The behavior of this macro is described in detail [here](PartialEq#derivable).
-#[rustc_builtin_macro]
+#[rustc_builtin_macro(PartialEq, attributes(skip))]
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
 #[allow_internal_unstable(core_intrinsics, structural_match)]
 pub macro PartialEq($item:item) {
@@ -911,7 +911,7 @@ pub trait Ord: Eq + PartialOrd<Self> {
 
 /// Derive macro generating an impl of the trait [`Ord`].
 /// The behavior of this macro is described in detail [here](Ord#derivable).
-#[rustc_builtin_macro]
+#[rustc_builtin_macro(Ord, attributes(skip))]
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
 #[allow_internal_unstable(core_intrinsics)]
 pub macro Ord($item:item) {
@@ -1225,7 +1225,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
 
 /// Derive macro generating an impl of the trait [`PartialOrd`].
 /// The behavior of this macro is described in detail [here](PartialOrd#derivable).
-#[rustc_builtin_macro]
+#[rustc_builtin_macro(PartialOrd, attributes(skip))]
 #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
 #[allow_internal_unstable(core_intrinsics)]
 pub macro PartialOrd($item:item) {
diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
@@ -606,7 +606,7 @@ pub trait Debug {
 // Separate module to reexport the macro `Debug` from prelude without the trait `Debug`.
 pub(crate) mod macros {
     /// Derive macro generating an impl of the trait `Debug`.
-    #[rustc_builtin_macro]
+    #[rustc_builtin_macro(Debug, attributes(skip))]
     #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
     #[allow_internal_unstable(core_intrinsics, fmt_helpers_for_derive)]
     pub macro Debug($item:item) {
diff --git a/library/core/src/hash/mod.rs b/library/core/src/hash/mod.rs
@@ -248,7 +248,7 @@ pub trait Hash {
 // Separate module to reexport the macro `Hash` from prelude without the trait `Hash`.
 pub(crate) mod macros {
     /// Derive macro generating an impl of the trait `Hash`.
-    #[rustc_builtin_macro]
+    #[rustc_builtin_macro(Hash, attributes(skip))]
     #[stable(feature = "builtin_macro_prelude", since = "1.38.0")]
     #[allow_internal_unstable(core_intrinsics)]
     pub macro Hash($item:item) {
diff --git a/tests/ui/deriving/skip/derive-skip-invalid.rs b/tests/ui/deriving/skip/derive-skip-invalid.rs
@@ -0,0 +1,12 @@
+#![crate_type = "lib"]
+#![feature(derive_skip)]
+
+#[derive(Debug)]
+struct KeyVal(#[skip = "Debug"] usize); //~ ERROR invalid skip attribute
+
+#[derive(Debug)]
+struct BadArg(#[skip("Debug")] usize);  //~ ERROR incorrect skip argument
+
+// FIXME: better error for derives not supporting `skip`
+#[derive(Clone)]
+struct SkipClone(#[skip] usize);  //~ ERROR cannot find attribute `skip` in this scope
diff --git a/tests/ui/deriving/skip/derive-skip-invalid.stderr b/tests/ui/deriving/skip/derive-skip-invalid.stderr
diff --git a/tests/ui/deriving/skip/derive-skip.rs b/tests/ui/deriving/skip/derive-skip.rs
diff --git a/tests/ui/feature-gates/feature-gate-derive-skip.rs b/tests/ui/feature-gates/feature-gate-derive-skip.rs
diff --git a/tests/ui/feature-gates/feature-gate-derive-skip.stderr b/tests/ui/feature-gates/feature-gate-derive-skip.stderr
