Auto merge of #124661 - RalfJung:only-structural-consts-in-patterns, r=pnkfelix

Turn remaining non-structural-const-in-pattern lints into hard errors

This completes the implementation of https://github.com/rust-lang/rust/issues/120362 by turning our remaining future-compat lints into hard errors: indirect_structural_match and pointer_structural_match.

They have been future-compat lints for a while (indirect_structural_match for many years, pointer_structural_match since Rust 1.75 (released Dec 28, 2023)), and have shown up in dependency breakage reports since Rust 1.78 (just released on May 2, 2024). I don't expect a lot of code will still depend on them, but we will of course do a crater run.

A lot of cleanup is now possible in const_to_pat, but that is deferred to a later PR.

Fixes https://github.com/rust-lang/rust/issues/70861

compiler/rustc_lint/src/lib.rs

@@ -539,6 +539,16 @@ fn register_builtins(store: &mut LintStore) {
         "converted into hard error, see RFC #3535 \
          <https://rust-lang.github.io/rfcs/3535-constants-in-patterns.html> for more information",
     );
+    store.register_removed(
+        "indirect_structural_match",
+        "converted into hard error, see RFC #3535 \
+         <https://rust-lang.github.io/rfcs/3535-constants-in-patterns.html> for more information",
+    );
+    store.register_removed(
+        "pointer_structural_match",
+        "converted into hard error, see RFC #3535 \
+         <https://rust-lang.github.io/rfcs/3535-constants-in-patterns.html> for more information",
+    );
 }
 
 fn register_internals(store: &mut LintStore) {

compiler/rustc_lint_defs/src/builtin.rs

@@ -49,7 +49,6 @@ declare_lint_pass! {
         HIDDEN_GLOB_REEXPORTS,
         ILL_FORMED_ATTRIBUTE_INPUT,
         INCOMPLETE_INCLUDE,
-        INDIRECT_STRUCTURAL_MATCH,
         INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
         INLINE_NO_SANITIZE,
         INVALID_DOC_ATTRIBUTES,
@@ -74,7 +73,6 @@ declare_lint_pass! {
         ORDER_DEPENDENT_TRAIT_OBJECTS,
         OVERLAPPING_RANGE_ENDPOINTS,
         PATTERNS_IN_FNS_WITHOUT_BODY,
-        POINTER_STRUCTURAL_MATCH,
         PRIVATE_BOUNDS,
         PRIVATE_INTERFACES,
         PROC_MACRO_BACK_COMPAT,
@@ -2351,52 +2349,6 @@ declare_lint! {
     "outlives requirements can be inferred"
 }
 
-declare_lint! {
-    /// The `indirect_structural_match` lint detects a `const` in a pattern
-    /// that manually implements [`PartialEq`] and [`Eq`].
-    ///
-    /// [`PartialEq`]: https://doc.rust-lang.org/std/cmp/trait.PartialEq.html
-    /// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
-    ///
-    /// ### Example
-    ///
-    /// ```rust,compile_fail
-    /// #![deny(indirect_structural_match)]
-    ///
-    /// struct NoDerive(i32);
-    /// impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
-    /// impl Eq for NoDerive { }
-    /// #[derive(PartialEq, Eq)]
-    /// struct WrapParam<T>(T);
-    /// const WRAP_INDIRECT_PARAM: & &WrapParam<NoDerive> = & &WrapParam(NoDerive(0));
-    /// fn main() {
-    ///     match WRAP_INDIRECT_PARAM {
-    ///         WRAP_INDIRECT_PARAM => { }
-    ///         _ => { }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// The compiler unintentionally accepted this form in the past. This is a
-    /// [future-incompatible] lint to transition this to a hard error in the
-    /// future. See [issue #62411] for a complete description of the problem,
-    /// and some possible solutions.
-    ///
-    /// [issue #62411]: https://github.com/rust-lang/rust/issues/62411
-    /// [future-incompatible]: ../index.md#future-incompatible-lints
-    pub INDIRECT_STRUCTURAL_MATCH,
-    Warn,
-    "constant used in pattern contains value of non-structural-match type in a field or a variant",
-    @future_incompatible = FutureIncompatibleInfo {
-        reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
-        reference: "issue #120362 <https://github.com/rust-lang/rust/issues/120362>",
-    };
-}
-
 declare_lint! {
     /// The `deprecated_in_future` lint is internal to rustc and should not be
     /// used by user code.
@@ -2414,45 +2366,6 @@ declare_lint! {
     report_in_external_macro
 }
 
-declare_lint! {
-    /// The `pointer_structural_match` lint detects pointers used in patterns whose behaviour
-    /// cannot be relied upon across compiler versions and optimization levels.
-    ///
-    /// ### Example
-    ///
-    /// ```rust,compile_fail
-    /// #![deny(pointer_structural_match)]
-    /// fn foo(a: usize, b: usize) -> usize { a + b }
-    /// const FOO: fn(usize, usize) -> usize = foo;
-    /// fn main() {
-    ///     match FOO {
-    ///         FOO => {},
-    ///         _ => {},
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// Previous versions of Rust allowed function pointers and all raw pointers in patterns.
-    /// While these work in many cases as expected by users, it is possible that due to
-    /// optimizations pointers are "not equal to themselves" or pointers to different functions
-    /// compare as equal during runtime. This is because LLVM optimizations can deduplicate
-    /// functions if their bodies are the same, thus also making pointers to these functions point
-    /// to the same location. Additionally functions may get duplicated if they are instantiated
-    /// in different crates and not deduplicated again via LTO. Pointer identity for memory
-    /// created by `const` is similarly unreliable.
-    pub POINTER_STRUCTURAL_MATCH,
-    Warn,
-    "pointers are not structural-match",
-    @future_incompatible = FutureIncompatibleInfo {
-        reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
-        reference: "issue #120362 <https://github.com/rust-lang/rust/issues/120362>",
-    };
-}
-
 declare_lint! {
     /// The `ambiguous_associated_items` lint detects ambiguity between
     /// [associated items] and [enum variants].

compiler/rustc_mir_build/messages.ftl

@@ -109,9 +109,6 @@ mir_build_extern_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
     .note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
     .label = use of extern static
 
-mir_build_indirect_structural_match =
-    to use a constant of type `{$non_sm_ty}` in a pattern, `{$non_sm_ty}` must be annotated with `#[derive(PartialEq)]`
-
 mir_build_inform_irrefutable = `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
 
 mir_build_initializing_type_with_requires_unsafe =
@@ -257,9 +254,6 @@ mir_build_non_exhaustive_patterns_type_not_empty = non-exhaustive patterns: type
 mir_build_non_partial_eq_match =
     to use a constant of type `{$non_peq_ty}` in a pattern, the type must implement `PartialEq`
 
-mir_build_nontrivial_structural_match =
-    to use a constant of type `{$non_sm_ty}` in a pattern, the constant's initializer must be trivial or `{$non_sm_ty}` must be annotated with `#[derive(PartialEq)]`
-
 mir_build_pattern_not_covered = refutable pattern in {$origin}
     .pattern_ty = the matched value is of type `{$pattern_ty}`
 

compiler/rustc_mir_build/src/errors.rs

@@ -794,9 +794,12 @@ pub struct NaNPattern {
     pub span: Span,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag(mir_build_pointer_pattern)]
-pub struct PointerPattern;
+pub struct PointerPattern {
+    #[primary_span]
+    pub span: Span,
+}
 
 #[derive(Diagnostic)]
 #[diag(mir_build_non_empty_never_pattern)]
@@ -808,22 +811,6 @@ pub struct NonEmptyNeverPattern<'tcx> {
     pub ty: Ty<'tcx>,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(mir_build_indirect_structural_match)]
-#[note(mir_build_type_not_structural_tip)]
-#[note(mir_build_type_not_structural_more_info)]
-pub struct IndirectStructuralMatch<'tcx> {
-    pub non_sm_ty: Ty<'tcx>,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(mir_build_nontrivial_structural_match)]
-#[note(mir_build_type_not_structural_tip)]
-#[note(mir_build_type_not_structural_more_info)]
-pub struct NontrivialStructuralMatch<'tcx> {
-    pub non_sm_ty: Ty<'tcx>,
-}
-
 #[derive(Diagnostic)]
 #[diag(mir_build_exceeds_mcdc_condition_num_limit)]
 pub(crate) struct MCDCExceedsConditionNumLimit {

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

@@ -7,7 +7,6 @@ use rustc_middle::mir;
 use rustc_middle::span_bug;
 use rustc_middle::thir::{FieldPat, Pat, PatKind};
 use rustc_middle::ty::{self, Ty, TyCtxt, ValTree};
-use rustc_session::lint;
 use rustc_span::{ErrorGuaranteed, Span};
 use rustc_target::abi::{FieldIdx, VariantIdx};
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
@@ -18,8 +17,8 @@ use std::cell::Cell;
 
 use super::PatCtxt;
 use crate::errors::{
-    IndirectStructuralMatch, InvalidPattern, NaNPattern, PointerPattern, TypeNotPartialEq,
+    InvalidPattern, NaNPattern, PointerPattern, TypeNotPartialEq, TypeNotStructural, UnionPattern,
-    TypeNotStructural, UnionPattern, UnsizedPattern,
+    UnsizedPattern,
 };
 
 impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
@@ -51,15 +50,6 @@ struct ConstToPat<'tcx> {
     // value.
     saw_const_match_error: Cell<Option<ErrorGuaranteed>>,
 
-    // This tracks if we emitted some diagnostic for a given const value, so that
-    // we will not subsequently issue an irrelevant lint for the same const
-    // value.
-    saw_const_match_lint: Cell<bool>,
-
-    // For backcompat we need to keep allowing non-structurally-eq types behind references.
-    // See also all the `cant-hide-behind` tests.
-    behind_reference: Cell<bool>,
-
     // inference context used for checking `T: Structural` bounds.
     infcx: InferCtxt<'tcx>,
 
@@ -86,8 +76,6 @@ impl<'tcx> ConstToPat<'tcx> {
             infcx,
             param_env: pat_ctxt.param_env,
             saw_const_match_error: Cell::new(None),
-            saw_const_match_lint: Cell::new(false),
-            behind_reference: Cell::new(false),
             treat_byte_string_as_slice: pat_ctxt
                 .typeck_results
                 .treat_byte_string_as_slice
@@ -199,15 +187,12 @@ impl<'tcx> ConstToPat<'tcx> {
                     // complained about structural match violations there, so we don't
                     // have to check anything any more.
                 }
-            } else if !have_valtree && !self.saw_const_match_lint.get() {
+            } else if !have_valtree {
                 // The only way valtree construction can fail without the structural match
                 // checker finding a violation is if there is a pointer somewhere.
-                self.tcx().emit_node_span_lint(
+                let e = self.tcx().dcx().emit_err(PointerPattern { span: self.span });
-                    lint::builtin::POINTER_STRUCTURAL_MATCH,
+                let kind = PatKind::Error(e);
-                    self.id,
+                return Box::new(Pat { span: self.span, ty: cv.ty(), kind });
-                    self.span,
-                    PointerPattern,
-                );
             }
 
             // Always check for `PartialEq` if we had no other errors yet.
@@ -276,36 +261,11 @@ impl<'tcx> ConstToPat<'tcx> {
         cv: ValTree<'tcx>,
         ty: Ty<'tcx>,
     ) -> Result<Box<Pat<'tcx>>, FallbackToOpaqueConst> {
-        let id = self.id;
         let span = self.span;
         let tcx = self.tcx();
         let param_env = self.param_env;
 
         let kind = match ty.kind() {
-            // If the type is not structurally comparable, just emit the constant directly,
-            // causing the pattern match code to treat it opaquely.
-            // FIXME: This code doesn't emit errors itself, the caller emits the errors.
-            // So instead of specific errors, you just get blanket errors about the whole
-            // const type. See
-            // https://github.com/rust-lang/rust/pull/70743#discussion_r404701963 for
-            // details.
-            // Backwards compatibility hack because we can't cause hard errors on these
-            // types, so we compare them via `PartialEq::eq` at runtime.
-            ty::Adt(..) if !self.type_marked_structural(ty) && self.behind_reference.get() => {
-                if self.saw_const_match_error.get().is_none() && !self.saw_const_match_lint.get() {
-                    self.saw_const_match_lint.set(true);
-                    tcx.emit_node_span_lint(
-                        lint::builtin::INDIRECT_STRUCTURAL_MATCH,
-                        id,
-                        span,
-                        IndirectStructuralMatch { non_sm_ty: ty },
-                    );
-                }
-                // Since we are behind a reference, we can just bubble the error up so we get a
-                // constant at reference type, making it easy to let the fallback call
-                // `PartialEq::eq` on it.
-                return Err(FallbackToOpaqueConst);
-            }
             ty::FnDef(..) => {
                 let e = tcx.dcx().emit_err(InvalidPattern { span, non_sm_ty: ty });
                 self.saw_const_match_error.set(Some(e));
@@ -379,38 +339,6 @@ impl<'tcx> ConstToPat<'tcx> {
                 ty::Str => {
                     PatKind::Constant { value: mir::Const::Ty(ty::Const::new_value(tcx, cv, ty)) }
                 }
-                // Backwards compatibility hack: support references to non-structural types,
-                // but hard error if we aren't behind a double reference. We could just use
-                // the fallback code path below, but that would allow *more* of this fishy
-                // code to compile, as then it only goes through the future incompat lint
-                // instead of a hard error.
-                ty::Adt(_, _) if !self.type_marked_structural(*pointee_ty) => {
-                    if self.behind_reference.get() {
-                        if self.saw_const_match_error.get().is_none()
-                            && !self.saw_const_match_lint.get()
-                        {
-                            self.saw_const_match_lint.set(true);
-                            tcx.emit_node_span_lint(
-                                lint::builtin::INDIRECT_STRUCTURAL_MATCH,
-                                self.id,
-                                span,
-                                IndirectStructuralMatch { non_sm_ty: *pointee_ty },
-                            );
-                        }
-                        return Err(FallbackToOpaqueConst);
-                    } else {
-                        if let Some(e) = self.saw_const_match_error.get() {
-                            // We already errored. Signal that in the pattern, so that follow up errors can be silenced.
-                            PatKind::Error(e)
-                        } else {
-                            let err = TypeNotStructural { span, non_sm_ty: *pointee_ty };
-                            let e = tcx.dcx().emit_err(err);
-                            self.saw_const_match_error.set(Some(e));
-                            // We errored. Signal that in the pattern, so that follow up errors can be silenced.
-                            PatKind::Error(e)
-                        }
-                    }
-                }
                 // All other references are converted into deref patterns and then recursively
                 // convert the dereferenced constant to a pattern that is the sub-pattern of the
                 // deref pattern.
@@ -421,7 +349,6 @@ impl<'tcx> ConstToPat<'tcx> {
                         // We errored. Signal that in the pattern, so that follow up errors can be silenced.
                         PatKind::Error(e)
                     } else {
-                        let old = self.behind_reference.replace(true);
                         // `b"foo"` produces a `&[u8; 3]`, but you can't use constants of array type when
                         // matching against references, you can only use byte string literals.
                         // The typechecker has a special case for byte string literals, by treating them
@@ -436,7 +363,6 @@ impl<'tcx> ConstToPat<'tcx> {
                         };
                         // References have the same valtree representation as their pointee.
                         let subpattern = self.recur(cv, pointee_ty)?;
-                        self.behind_reference.set(old);
                         PatKind::Deref { subpattern }
                     }
                 }

tests/ui/closures/2229_closure_analysis/match/match-edge-cases_1.rs

@@ -2,8 +2,7 @@
 //@ edition:2021
 
 const PATTERN_REF: &str = "Hello World";
-const NUMBER: i32 = 30;
+const NUMBER_POINTER: *const i32 = 30 as *const i32;
-const NUMBER_POINTER: *const i32 = &NUMBER;
 
 pub fn edge_case_ref(event: &str) {
     let _ = || {
@@ -26,8 +25,7 @@ pub fn edge_case_str(event: String) {
 pub fn edge_case_raw_ptr(event: *const i32) {
     let _ = || {
         match event {
-            NUMBER_POINTER => (), //~WARN behave unpredictably
+            NUMBER_POINTER => (),
-            //~| previously accepted
             _ => (),
         };
     };

tests/ui/closures/2229_closure_analysis/match/match-edge-cases_1.stderr

@@ -1,23 +0,0 @@
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/match-edge-cases_1.rs:29:13
-   |
-LL |             NUMBER_POINTER => (),
-   |             ^^^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-warning: 1 warning emitted
-
-Future incompatibility report: Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/match-edge-cases_1.rs:29:13
-   |
-LL |             NUMBER_POINTER => (),
-   |             ^^^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-

tests/ui/consts/const_in_pattern/accept_structural.rs

@@ -1,7 +1,6 @@
 //@ run-pass
 
 #![allow(non_local_definitions)]
-#![warn(indirect_structural_match)]
 
 // This test is checking our logic for structural match checking by enumerating
 // the different kinds of const expressions. This test is collecting cases where

tests/ui/consts/const_in_pattern/cross-crate-fail.rs

@@ -1,7 +1,5 @@
 //@ aux-build:consts.rs
 
-#![warn(indirect_structural_match)]
-
 extern crate consts;
 
 struct Defaulted;

tests/ui/consts/const_in_pattern/cross-crate-fail.stderr

@@ -1,5 +1,5 @@
 error: to use a constant of type `CustomEq` in a pattern, `CustomEq` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cross-crate-fail.rs:13:9
+  --> $DIR/cross-crate-fail.rs:11:9
    |
 LL |         consts::SOME => panic!(),
    |         ^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |         consts::SOME => panic!(),
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `CustomEq` in a pattern, `CustomEq` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cross-crate-fail.rs:20:9
+  --> $DIR/cross-crate-fail.rs:18:9
    |
 LL |         <Defaulted as consts::AssocConst>::SOME  => panic!(),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/ui/consts/const_in_pattern/cross-crate-pass.rs

@@ -1,8 +1,6 @@
 //@ run-pass
 //@ aux-build:consts.rs
 
-#![warn(indirect_structural_match)]
-
 extern crate consts;
 use consts::CustomEq;
 

tests/ui/consts/const_in_pattern/custom-eq-branch-pass.rs

@@ -1,7 +1,5 @@
 //@ run-pass
 
-#![warn(indirect_structural_match)]
-
 struct CustomEq;
 
 impl Eq for CustomEq {}

tests/ui/consts/const_in_pattern/issue-34784-match-on-non-int-raw-ptr.rs

@@ -1,4 +1,3 @@
-#![deny(pointer_structural_match)]
 #![allow(dead_code)]
 
 const C: *const u8 = &0;
@@ -8,7 +7,6 @@ const C_INNER: (*const u8, u8) = (C, 0);
 fn foo(x: *const u8) {
     match x {
         C => {} //~ERROR: behave unpredictably
-        //~| previously accepted
         _ => {}
     }
 }
@@ -16,7 +14,6 @@ fn foo(x: *const u8) {
 fn foo2(x: *const u8) {
     match (x, 1) {
         C_INNER => {} //~ERROR: behave unpredictably
-        //~| previously accepted
         _ => {}
     }
 }
@@ -28,13 +25,11 @@ const STR: *const str = "abcd";
 fn main() {
     match D {
         D => {} //~ERROR: behave unpredictably
-        //~| previously accepted
         _ => {}
     }
 
     match STR {
         STR => {} //~ERROR: behave unpredictably
-        //~| previously accepted
         _ => {}
     }
 }

tests/ui/consts/const_in_pattern/issue-34784-match-on-non-int-raw-ptr.stderr

@@ -1,103 +1,26 @@
 error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:10:9
+  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:9:9
    |
 LL |         C => {}
    |         ^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:1:9
-   |
-LL | #![deny(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:18:9
+  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:16:9
    |
 LL |         C_INNER => {}
    |         ^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
 error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:30:9
+  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:27:9
    |
 LL |         D => {}
    |         ^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
 error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:36:9
+  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:32:9
    |
 LL |         STR => {}
    |         ^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
 error: aborting due to 4 previous errors
 
-Future incompatibility report: Future breakage diagnostic:
-error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:10:9
-   |
-LL |         C => {}
-   |         ^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:1:9
-   |
-LL | #![deny(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
-
-Future breakage diagnostic:
-error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:18:9
-   |
-LL |         C_INNER => {}
-   |         ^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:1:9
-   |
-LL | #![deny(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
-
-Future breakage diagnostic:
-error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:30:9
-   |
-LL |         D => {}
-   |         ^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:1:9
-   |
-LL | #![deny(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
-
-Future breakage diagnostic:
-error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:36:9
-   |
-LL |         STR => {}
-   |         ^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-34784-match-on-non-int-raw-ptr.rs:1:9
-   |
-LL | #![deny(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
-

tests/ui/consts/const_in_pattern/issue-44333.rs

@@ -1,7 +1,3 @@
-//@ run-pass
-
-#![warn(pointer_structural_match)]
-
 type Func = fn(usize, usize) -> usize;
 
 fn foo(a: usize, b: usize) -> usize { a + b }
@@ -16,10 +12,8 @@ const BAR: Func = bar;
 
 fn main() {
     match test(std::env::consts::ARCH.len()) {
-        FOO => println!("foo"), //~ WARN behave unpredictably
+        FOO => println!("foo"), //~ ERROR behave unpredictably
-        //~^ WARN will become a hard error
+        BAR => println!("bar"), //~ ERROR behave unpredictably
-        BAR => println!("bar"), //~ WARN behave unpredictably
-        //~^ WARN will become a hard error
         _ => unreachable!(),
     }
 }

tests/ui/consts/const_in_pattern/issue-44333.stderr

@@ -1,55 +1,14 @@
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-44333.rs:19:9
+  --> $DIR/issue-44333.rs:15:9
    |
 LL |         FOO => println!("foo"),
    |         ^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-44333.rs:3:9
-   |
-LL | #![warn(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-44333.rs:21:9
+  --> $DIR/issue-44333.rs:16:9
    |
 LL |         BAR => println!("bar"),
    |         ^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
-warning: 2 warnings emitted
+error: aborting due to 2 previous errors
-
-Future incompatibility report: Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-44333.rs:19:9
-   |
-LL |         FOO => println!("foo"),
-   |         ^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-44333.rs:3:9
-   |
-LL | #![warn(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-44333.rs:21:9
-   |
-LL |         BAR => println!("bar"),
-   |         ^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-44333.rs:3:9
-   |
-LL | #![warn(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
 

tests/ui/consts/const_in_pattern/no-eq-branch-fail.rs

@@ -1,5 +1,3 @@
-#![warn(indirect_structural_match)]
-
 struct NoEq;
 
 enum Foo {

tests/ui/consts/const_in_pattern/no-eq-branch-fail.stderr

@@ -1,5 +1,5 @@
 error: to use a constant of type `Foo` in a pattern, `Foo` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/no-eq-branch-fail.rs:21:9
+  --> $DIR/no-eq-branch-fail.rs:19:9
    |
 LL |         BAR_BAZ => panic!(),
    |         ^^^^^^^

tests/ui/consts/const_in_pattern/reject_non_structural.rs

@@ -11,8 +11,6 @@
 // See also RFC 1445
 
 #![feature(type_ascription)]
-#![warn(indirect_structural_match)]
-//~^ NOTE lint level is defined here
 
 #[derive(Copy, Clone, Debug)]
 struct NoPartialEq;
@@ -96,9 +94,7 @@ fn main() {
 
     const ADDR_OF: &OND = &Some(NoDerive);
     match &Some(NoDerive) { ADDR_OF => dbg!(ADDR_OF), _ => panic!("whoops"), };
-    //~^ WARN must be annotated with `#[derive(PartialEq)]`
+    //~^ ERROR must be annotated with `#[derive(PartialEq)]`
     //~| NOTE the traits must be derived
     //~| NOTE StructuralPartialEq.html for details
-    //~| WARN previously accepted by the compiler but is being phased out
-    //~| NOTE for more information, see
 }

tests/ui/consts/const_in_pattern/reject_non_structural.stderr

@@ -1,5 +1,5 @@
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:42:36
+  --> $DIR/reject_non_structural.rs:40:36
    |
 LL |     match Derive::Some(NoDerive) { ENUM => dbg!(ENUM), _ => panic!("whoops"), };
    |                                    ^^^^
@@ -8,7 +8,7 @@ LL |     match Derive::Some(NoDerive) { ENUM => dbg!(ENUM), _ => panic!("whoops"
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:48:28
+  --> $DIR/reject_non_structural.rs:46:28
    |
 LL |     match Some(NoDerive) { FIELD => dbg!(FIELD), _ => panic!("whoops"), };
    |                            ^^^^^
@@ -17,7 +17,7 @@ LL |     match Some(NoDerive) { FIELD => dbg!(FIELD), _ => panic!("whoops"), };
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:55:27
+  --> $DIR/reject_non_structural.rs:53:27
    |
 LL |     match Some(NoDerive) {INDIRECT => dbg!(INDIRECT), _ => panic!("whoops"), };
    |                           ^^^^^^^^
@@ -26,7 +26,7 @@ LL |     match Some(NoDerive) {INDIRECT => dbg!(INDIRECT), _ => panic!("whoops")
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:61:36
+  --> $DIR/reject_non_structural.rs:59:36
    |
 LL |     match (None, Some(NoDerive)) { TUPLE => dbg!(TUPLE), _ => panic!("whoops"), };
    |                                    ^^^^^
@@ -35,7 +35,7 @@ LL |     match (None, Some(NoDerive)) { TUPLE => dbg!(TUPLE), _ => panic!("whoop
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:67:28
+  --> $DIR/reject_non_structural.rs:65:28
    |
 LL |     match Some(NoDerive) { TYPE_ASCRIPTION => dbg!(TYPE_ASCRIPTION), _ => panic!("whoops"), };
    |                            ^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     match Some(NoDerive) { TYPE_ASCRIPTION => dbg!(TYPE_ASCRIPTION), _ => p
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:73:36
+  --> $DIR/reject_non_structural.rs:71:36
    |
 LL |     match [None, Some(NoDerive)] { ARRAY => dbg!(ARRAY), _ => panic!("whoops"), };
    |                                    ^^^^^
@@ -53,7 +53,7 @@ LL |     match [None, Some(NoDerive)] { ARRAY => dbg!(ARRAY), _ => panic!("whoop
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:79:33
+  --> $DIR/reject_non_structural.rs:77:33
    |
 LL |     match [Some(NoDerive); 2] { REPEAT => dbg!(REPEAT), _ => panic!("whoops"), };
    |                                 ^^^^^^
@@ -62,7 +62,7 @@ LL |     match [Some(NoDerive); 2] { REPEAT => dbg!(REPEAT), _ => panic!("whoops
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:86:28
+  --> $DIR/reject_non_structural.rs:84:28
    |
 LL |     match Some(NoDerive) { NoDerive::ASSOC => dbg!(NoDerive::ASSOC), _ => panic!("whoops"), };
    |                            ^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL |     match Some(NoDerive) { NoDerive::ASSOC => dbg!(NoDerive::ASSOC), _ => p
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:92:28
+  --> $DIR/reject_non_structural.rs:90:28
    |
 LL |     match Some(NoDerive) { BLOCK => dbg!(BLOCK), _ => panic!("whoops"), };
    |                            ^^^^^
@@ -79,38 +79,14 @@ LL |     match Some(NoDerive) { BLOCK => dbg!(BLOCK), _ => panic!("whoops"), };
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
+error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:98:29
+  --> $DIR/reject_non_structural.rs:96:29
    |
 LL |     match &Some(NoDerive) { ADDR_OF => dbg!(ADDR_OF), _ => panic!("whoops"), };
    |                             ^^^^^^^
    |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/reject_non_structural.rs:14:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 9 previous errors; 1 warning emitted
+error: aborting due to 10 previous errors
-
-Future incompatibility report: Future breakage diagnostic:
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/reject_non_structural.rs:98:29
-   |
-LL |     match &Some(NoDerive) { ADDR_OF => dbg!(ADDR_OF), _ => panic!("whoops"), };
-   |                             ^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: the traits must be derived, manual `impl`s are not sufficient
-   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/reject_non_structural.rs:14:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 

tests/ui/consts/issue-89088.rs

@@ -1,8 +1,5 @@
 // Regression test for the ICE described in #89088.
 
-//@ check-pass
-
-#![allow(indirect_structural_match)]
 use std::borrow::Cow;
 
 const FOO: &A = &A::Field(Cow::Borrowed("foo"));
@@ -16,7 +13,7 @@ fn main() {
     let var = A::Field(Cow::Borrowed("bar"));
 
     match &var {
-        FOO => todo!(),
+        FOO => todo!(), //~ERROR derive(PartialEq)
         _ => todo!()
     }
 }

tests/ui/consts/issue-89088.stderr

@@ -1,12 +1,11 @@
-Future incompatibility report: Future breakage diagnostic:
+error: to use a constant of type `Cow<'_, str>` in a pattern, `Cow<'_, str>` must be annotated with `#[derive(PartialEq)]`
-warning: to use a constant of type `Cow<'_, str>` in a pattern, `Cow<'_, str>` must be annotated with `#[derive(PartialEq)]`
+  --> $DIR/issue-89088.rs:16:9
-  --> $DIR/issue-89088.rs:19:9
    |
 LL |         FOO => todo!(),
    |         ^^^
    |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
+error: aborting due to 1 previous error
+

tests/ui/nll/issue-55511.rs

@@ -1,4 +1,3 @@
-#![warn(indirect_structural_match)]
 use std::cell::Cell;
 trait Foo<'a> {
     const C: Option<Cell<&'a u32>>;

tests/ui/nll/issue-55511.stderr

@@ -1,5 +1,5 @@
 error[E0597]: `a` does not live long enough
-  --> $DIR/issue-55511.rs:13:28
+  --> $DIR/issue-55511.rs:12:28
    |
 LL |     let a = 22;
    |         - binding `a` declared here

tests/ui/pattern/usefulness/const-partial_eq-fallback-ice.stderr

@@ -9,15 +9,3 @@ LL |     if let CONSTANT = &&MyType {
 
 error: aborting due to 1 previous error
 
-Future incompatibility report: Future breakage diagnostic:
-warning: to use a constant of type `MyType` in a pattern, `MyType` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/const-partial_eq-fallback-ice.rs:14:12
-   |
-LL |     if let CONSTANT = &&MyType {
-   |            ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: the traits must be derived, manual `impl`s are not sufficient
-   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-

tests/ui/pattern/usefulness/consts-opaque.rs

@@ -93,10 +93,8 @@ fn main() {
     const QUUX: Quux = quux;
 
     match QUUX {
-        QUUX => {} //~WARN behave unpredictably
+        QUUX => {} //~ERROR behave unpredictably
-        //~| previously accepted
+        QUUX => {} //~ERROR behave unpredictably
-        QUUX => {} //~WARN behave unpredictably
-        //~| previously accepted
         _ => {}
     }
 
@@ -105,17 +103,14 @@ fn main() {
     const WRAPQUUX: Wrap<Quux> = Wrap(quux);
 
     match WRAPQUUX {
-        WRAPQUUX => {} //~WARN behave unpredictably
+        WRAPQUUX => {} //~ERROR behave unpredictably
-        //~| previously accepted
+        WRAPQUUX => {} //~ERROR behave unpredictably
-        WRAPQUUX => {} //~WARN behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     }
 
     match WRAPQUUX {
         Wrap(_) => {}
-        WRAPQUUX => {} //~WARN behave unpredictably
+        WRAPQUUX => {} //~ERROR behave unpredictably
-        //~| previously accepted
     }
 
     match WRAPQUUX {
@@ -123,9 +118,7 @@ fn main() {
     }
 
     match WRAPQUUX {
-        //~^ ERROR: non-exhaustive patterns: `Wrap(_)` not covered
+        WRAPQUUX => {} //~ERROR behave unpredictably
-        WRAPQUUX => {} //~WARN behave unpredictably
-        //~| previously accepted
     }
 
     #[derive(PartialEq, Eq)]
@@ -136,11 +129,9 @@ fn main() {
     const WHOKNOWSQUUX: WhoKnows<Quux> = WhoKnows::Yay(quux);
 
     match WHOKNOWSQUUX {
-        WHOKNOWSQUUX => {} //~WARN behave unpredictably
+        WHOKNOWSQUUX => {} //~ERROR behave unpredictably
-        //~| previously accepted
         WhoKnows::Yay(_) => {}
-        WHOKNOWSQUUX => {} //~WARN behave unpredictably
+        WHOKNOWSQUUX => {} //~ERROR behave unpredictably
-        //~| previously accepted
         WhoKnows::Nope => {}
     }
 }

tests/ui/pattern/usefulness/consts-opaque.stderr

@@ -1,75 +1,50 @@
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
   --> $DIR/consts-opaque.rs:96:9
    |
 LL |         QUUX => {}
    |         ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:98:9
+  --> $DIR/consts-opaque.rs:97:9
    |
 LL |         QUUX => {}
    |         ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:108:9
+  --> $DIR/consts-opaque.rs:106:9
    |
 LL |         WRAPQUUX => {}
    |         ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:110:9
+  --> $DIR/consts-opaque.rs:107:9
    |
 LL |         WRAPQUUX => {}
    |         ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:117:9
+  --> $DIR/consts-opaque.rs:113:9
    |
 LL |         WRAPQUUX => {}
    |         ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:127:9
+  --> $DIR/consts-opaque.rs:121:9
    |
 LL |         WRAPQUUX => {}
    |         ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:139:9
+  --> $DIR/consts-opaque.rs:132:9
    |
 LL |         WHOKNOWSQUUX => {}
    |         ^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:142:9
+  --> $DIR/consts-opaque.rs:134:9
    |
 LL |         WHOKNOWSQUUX => {}
    |         ^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
 error: unreachable pattern
   --> $DIR/consts-opaque.rs:48:9
@@ -146,111 +121,5 @@ error: unreachable pattern
 LL |         _ => {} // should not be emitting unreachable warning
    |         ^
 
-error[E0004]: non-exhaustive patterns: `Wrap(_)` not covered
+error: aborting due to 17 previous errors
-  --> $DIR/consts-opaque.rs:125:11
-   |
-LL |     match WRAPQUUX {
-   |           ^^^^^^^^ pattern `Wrap(_)` not covered
-   |
-note: `Wrap<fn(usize, usize) -> usize>` defined here
-  --> $DIR/consts-opaque.rs:104:12
-   |
-LL |     struct Wrap<T>(T);
-   |            ^^^^
-   = note: the matched value is of type `Wrap<fn(usize, usize) -> usize>`
-help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
-   |
-LL |         WRAPQUUX => {}, Wrap(_) => todo!()
-   |                       ++++++++++++++++++++
-
-error: aborting due to 10 previous errors; 8 warnings emitted
-
-For more information about this error, try `rustc --explain E0004`.
-Future incompatibility report: Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:96:9
-   |
-LL |         QUUX => {}
-   |         ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:98:9
-   |
-LL |         QUUX => {}
-   |         ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:108:9
-   |
-LL |         WRAPQUUX => {}
-   |         ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:110:9
-   |
-LL |         WRAPQUUX => {}
-   |         ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:117:9
-   |
-LL |         WRAPQUUX => {}
-   |         ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:127:9
-   |
-LL |         WRAPQUUX => {}
-   |         ^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:139:9
-   |
-LL |         WHOKNOWSQUUX => {}
-   |         ^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/consts-opaque.rs:142:9
-   |
-LL |         WHOKNOWSQUUX => {}
-   |         ^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
 

tests/ui/raw-ref-op/const-eval-compare-ice-105047.rs

@@ -1,15 +0,0 @@
-// issue: rust-lang/rust#105047
-// ICE raw ptr comparison should already be caught in the trait systems
-
-#![feature(raw_ref_op)]
-
-const RCZ: *const i32 = &raw const *&0;
-
-const fn f() {
-    if let RCZ = &raw const *&0 { }
-    //~^ WARN function pointers and raw pointers not derived from integers in patterns
-    //~| ERROR pointers cannot be reliably compared during const eval
-    //~| WARN this was previously accepted by the compiler but is being phased out
-}
-
-fn main() {}

tests/ui/raw-ref-op/const-eval-compare-ice-105047.stderr

@@ -1,31 +0,0 @@
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/const-eval-compare-ice-105047.rs:9:12
-   |
-LL |     if let RCZ = &raw const *&0 { }
-   |            ^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-error: pointers cannot be reliably compared during const eval
-  --> $DIR/const-eval-compare-ice-105047.rs:9:12
-   |
-LL |     if let RCZ = &raw const *&0 { }
-   |            ^^^
-   |
-   = note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
-
-error: aborting due to 1 previous error; 1 warning emitted
-
-Future incompatibility report: Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/const-eval-compare-ice-105047.rs:9:12
-   |
-LL |     if let RCZ = &raw const *&0 { }
-   |            ^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/allow-hide-behind-direct-unsafe-ptr-embedded.rs

@@ -1,26 +0,0 @@
-// Test explores how `#[structral_match]` behaves in tandem with
-// `*const` and `*mut` pointers.
-
-//@ run-pass
-
-#![warn(pointer_structural_match)]
-
-struct NoDerive(#[allow(dead_code)] i32);
-
-// This impl makes NoDerive irreflexive
-// (which doesn't matter here because `<*const T>::eq` won't recur on `T`).
-impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
-
-impl Eq for NoDerive { }
-
-#[derive(PartialEq, Eq)]
-struct WrapEmbedded(*const NoDerive);
-
-const WRAP_UNSAFE_EMBEDDED: WrapEmbedded = WrapEmbedded(std::ptr::null());
-
-fn main() {
-    match WRAP_UNSAFE_EMBEDDED {
-        WRAP_UNSAFE_EMBEDDED => { println!("WRAP_UNSAFE_EMBEDDED correctly matched itself"); }
-        _ => { panic!("WRAP_UNSAFE_EMBEDDED did not match itself"); }
-    }
-}

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/allow-hide-behind-direct-unsafe-ptr-param.rs

@@ -1,26 +0,0 @@
-// Test explores how `#[structral_match]` behaves in tandem with
-// `*const` and `*mut` pointers.
-
-//@ run-pass
-
-#![warn(pointer_structural_match)]
-
-struct NoDerive(#[allow(dead_code)] i32);
-
-// This impl makes NoDerive irreflexive
-// (which doesn't matter here because `<*const T>::eq` won't recur on `T`).
-impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
-
-impl Eq for NoDerive { }
-
-#[derive(PartialEq, Eq)]
-struct WrapParam<X>(*const X);
-
-const WRAP_UNSAFE_PARAM: WrapParam<NoDerive> = WrapParam(std::ptr::null());
-
-fn main() {
-    match WRAP_UNSAFE_PARAM {
-        WRAP_UNSAFE_PARAM => { println!("WRAP_UNSAFE_PARAM correctly matched itself"); }
-        _ => { panic!("WRAP_UNSAFE_PARAM did not match itself"); }
-    }
-}

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/allow-hide-behind-indirect-unsafe-ptr-embedded.rs

@@ -1,26 +0,0 @@
-// Test explores how `#[structral_match]` behaves in tandem with
-// `*const` and `*mut` pointers.
-
-//@ run-pass
-
-#![warn(pointer_structural_match)]
-
-struct NoDerive(#[allow(dead_code)] i32);
-
-// This impl makes NoDerive irreflexive
-// (which doesn't matter here because `<*const T>::eq` won't recur on `T`).
-impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
-
-impl Eq for NoDerive { }
-
-#[derive(PartialEq, Eq)]
-struct WrapEmbedded(*const NoDerive);
-
-const WRAP_UNSAFE_EMBEDDED: & &WrapEmbedded = & &WrapEmbedded(std::ptr::null());
-
-fn main() {
-    match WRAP_UNSAFE_EMBEDDED {
-        WRAP_UNSAFE_EMBEDDED => { println!("WRAP_UNSAFE_EMBEDDED correctly matched itself"); }
-        _ => { panic!("WRAP_UNSAFE_EMBEDDED did not match itself"); }
-    }
-}

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/allow-hide-behind-indirect-unsafe-ptr-param.rs

@@ -1,26 +0,0 @@
-// Test explores how `#[structral_match]` behaves in tandem with
-// `*const` and `*mut` pointers.
-
-//@ run-pass
-
-#![warn(pointer_structural_match)]
-
-struct NoDerive(#[allow(dead_code)] i32);
-
-// This impl makes NoDerive irreflexive
-// (which doesn't matter here because `<*const T>::eq` won't recur on `T`).
-impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
-
-impl Eq for NoDerive { }
-
-#[derive(PartialEq, Eq)]
-struct WrapParam<X>(*const X);
-
-const WRAP_UNSAFE_PARAM: & &WrapParam<NoDerive> = & &WrapParam(std::ptr::null());
-
-fn main() {
-    match WRAP_UNSAFE_PARAM {
-        WRAP_UNSAFE_PARAM => { println!("WRAP_UNSAFE_PARAM correctly matched itself"); }
-        _ => { panic!("WRAP_UNSAFE_PARAM did not match itself"); }
-    }
-}

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.rs

@@ -4,7 +4,6 @@
 // through that we had intended to reject.
 //
 // See discussion on rust-lang/rust#62307 and rust-lang/rust#62339
-#![warn(indirect_structural_match)]
 struct NoDerive(i32);
 
 // This impl makes NoDerive irreflexive.

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-direct-struct-param.stderr

@@ -1,5 +1,5 @@
 error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-direct-struct-param.rs:22:9
+  --> $DIR/cant-hide-behind-direct-struct-param.rs:21:9
    |
 LL |         WRAP_DIRECT_PARAM => { panic!("WRAP_DIRECT_PARAM matched itself"); }
    |         ^^^^^^^^^^^^^^^^^

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-embedded.rs

@@ -4,8 +4,6 @@
 // through that we had intended to reject.
 //
 // See discussion on rust-lang/rust#62307 and rust-lang/rust#62339
-#![warn(indirect_structural_match)]
-//@ run-pass
 
 struct NoDerive(#[allow(dead_code)] i32);
 
@@ -22,8 +20,7 @@ const WRAP_DOUBLY_INDIRECT_INLINE: & &WrapInline = & &WrapInline(& & NoDerive(0)
 fn main() {
     match WRAP_DOUBLY_INDIRECT_INLINE {
         WRAP_DOUBLY_INDIRECT_INLINE => { panic!("WRAP_DOUBLY_INDIRECT_INLINE matched itself"); }
-        //~^ WARN must be annotated with `#[derive(PartialEq)]`
+        //~^ ERROR must be annotated with `#[derive(PartialEq)]`
-        //~| WARN this was previously accepted
         _ => { println!("WRAP_DOUBLY_INDIRECT_INLINE correctly did not match itself"); }
     }
 }

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-embedded.stderr

@@ -1,35 +1,11 @@
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
+error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-doubly-indirect-embedded.rs:24:9
+  --> $DIR/cant-hide-behind-doubly-indirect-embedded.rs:22:9
    |
 LL |         WRAP_DOUBLY_INDIRECT_INLINE => { panic!("WRAP_DOUBLY_INDIRECT_INLINE matched itself"); }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/cant-hide-behind-doubly-indirect-embedded.rs:7:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: 1 warning emitted
+error: aborting due to 1 previous error
-
-Future incompatibility report: Future breakage diagnostic:
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-doubly-indirect-embedded.rs:24:9
-   |
-LL |         WRAP_DOUBLY_INDIRECT_INLINE => { panic!("WRAP_DOUBLY_INDIRECT_INLINE matched itself"); }
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: the traits must be derived, manual `impl`s are not sufficient
-   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/cant-hide-behind-doubly-indirect-embedded.rs:7:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-param.rs

@@ -4,8 +4,6 @@
 // through that we had intended to reject.
 //
 // See discussion on rust-lang/rust#62307 and rust-lang/rust#62339
-#![warn(indirect_structural_match)]
-//@ run-pass
 
 struct NoDerive(#[allow(dead_code)] i32);
 
@@ -22,8 +20,7 @@ const WRAP_DOUBLY_INDIRECT_PARAM: & &WrapParam<NoDerive> = & &WrapParam(& & NoDe
 fn main() {
     match WRAP_DOUBLY_INDIRECT_PARAM {
         WRAP_DOUBLY_INDIRECT_PARAM => { panic!("WRAP_DOUBLY_INDIRECT_PARAM matched itself"); }
-        //~^ WARN must be annotated with `#[derive(PartialEq)]`
+        //~^ ERROR must be annotated with `#[derive(PartialEq)]`
-        //~| WARN this was previously accepted
         _ => { println!("WRAP_DOUBLY_INDIRECT_PARAM correctly did not match itself"); }
     }
 }

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-doubly-indirect-param.stderr

@@ -1,35 +1,11 @@
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
+error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-doubly-indirect-param.rs:24:9
+  --> $DIR/cant-hide-behind-doubly-indirect-param.rs:22:9
    |
 LL |         WRAP_DOUBLY_INDIRECT_PARAM => { panic!("WRAP_DOUBLY_INDIRECT_PARAM matched itself"); }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/cant-hide-behind-doubly-indirect-param.rs:7:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: 1 warning emitted
+error: aborting due to 1 previous error
-
-Future incompatibility report: Future breakage diagnostic:
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-doubly-indirect-param.rs:24:9
-   |
-LL |         WRAP_DOUBLY_INDIRECT_PARAM => { panic!("WRAP_DOUBLY_INDIRECT_PARAM matched itself"); }
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: the traits must be derived, manual `impl`s are not sufficient
-   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/cant-hide-behind-doubly-indirect-param.rs:7:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-embedded.rs

@@ -4,8 +4,6 @@
 // through that we had intended to reject.
 //
 // See discussion on rust-lang/rust#62307 and rust-lang/rust#62339
-#![warn(indirect_structural_match)]
-//@ run-pass
 
 struct NoDerive(#[allow(dead_code)] i32);
 
@@ -22,8 +20,7 @@ const WRAP_INDIRECT_INLINE: & &WrapInline = & &WrapInline(NoDerive(0));
 fn main() {
     match WRAP_INDIRECT_INLINE {
         WRAP_INDIRECT_INLINE => { panic!("WRAP_INDIRECT_INLINE matched itself"); }
-        //~^ WARN must be annotated with `#[derive(PartialEq)]`
+        //~^ ERROR must be annotated with `#[derive(PartialEq)]`
-        //~| WARN this was previously accepted
         _ => { println!("WRAP_INDIRECT_INLINE did not match itself"); }
     }
 }

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-embedded.stderr

@@ -1,35 +1,11 @@
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
+error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-indirect-struct-embedded.rs:24:9
+  --> $DIR/cant-hide-behind-indirect-struct-embedded.rs:22:9
    |
 LL |         WRAP_INDIRECT_INLINE => { panic!("WRAP_INDIRECT_INLINE matched itself"); }
    |         ^^^^^^^^^^^^^^^^^^^^
    |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/cant-hide-behind-indirect-struct-embedded.rs:7:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: 1 warning emitted
+error: aborting due to 1 previous error
-
-Future incompatibility report: Future breakage diagnostic:
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-indirect-struct-embedded.rs:24:9
-   |
-LL |         WRAP_INDIRECT_INLINE => { panic!("WRAP_INDIRECT_INLINE matched itself"); }
-   |         ^^^^^^^^^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: the traits must be derived, manual `impl`s are not sufficient
-   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/cant-hide-behind-indirect-struct-embedded.rs:7:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-param.rs

@@ -4,8 +4,6 @@
 // through that we had intended to reject.
 //
 // See discussion on rust-lang/rust#62307 and rust-lang/rust#62339
-#![warn(indirect_structural_match)]
-//@ run-pass
 
 struct NoDerive(#[allow(dead_code)] i32);
 
@@ -22,8 +20,7 @@ const WRAP_INDIRECT_PARAM: & &WrapParam<NoDerive> = & &WrapParam(NoDerive(0));
 fn main() {
     match WRAP_INDIRECT_PARAM {
         WRAP_INDIRECT_PARAM => { panic!("WRAP_INDIRECT_PARAM matched itself"); }
-        //~^ WARN must be annotated with `#[derive(PartialEq)]`
+        //~^ ERROR must be annotated with `#[derive(PartialEq)]`
-        //~| WARN this was previously accepted
         _ => { println!("WRAP_INDIRECT_PARAM correctly did not match itself"); }
     }
 }

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/cant-hide-behind-indirect-struct-param.stderr

@@ -1,35 +1,11 @@
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
+error: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-indirect-struct-param.rs:24:9
+  --> $DIR/cant-hide-behind-indirect-struct-param.rs:22:9
    |
 LL |         WRAP_INDIRECT_PARAM => { panic!("WRAP_INDIRECT_PARAM matched itself"); }
    |         ^^^^^^^^^^^^^^^^^^^
    |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/cant-hide-behind-indirect-struct-param.rs:7:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: 1 warning emitted
+error: aborting due to 1 previous error
-
-Future incompatibility report: Future breakage diagnostic:
-warning: to use a constant of type `NoDerive` in a pattern, `NoDerive` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/cant-hide-behind-indirect-struct-param.rs:24:9
-   |
-LL |         WRAP_INDIRECT_PARAM => { panic!("WRAP_INDIRECT_PARAM matched itself"); }
-   |         ^^^^^^^^^^^^^^^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: the traits must be derived, manual `impl`s are not sufficient
-   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/cant-hide-behind-indirect-struct-param.rs:7:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/fn-ptr-is-not-structurally-matchable.rs

@@ -1,7 +1,5 @@
-//@ run-pass
+// This file checks that fn ptrs are *not* considered structurally matchable.
-
+// See also rust-lang/rust#63479 and RFC 3535.
-// This file checks that fn ptrs are considered structurally matchable.
-// See also rust-lang/rust#63479.
 
 fn main() {
     let mut count = 0;
@@ -40,8 +38,7 @@ fn main() {
     const CFN1: Wrap<fn()> = Wrap(trivial);
     let input: Wrap<fn()> = Wrap(trivial);
     match Wrap(input) {
-        Wrap(CFN1) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN1) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -49,8 +46,7 @@ fn main() {
     const CFN2: Wrap<fn(SM)> = Wrap(sm_to);
     let input: Wrap<fn(SM)> = Wrap(sm_to);
     match Wrap(input) {
-        Wrap(CFN2) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN2) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -58,8 +54,7 @@ fn main() {
     const CFN3: Wrap<fn() -> SM> = Wrap(to_sm);
     let input: Wrap<fn() -> SM> = Wrap(to_sm);
     match Wrap(input) {
-        Wrap(CFN3) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN3) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -67,8 +62,7 @@ fn main() {
     const CFN4: Wrap<fn(NotSM)> = Wrap(not_sm_to);
     let input: Wrap<fn(NotSM)> = Wrap(not_sm_to);
     match Wrap(input) {
-        Wrap(CFN4) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN4) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -76,8 +70,7 @@ fn main() {
     const CFN5: Wrap<fn() -> NotSM> = Wrap(to_not_sm);
     let input: Wrap<fn() -> NotSM> = Wrap(to_not_sm);
     match Wrap(input) {
-        Wrap(CFN5) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN5) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -85,8 +78,7 @@ fn main() {
     const CFN6: Wrap<fn(&SM)> = Wrap(r_sm_to);
     let input: Wrap<fn(&SM)> = Wrap(r_sm_to);
     match Wrap(input) {
-        Wrap(CFN6) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN6) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -94,8 +86,7 @@ fn main() {
     const CFN7: Wrap<fn(&()) -> &SM> = Wrap(r_to_r_sm);
     let input: Wrap<fn(&()) -> &SM> = Wrap(r_to_r_sm);
     match Wrap(input) {
-        Wrap(CFN7) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN7) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -103,8 +94,7 @@ fn main() {
     const CFN8: Wrap<fn(&NotSM)> = Wrap(r_not_sm_to);
     let input: Wrap<fn(&NotSM)> = Wrap(r_not_sm_to);
     match Wrap(input) {
-        Wrap(CFN8) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN8) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -112,8 +102,7 @@ fn main() {
     const CFN9: Wrap<fn(&()) -> &NotSM> = Wrap(r_to_r_not_sm);
     let input: Wrap<fn(&()) -> &NotSM> = Wrap(r_to_r_not_sm);
     match Wrap(input) {
-        Wrap(CFN9) => count += 1, //~WARN behave unpredictably
+        Wrap(CFN9) => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Wrap(_) => {}
     };
 
@@ -135,8 +124,7 @@ fn main() {
 
     let input = Foo { alpha: not_sm_to, beta: to_not_sm, gamma: sm_to, delta: to_sm };
     match input {
-        CFOO => count += 1, //~WARN behave unpredictably
+        CFOO => count += 1, //~ERROR behave unpredictably
-        //~| previously accepted
         Foo { .. } => {}
     };
 

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/fn-ptr-is-not-structurally-matchable.stderr

@@ -0,0 +1,62 @@
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:41:14
+   |
+LL |         Wrap(CFN1) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:49:14
+   |
+LL |         Wrap(CFN2) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:57:14
+   |
+LL |         Wrap(CFN3) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:65:14
+   |
+LL |         Wrap(CFN4) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:73:14
+   |
+LL |         Wrap(CFN5) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:81:14
+   |
+LL |         Wrap(CFN6) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:89:14
+   |
+LL |         Wrap(CFN7) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:97:14
+   |
+LL |         Wrap(CFN8) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:105:14
+   |
+LL |         Wrap(CFN9) => count += 1,
+   |              ^^^^
+
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+  --> $DIR/fn-ptr-is-not-structurally-matchable.rs:127:9
+   |
+LL |         CFOO => count += 1,
+   |         ^^^^
+
+error: aborting due to 10 previous errors
+

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/fn-ptr-is-structurally-matchable.stderr

@@ -1,203 +0,0 @@
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:43:14
-   |
-LL |         Wrap(CFN1) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:52:14
-   |
-LL |         Wrap(CFN2) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:61:14
-   |
-LL |         Wrap(CFN3) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:70:14
-   |
-LL |         Wrap(CFN4) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:79:14
-   |
-LL |         Wrap(CFN5) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:88:14
-   |
-LL |         Wrap(CFN6) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:97:14
-   |
-LL |         Wrap(CFN7) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:106:14
-   |
-LL |         Wrap(CFN8) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:115:14
-   |
-LL |         Wrap(CFN9) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:138:9
-   |
-LL |         CFOO => count += 1,
-   |         ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-
-warning: 10 warnings emitted
-
-Future incompatibility report: Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:43:14
-   |
-LL |         Wrap(CFN1) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:52:14
-   |
-LL |         Wrap(CFN2) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:61:14
-   |
-LL |         Wrap(CFN3) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:70:14
-   |
-LL |         Wrap(CFN4) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:79:14
-   |
-LL |         Wrap(CFN5) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:88:14
-   |
-LL |         Wrap(CFN6) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:97:14
-   |
-LL |         Wrap(CFN7) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:106:14
-   |
-LL |         Wrap(CFN8) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:115:14
-   |
-LL |         Wrap(CFN9) => count += 1,
-   |              ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/fn-ptr-is-structurally-matchable.rs:138:9
-   |
-LL |         CFOO => count += 1,
-   |         ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: `#[warn(pointer_structural_match)]` on by default
-

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-62307-match-ref-ref-forbidden-without-eq.rs

@@ -10,8 +10,6 @@
 
 // Issue 62307 pointed out a case where the structural-match checking
 // was too shallow.
-#![warn(indirect_structural_match)]
-//@ run-pass
 
 #[derive(Debug)]
 struct B(i32);
@@ -29,15 +27,13 @@ fn main() {
 
     match RR_B0 {
         RR_B1 => { println!("CLAIM RR0: {:?} matches {:?}", RR_B1, RR_B0); }
-        //~^ WARN must be annotated with `#[derive(PartialEq)]`
+        //~^ ERROR must be annotated with `#[derive(PartialEq)]`
-        //~| WARN this was previously accepted
         _ => { }
     }
 
     match RR_B1 {
         RR_B1 => { println!("CLAIM RR1: {:?} matches {:?}", RR_B1, RR_B1); }
-        //~^ WARN must be annotated with `#[derive(PartialEq)]`
+        //~^ ERROR must be annotated with `#[derive(PartialEq)]`
-        //~| WARN this was previously accepted
         _ => { }
     }
 }

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-62307-match-ref-ref-forbidden-without-eq.stderr

@@ -1,63 +1,20 @@
-warning: to use a constant of type `B` in a pattern, `B` must be annotated with `#[derive(PartialEq)]`
+error: to use a constant of type `B` in a pattern, `B` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:31:9
+  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:29:9
    |
 LL |         RR_B1 => { println!("CLAIM RR0: {:?} matches {:?}", RR_B1, RR_B0); }
    |         ^^^^^
    |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:13:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: to use a constant of type `B` in a pattern, `B` must be annotated with `#[derive(PartialEq)]`
+error: to use a constant of type `B` in a pattern, `B` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:38:9
+  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:35:9
    |
 LL |         RR_B1 => { println!("CLAIM RR1: {:?} matches {:?}", RR_B1, RR_B1); }
    |         ^^^^^
    |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
 
-warning: 2 warnings emitted
+error: aborting due to 2 previous errors
-
-Future incompatibility report: Future breakage diagnostic:
-warning: to use a constant of type `B` in a pattern, `B` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:31:9
-   |
-LL |         RR_B1 => { println!("CLAIM RR0: {:?} matches {:?}", RR_B1, RR_B0); }
-   |         ^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: the traits must be derived, manual `impl`s are not sufficient
-   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:13:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Future breakage diagnostic:
-warning: to use a constant of type `B` in a pattern, `B` must be annotated with `#[derive(PartialEq)]`
-  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:38:9
-   |
-LL |         RR_B1 => { println!("CLAIM RR1: {:?} matches {:?}", RR_B1, RR_B1); }
-   |         ^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-   = note: the traits must be derived, manual `impl`s are not sufficient
-   = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details
-note: the lint level is defined here
-  --> $DIR/issue-62307-match-ref-ref-forbidden-without-eq.rs:13:9
-   |
-LL | #![warn(indirect_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-63479-match-fnptr.rs

@@ -1,12 +1,8 @@
-//@ run-pass
-
 // The actual regression test from #63479. (Including this because my
 // first draft at fn-ptr-is-structurally-matchable.rs failed to actually
 // cover the case this hit; I've since expanded it accordingly, but the
 // experience left me wary of leaving this regression test out.)
 
-#![warn(pointer_structural_match)]
-
 #[derive(Eq)]
 struct A {
   a: i64
@@ -34,14 +30,12 @@ fn main() {
   let s = B(my_fn);
   match s {
     B(TEST) => println!("matched"),
-    //~^ WARN behave unpredictably
+    //~^ ERROR behave unpredictably
-    //~| WARN this was previously accepted by the compiler but is being phased out
     _ => panic!("didn't match")
   };
   match (s.0, 0) {
     TEST2 => println!("matched"),
-    //~^ WARN behave unpredictably
+    //~^ ERROR behave unpredictably
-    //~| WARN this was previously accepted by the compiler but is being phased out
     _ => panic!("didn't match")
   }
 }

tests/ui/rfcs/rfc-1445-restrict-constants-in-patterns/issue-63479-match-fnptr.stderr

@@ -1,55 +1,14 @@
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-63479-match-fnptr.rs:36:7
+  --> $DIR/issue-63479-match-fnptr.rs:32:7
    |
 LL |     B(TEST) => println!("matched"),
    |       ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-63479-match-fnptr.rs:8:9
-   |
-LL | #![warn(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
+error: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-63479-match-fnptr.rs:42:5
+  --> $DIR/issue-63479-match-fnptr.rs:37:5
    |
 LL |     TEST2 => println!("matched"),
    |     ^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
 
-warning: 2 warnings emitted
+error: aborting due to 2 previous errors
-
-Future incompatibility report: Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-63479-match-fnptr.rs:36:7
-   |
-LL |     B(TEST) => println!("matched"),
-   |       ^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-63479-match-fnptr.rs:8:9
-   |
-LL | #![warn(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^
-
-Future breakage diagnostic:
-warning: function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon. See https://github.com/rust-lang/rust/issues/70861 for details.
-  --> $DIR/issue-63479-match-fnptr.rs:42:5
-   |
-LL |     TEST2 => println!("matched"),
-   |     ^^^^^
-   |
-   = 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 #120362 <https://github.com/rust-lang/rust/issues/120362>
-note: the lint level is defined here
-  --> $DIR/issue-63479-match-fnptr.rs:8:9
-   |
-LL | #![warn(pointer_structural_match)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^