Prototype code to migrate from #[structural_match] attribute to Structural trait.

As far as I can tell this preserves previous observable stable behavior,
*including* the ICE from rust-lang#61188.

(In other words, further work is necessary to reap benefits of switching to a
trait.)

Author: pnkfelix

src/libcore/marker.rs

@@ -126,6 +126,32 @@ pub trait Unsize<T: ?Sized> {
     // Empty.
 }
 
+/// Types that can be used in constants within pattern matches.
+///
+/// Any type that derives `PartialEq` automatically implements this trait.
+///
+/// If a `const` item contains some type that does not implement this trait,
+/// then that type either (1.) does not implement `PartialEq` (which means the
+/// constant will not provide that comparison method, which code generation
+/// assumes is available), or (2.) it implements *its own* version of
+/// `PartialEq` (which we assume does not conform to a structural-equality
+/// comparison).
+///
+/// In either of the two scenarios above, we reject usage of such a constant in
+/// a pattern match.
+///
+/// See also the [structural match RFC][RFC1445], and [issue 63438][] which
+/// motivated migrating from attribute-based design to this `Structural` trait.
+///
+/// [RFC1445]: https://github.com/rust-lang/rfcs/blob/master/text/1445-restrict-constants-in-patterns.md
+/// [issue 63438]: https://github.com/rust-lang/rust/issues/63438
+#[cfg(not(bootstrap))]
+#[unstable(feature = "structural_match", issue = "31434")]
+#[lang = "structural_match"]
+pub trait Structural {
+    // Empty.
+}
+
 /// Types whose values can be duplicated simply by copying bits.
 ///
 /// By default, variable bindings have 'move semantics.' In other

src/librustc/middle/lang_items.rs

