Use correct type in diagnostics again

compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs

@@ -89,11 +89,42 @@ impl<'a, 'tcx> ConstToPat<'a, 'tcx> {
         self.infcx.tcx
     }
 
-    fn search_for_structural_match_violation(
+    fn search_for_structural_match_violation(&self, ty: Ty<'tcx>) -> Option<String> {
-        &self,
+        traits::search_for_structural_match_violation(self.id, self.span, self.tcx(), ty).map(
-        ty: Ty<'tcx>,
+            |non_sm_ty| {
-    ) -> Option<traits::NonStructuralMatchTy<'tcx>> {
+                with_no_trimmed_paths(|| match non_sm_ty {
-        traits::search_for_structural_match_violation(self.id, self.span, self.tcx(), ty)
+                    traits::NonStructuralMatchTy::Adt(adt_def) => {
+                        let path = self.tcx().def_path_str(adt_def.did);
+                        format!(
+                            "to use a constant of type `{}` in a pattern, \
+                         `{}` must be annotated with `#[derive(PartialEq, Eq)]`",
+                            path, path,
+                        )
+                    }
+                    traits::NonStructuralMatchTy::Dynamic => {
+                        "trait objects cannot be used in patterns".to_string()
+                    }
+                    traits::NonStructuralMatchTy::Opaque => {
+                        "opaque types cannot be used in patterns".to_string()
+                    }
+                    traits::NonStructuralMatchTy::Generator => {
+                        "generators cannot be used in patterns".to_string()
+                    }
+                    traits::NonStructuralMatchTy::Closure => {
+                        "closures cannot be used in patterns".to_string()
+                    }
+                    traits::NonStructuralMatchTy::Param => {
+                        bug!("use of a constant whose type is a parameter inside a pattern")
+                    }
+                    traits::NonStructuralMatchTy::Projection => {
+                        bug!("use of a constant whose type is a projection inside a pattern")
+                    }
+                    traits::NonStructuralMatchTy::Foreign => {
+                        bug!("use of a value of a foreign type inside a pattern")
+                    }
+                })
+            },
+        )
     }
 
     fn type_marked_structural(&self, ty: Ty<'tcx>) -> bool {
@@ -135,39 +166,7 @@ impl<'a, 'tcx> ConstToPat<'a, 'tcx> {
                 return inlined_const_as_pat;
             }
 
-            if let Some(non_sm_ty) = structural {
+            if let Some(msg) = structural {
-                let msg = with_no_trimmed_paths(|| match non_sm_ty {
-                    traits::NonStructuralMatchTy::Adt(adt_def) => {
-                        let path = self.tcx().def_path_str(adt_def.did);
-                        format!(
-                            "to use a constant of type `{}` in a pattern, \
-                             `{}` must be annotated with `#[derive(PartialEq, Eq)]`",
-                            path, path,
-                        )
-                    }
-                    traits::NonStructuralMatchTy::Dynamic => {
-                        "trait objects cannot be used in patterns".to_string()
-                    }
-                    traits::NonStructuralMatchTy::Opaque => {
-                        "opaque types cannot be used in patterns".to_string()
-                    }
-                    traits::NonStructuralMatchTy::Generator => {
-                        "generators cannot be used in patterns".to_string()
-                    }
-                    traits::NonStructuralMatchTy::Closure => {
-                        "closures cannot be used in patterns".to_string()
-                    }
-                    traits::NonStructuralMatchTy::Param => {
-                        bug!("use of a constant whose type is a parameter inside a pattern")
-                    }
-                    traits::NonStructuralMatchTy::Projection => {
-                        bug!("use of a constant whose type is a projection inside a pattern")
-                    }
-                    traits::NonStructuralMatchTy::Foreign => {
-                        bug!("use of a value of a foreign type inside a pattern")
-                    }
-                });
-
                 if !self.type_may_have_partial_eq_impl(cv.ty) {
                     // span_fatal avoids ICE from resolution of non-existent method (rare case).
                     self.tcx().sess.span_fatal(self.span, &msg);
@@ -272,11 +271,9 @@ impl<'a, 'tcx> ConstToPat<'a, 'tcx> {
                     // `search_for_structural_match_violation` and then remove this condition.
                     && self.search_for_structural_match_violation(cv.ty).is_some() =>
             {
-                let msg = format!(
+                // Obtain the actual type that isn't annotated. If we just looked at `cv.ty` we
-                    "to use a constant of type `{}` in a pattern, \
+                // could get `Option<NonStructEq>`, even though `Option` is annotated with derive.
-                    `{}` must be annotated with `#[derive(PartialEq, Eq)]`",
+                let msg = self.search_for_structural_match_violation(cv.ty).unwrap();
-                    cv.ty, cv.ty,
-                );
                 self.saw_const_match_error.set(true);
                 if self.include_lint_checks {
                     tcx.sess.span_err(self.span, &msg);
@@ -512,11 +509,11 @@ impl<'a, 'tcx> ConstToPat<'a, 'tcx> {
             && self.search_for_structural_match_violation(cv.ty).is_some()
         {
             self.saw_const_match_lint.set(true);
-            let msg = format!(
+            // Obtain the actual type that isn't annotated. If we just looked at `cv.ty` we
-                "to use a constant of type `{}` in a pattern, \
+            // could get `Option<NonStructEq>`, even though `Option` is annotated with derive.
-                 the constant's initializer must be trivial or all types \
+            let msg = self.search_for_structural_match_violation(cv.ty).unwrap().replace(
-                 in the constant must be annotated with `#[derive(PartialEq, Eq)]`",
+                "in a pattern,",
-                cv.ty,
+                "in a pattern, the constant's initializer must be trivial or",
             );
             tcx.struct_span_lint_hir(
                 lint::builtin::NONTRIVIAL_STRUCTURAL_MATCH,

src/test/ui/consts/const_in_pattern/custom-eq-branch-warn.stderr

@@ -1,4 +1,4 @@
-warning: to use a constant of type `Foo` in a pattern, the constant's initializer must be trivial or all types in the constant must be annotated with `#[derive(PartialEq, Eq)]`
+warning: to use a constant of type `CustomEq` in a pattern, the constant's initializer must be trivial or `CustomEq` must be annotated with `#[derive(PartialEq, Eq)]`
   --> $DIR/custom-eq-branch-warn.rs:29:9
    |
 LL |         BAR_BAZ => panic!(),

src/test/ui/consts/const_in_pattern/reject_non_partial_eq.stderr

@@ -1,4 +1,4 @@
-error: to use a constant of type `Option<NoPartialEq>` in a pattern, `Option<NoPartialEq>` must be annotated with `#[derive(PartialEq, Eq)]`
+error: to use a constant of type `NoPartialEq` in a pattern, `NoPartialEq` must be annotated with `#[derive(PartialEq, Eq)]`
   --> $DIR/reject_non_partial_eq.rs:28:9
    |
 LL |         NO_PARTIAL_EQ_NONE => println!("NO_PARTIAL_EQ_NONE"),

src/test/ui/consts/const_in_pattern/warn_corner_cases.stderr

@@ -1,4 +1,4 @@
-warning: to use a constant of type `Option<NoDerive>` in a pattern, the constant's initializer must be trivial or all types in the constant must be annotated with `#[derive(PartialEq, Eq)]`
+warning: to use a constant of type `NoDerive` in a pattern, the constant's initializer must be trivial or `NoDerive` must be annotated with `#[derive(PartialEq, Eq)]`
   --> $DIR/warn_corner_cases.rs:26:47
    |
 LL |     match None { Some(_) => panic!("whoops"), INDEX => dbg!(INDEX), };
@@ -8,7 +8,7 @@ LL |     match None { Some(_) => panic!("whoops"), INDEX => dbg!(INDEX), };
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #73448 <https://github.com/rust-lang/rust/issues/73448>
 
-warning: to use a constant of type `Option<NoDerive>` in a pattern, the constant's initializer must be trivial or all types in the constant must be annotated with `#[derive(PartialEq, Eq)]`
+warning: to use a constant of type `NoDerive` in a pattern, the constant's initializer must be trivial or `NoDerive` must be annotated with `#[derive(PartialEq, Eq)]`
   --> $DIR/warn_corner_cases.rs:32:47
    |
 LL |     match None { Some(_) => panic!("whoops"), CALL => dbg!(CALL), };
@@ -17,7 +17,7 @@ LL |     match None { Some(_) => panic!("whoops"), CALL => dbg!(CALL), };
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #73448 <https://github.com/rust-lang/rust/issues/73448>
 
-warning: to use a constant of type `Option<NoDerive>` in a pattern, the constant's initializer must be trivial or all types in the constant must be annotated with `#[derive(PartialEq, Eq)]`
+warning: to use a constant of type `NoDerive` in a pattern, the constant's initializer must be trivial or `NoDerive` must be annotated with `#[derive(PartialEq, Eq)]`
   --> $DIR/warn_corner_cases.rs:38:47
    |
 LL |     match None { Some(_) => panic!("whoops"), METHOD_CALL => dbg!(METHOD_CALL), };