@@ -297,6 +297,7 @@ language_item_table! {
 
     SizedTraitLangItem,          "sized",              sized_trait,             Target::Trait;
     UnsizeTraitLangItem,         "unsize",             unsize_trait,            Target::Trait;
+    StructuralTraitLangItem,     "structural_match",   structural_trait,        Target::Trait;
     CopyTraitLangItem,           "copy",               copy_trait,              Target::Trait;
     CloneTraitLangItem,          "clone",              clone_trait,             Target::Trait;
     SyncTraitLangItem,           "sync",               sync_trait,              Target::Trait;

src/librustc/traits/error_reporting.rs

@@ -1903,6 +1903,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             ObligationCauseCode::ConstSized => {
                 err.note("constant expressions must have a statically known size");
             }
+            ObligationCauseCode::ConstPatternStructural => {
+                err.note("constants used for pattern-matching must derive `PartialEq` and `Eq`");
+            }
             ObligationCauseCode::SharedStatic => {
                 err.note("shared static variables must have a type that implements `Sync`");
             }

src/librustc/traits/mod.rs

@@ -236,6 +236,9 @@ pub enum ObligationCauseCode<'tcx> {
     /// Computing common supertype in the pattern guard for the arms of a match expression
     MatchExpressionArmPattern { span: Span, ty: Ty<'tcx> },
 
+    /// Constants in patterns must have `Structural` type.
+    ConstPatternStructural,
+
     /// Computing common supertype in an if expression
     IfExpression(Box<IfExpressionCause>),
 

src/librustc/traits/structural_impls.rs

@@ -493,6 +493,7 @@ impl<'a, 'tcx> Lift<'tcx> for traits::ObligationCauseCode<'a> {
             super::RepeatVec => Some(super::RepeatVec),
             super::FieldSized { adt_kind, last } => Some(super::FieldSized { adt_kind, last }),
             super::ConstSized => Some(super::ConstSized),
+            super::ConstPatternStructural => Some(super::ConstPatternStructural),
             super::SharedStatic => Some(super::SharedStatic),
             super::BuiltinDerivedObligation(ref cause) => {
                 tcx.lift(cause).map(super::BuiltinDerivedObligation)

src/librustc_mir/hair/pattern/mod.rs

@@ -14,6 +14,7 @@ use rustc::lint;
 use rustc::mir::{Field, BorrowKind, Mutability};
 use rustc::mir::{UserTypeProjection};
 use rustc::mir::interpret::{GlobalId, ConstValue, get_slice_bytes, sign_extend};
+use rustc::traits::{self, ConstPatternStructural, TraitEngine};
 use rustc::traits::{ObligationCause, PredicateObligation};
 use rustc::ty::{self, Region, TyCtxt, AdtDef, Ty, UserType, DefIdTree};
 use rustc::ty::{CanonicalUserType, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations};
@@ -1003,7 +1004,9 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
         if self.include_lint_checks && !saw_error {
             // If we were able to successfully convert the const to some pat, double-check
             // that the type of the const obeys `#[structural_match]` constraint.
-            if let Some(adt_def) = search_for_adt_without_structural_match(self.tcx, cv.ty) {
+            if let Some(adt_def) =
+                search_for_adt_without_structural_match(self.tcx, cv.ty, id, span)
+            {
 
                 let path = self.tcx.def_path_str(adt_def.did);
                 let msg = format!(
@@ -1173,8 +1176,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
 }
 
 /// This method traverses the structure of `ty`, trying to find an
-/// instance of an ADT (i.e. struct or enum) that was declared without
-/// the `#[structural_match]` attribute.
+/// instance of an ADT (i.e. struct or enum) that does not implement
+/// the `Structural` trait.
 ///
 /// The "structure of a type" includes all components that would be
 /// considered when doing a pattern match on a constant of that
@@ -1188,31 +1191,35 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
 ///    instantiated generic like `PhantomData<T>`.
 ///
 /// The reason we do this search is Rust currently require all ADT's
-/// reachable from a constant's type to be annotated with
-/// `#[structural_match]`, an attribute which essentially says that
-/// the implementation of `PartialEq::eq` behaves *equivalently* to a
-/// comparison against the unfolded structure.
+/// reachable from a constant's type to implement `Structural`, a
+/// trait which essentially says that the implementation of
+/// `PartialEq::eq` behaves *equivalently* to a comparison against
+/// the unfolded structure.
 ///
 /// For more background on why Rust has this requirement, and issues
 /// that arose when the requirement was not enforced completely, see
 /// Rust RFC 1445, rust-lang/rust#61188, and rust-lang/rust#62307.
 fn search_for_adt_without_structural_match<'tcx>(tcx: TyCtxt<'tcx>,
-                                                 ty: Ty<'tcx>)
+                                                 ty: Ty<'tcx>,
+                                                 id: hir::HirId,
+                                                 span: Span)
                                                  -> Option<&'tcx AdtDef>
 {
     // Import here (not mod level), because `TypeFoldable::fold_with`
     // conflicts with `PatternFoldable::fold_with`
     use crate::rustc::ty::fold::TypeVisitor;
     use crate::rustc::ty::TypeFoldable;
 
-    let mut search = Search { tcx, found: None, seen: FxHashSet::default() };
+    let mut search = Search { tcx, id, span, found: None, seen: FxHashSet::default() };
     ty.visit_with(&mut search);
     return search.found;
 
     struct Search<'tcx> {
         tcx: TyCtxt<'tcx>,
+        id: hir::HirId,
+        span: Span,
 
-        // records the first ADT we find without `#[structural_match`
+        // records the first ADT we find that does not implement `Structural`.
         found: Option<&'tcx AdtDef>,
 
         // tracks ADT's previously encountered during search, so that
@@ -1251,18 +1258,34 @@ fn search_for_adt_without_structural_match<'tcx>(tcx: TyCtxt<'tcx>,
                 }
             };
 
-            if !self.tcx.has_attr(adt_def.did, sym::structural_match) {
-                self.found = Some(&adt_def);
-                debug!("Search found adt_def: {:?}", adt_def);
-                return true // Halt visiting!
-            }
-
             if self.seen.contains(adt_def) {
                 debug!("Search already seen adt_def: {:?}", adt_def);
                 // let caller continue its search
                 return false;
             }
 
+            let non_structural = self.tcx.infer_ctxt().enter(|infcx| {
+                let cause = ObligationCause::new(self.span, self.id, ConstPatternStructural);
+                let mut fulfillment_cx = traits::FulfillmentContext::new();
+                let structural_def_id = self.tcx.lang_items().structural_trait().unwrap();
+                fulfillment_cx.register_bound(
+                    &infcx, ty::ParamEnv::empty(), ty, structural_def_id, cause);
+                if let Err(_err) = fulfillment_cx.select_all_or_error(&infcx) {
+                    // initial prototype: don't report any trait fulfillment error here.
+                    //
+                    // infcx.report_fulfillment_errors(&err, None, false);
+                    true
+                } else {
+                    false
+                }
+            });
+
+            if non_structural {
+                debug!("Search found ty: {:?}", ty);
+                self.found = Some(&adt_def);
+                return true // Halt visiting!
+            }
+
             self.seen.insert(adt_def);
 
             // `#[structural_match]` does not care about the

src/libsyntax_ext/deriving/cmp/partial_eq.rs

@@ -2,11 +2,11 @@ use crate::deriving::{path_local, path_std};
 use crate::deriving::generic::*;
 use crate::deriving::generic::ty::*;
 
-use syntax::ast::{BinOpKind, Expr, MetaItem};
+use syntax::ast::{self, BinOpKind, Expr, ItemKind, MetaItem};
 use syntax::ext::base::{Annotatable, ExtCtxt, SpecialDerives};
 use syntax::ptr::P;
 use syntax::symbol::sym;
-use syntax_pos::Span;
+use syntax_pos::{self, Span};
 
 pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt<'_>,
                                   span: Span,
@@ -81,6 +81,8 @@ pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt<'_>,
         } }
     }
 
+    inject_impl_of_structural_trait(cx, span, item, push);
+
     // avoid defining `ne` if we can
     // c-like enums, enums without any fields and structs without fields
     // can safely define only `eq`.
@@ -102,3 +104,92 @@ pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt<'_>,
     };
     trait_def.expand(cx, mitem, item, push)
 }
+
+// Injects `impl<...> Structural for ItemType<...> { }`. In particular,
+// does *not* add `where T: Structural` for parameters `T` in `...`.
+// (That's the main reason we cannot use TraitDef here.)
+fn inject_impl_of_structural_trait(cx: &mut ExtCtxt<'_>,
+                                   span: Span,
+                                   item: &Annotatable,
+                                   push: &mut dyn FnMut(Annotatable)) {
+
+    // set the expn ID so we can use the unstable trait.
+    let span = span.fresh_expansion(syntax_pos::ExpnData::allow_unstable(
+        syntax_pos::ExpnKind::Macro(syntax_pos::MacroKind::Derive, sym::PartialEq),
+        span,
+        cx.parse_sess.edition,
+        [sym::structural_match][..].into()));
+
+    let item = match *item {
+        Annotatable::Item(ref item) => item,
+        _ => {
+            // Non-Item derive is an error, but it should have been
+            // set earlier; see
+            // libsyntax/ext/expand.rs:MacroExpander::expand()
+            return;
+        }
+    };
+
+    let generics = match item.kind {
+        ItemKind::Struct(_, ref generics) => generics,
+        ItemKind::Enum(_, ref generics) => generics,
+        // Do not inject `impl Structural for Union`. (`PartialEq` does not
+        // support unions, so we will see error downstream.)
+        ItemKind::Union(..) => return,
+        _ => unreachable!(),
+    };
+
+    // Create generics param list for where clauses and impl headers
+    let mut generics = generics.clone();
+
+    // Create the type of `self`.
+    //
+    // in addition, remove defaults from type params (impls cannot have them).
+    let self_params: Vec<_> = generics.params.iter_mut().map(|param| match &mut param.kind {
+        ast::GenericParamKind::Lifetime => {
+            ast::GenericArg::Lifetime(cx.lifetime(span, param.ident))
+        }
+        ast::GenericParamKind::Type { default } => {
+            *default = None;
+            ast::GenericArg::Type(cx.ty_ident(span, param.ident))
+        }
+        ast::GenericParamKind::Const { ty: _ } => {
+            ast::GenericArg::Const(cx.const_ident(span, param.ident))
+        }
+    }).collect();
+
+    let type_ident = item.ident;
+
+    let structural_path = path_std!(cx, marker::Structural);
+    let trait_ref = cx.trait_ref(structural_path.to_path(cx, span, type_ident, &generics));
+    let self_type = cx.ty_path(cx.path_all(span, false, vec![type_ident], self_params));
+
+    // It would be nice to also encode constraint `where Self: Eq` (by adding it
+    // onto `generics` cloned above). Unfortunately, that strategy runs afoul of
+    // rust-lang/rust#48214. So we perform that additional check in the compiler
+    // itself, instead of encoding it here.
+
+    // Keep the lint and stability attributes of the original item, to control
+    // how the generated implementation is linted.
+    let mut attrs = Vec::new();
+    attrs.extend(item.attrs
+                 .iter()
+                 .filter(|a| {
+                     [sym::allow, sym::warn, sym::deny, sym::forbid, sym::stable, sym::unstable]
+                         .contains(&a.name_or_empty())
+                 })
+                 .cloned());
+
+    let newitem = cx.item(span,
+                          ast::Ident::invalid(),
+                          attrs,
+                          ItemKind::Impl(ast::Unsafety::Normal,
+                                         ast::ImplPolarity::Positive,
+                                         ast::Defaultness::Final,
+                                         generics,
+                                         Some(trait_ref),
+                                         self_type,
+                                         Vec::new()));
+
+    push(Annotatable::Item(newitem));
+}

src/test/ui/rfc1445/feature-gate.rs

@@ -25,3 +25,6 @@ fn main() { //[with_gate]~ ERROR compilation successful
         _ => { }
     }
 }
+
+#[cfg(with_gate)]
+impl std::marker::Structural for Foo { }