Skip to content

Commit 5fe5543

Browse files
borsbors
committed
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 #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 #70861
2 parents bd184cc + cbd682b commit 5fe5543

File tree

50 files changed

+185
-1209
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

50 files changed

+185
-1209
lines changed

‎compiler/rustc_lint/src/lib.rs

+10
Original file line numberDiff line numberDiff line change
@@ -539,6 +539,16 @@ fn register_builtins(store: &mut LintStore) {
539539
"converted into hard error, see RFC #3535 \
540540
<https://rust-lang.github.io/rfcs/3535-constants-in-patterns.html> for more information",
541541
);
542+
store.register_removed(
543+
"indirect_structural_match",
544+
"converted into hard error, see RFC #3535 \
545+
<https://rust-lang.github.io/rfcs/3535-constants-in-patterns.html> for more information",
546+
);
547+
store.register_removed(
548+
"pointer_structural_match",
549+
"converted into hard error, see RFC #3535 \
550+
<https://rust-lang.github.io/rfcs/3535-constants-in-patterns.html> for more information",
551+
);
542552
}
543553

544554
fn register_internals(store: &mut LintStore) {

‎compiler/rustc_lint_defs/src/builtin.rs

-87
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,6 @@ declare_lint_pass! {
4949
HIDDEN_GLOB_REEXPORTS,
5050
ILL_FORMED_ATTRIBUTE_INPUT,
5151
INCOMPLETE_INCLUDE,
52-
INDIRECT_STRUCTURAL_MATCH,
5352
INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
5453
INLINE_NO_SANITIZE,
5554
INVALID_DOC_ATTRIBUTES,
@@ -74,7 +73,6 @@ declare_lint_pass! {
7473
ORDER_DEPENDENT_TRAIT_OBJECTS,
7574
OVERLAPPING_RANGE_ENDPOINTS,
7675
PATTERNS_IN_FNS_WITHOUT_BODY,
77-
POINTER_STRUCTURAL_MATCH,
7876
PRIVATE_BOUNDS,
7977
PRIVATE_INTERFACES,
8078
PROC_MACRO_BACK_COMPAT,
@@ -2351,52 +2349,6 @@ declare_lint! {
23512349
"outlives requirements can be inferred"
23522350
}
23532351

2354-
declare_lint! {
2355-
/// The `indirect_structural_match` lint detects a `const` in a pattern
2356-
/// that manually implements [`PartialEq`] and [`Eq`].
2357-
///
2358-
/// [`PartialEq`]: https://doc.rust-lang.org/std/cmp/trait.PartialEq.html
2359-
/// [`Eq`]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
2360-
///
2361-
/// ### Example
2362-
///
2363-
/// ```rust,compile_fail
2364-
/// #![deny(indirect_structural_match)]
2365-
///
2366-
/// struct NoDerive(i32);
2367-
/// impl PartialEq for NoDerive { fn eq(&self, _: &Self) -> bool { false } }
2368-
/// impl Eq for NoDerive { }
2369-
/// #[derive(PartialEq, Eq)]
2370-
/// struct WrapParam<T>(T);
2371-
/// const WRAP_INDIRECT_PARAM: & &WrapParam<NoDerive> = & &WrapParam(NoDerive(0));
2372-
/// fn main() {
2373-
/// match WRAP_INDIRECT_PARAM {
2374-
/// WRAP_INDIRECT_PARAM => { }
2375-
/// _ => { }
2376-
/// }
2377-
/// }
2378-
/// ```
2379-
///
2380-
/// {{produces}}
2381-
///
2382-
/// ### Explanation
2383-
///
2384-
/// The compiler unintentionally accepted this form in the past. This is a
2385-
/// [future-incompatible] lint to transition this to a hard error in the
2386-
/// future. See [issue #62411] for a complete description of the problem,
2387-
/// and some possible solutions.
2388-
///
2389-
/// [issue #62411]: https://github.com/rust-lang/rust/issues/62411
2390-
/// [future-incompatible]: ../index.md#future-incompatible-lints
2391-
pub INDIRECT_STRUCTURAL_MATCH,
2392-
Warn,
2393-
"constant used in pattern contains value of non-structural-match type in a field or a variant",
2394-
@future_incompatible = FutureIncompatibleInfo {
2395-
reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
2396-
reference: "issue #120362 <https://github.com/rust-lang/rust/issues/120362>",
2397-
};
2398-
}
2399-
24002352
declare_lint! {
24012353
/// The `deprecated_in_future` lint is internal to rustc and should not be
24022354
/// used by user code.
@@ -2414,45 +2366,6 @@ declare_lint! {
24142366
report_in_external_macro
24152367
}
24162368

2417-
declare_lint! {
2418-
/// The `pointer_structural_match` lint detects pointers used in patterns whose behaviour
2419-
/// cannot be relied upon across compiler versions and optimization levels.
2420-
///
2421-
/// ### Example
2422-
///
2423-
/// ```rust,compile_fail
2424-
/// #![deny(pointer_structural_match)]
2425-
/// fn foo(a: usize, b: usize) -> usize { a + b }
2426-
/// const FOO: fn(usize, usize) -> usize = foo;
2427-
/// fn main() {
2428-
/// match FOO {
2429-
/// FOO => {},
2430-
/// _ => {},
2431-
/// }
2432-
/// }
2433-
/// ```
2434-
///
2435-
/// {{produces}}
2436-
///
2437-
/// ### Explanation
2438-
///
2439-
/// Previous versions of Rust allowed function pointers and all raw pointers in patterns.
2440-
/// While these work in many cases as expected by users, it is possible that due to
2441-
/// optimizations pointers are "not equal to themselves" or pointers to different functions
2442-
/// compare as equal during runtime. This is because LLVM optimizations can deduplicate
2443-
/// functions if their bodies are the same, thus also making pointers to these functions point
2444-
/// to the same location. Additionally functions may get duplicated if they are instantiated
2445-
/// in different crates and not deduplicated again via LTO. Pointer identity for memory
2446-
/// created by `const` is similarly unreliable.
2447-
pub POINTER_STRUCTURAL_MATCH,
2448-
Warn,
2449-
"pointers are not structural-match",
2450-
@future_incompatible = FutureIncompatibleInfo {
2451-
reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
2452-
reference: "issue #120362 <https://github.com/rust-lang/rust/issues/120362>",
2453-
};
2454-
}
2455-
24562369
declare_lint! {
24572370
/// The `ambiguous_associated_items` lint detects ambiguity between
24582371
/// [associated items] and [enum variants].

‎compiler/rustc_mir_build/messages.ftl

-6
Original file line numberDiff line numberDiff line change
@@ -109,9 +109,6 @@ mir_build_extern_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
109109
.note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
110110
.label = use of extern static
111111
112-
mir_build_indirect_structural_match =
113-
to use a constant of type `{$non_sm_ty}` in a pattern, `{$non_sm_ty}` must be annotated with `#[derive(PartialEq)]`
114-
115112
mir_build_inform_irrefutable = `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
116113
117114
mir_build_initializing_type_with_requires_unsafe =
@@ -257,9 +254,6 @@ mir_build_non_exhaustive_patterns_type_not_empty = non-exhaustive patterns: type
257254
mir_build_non_partial_eq_match =
258255
to use a constant of type `{$non_peq_ty}` in a pattern, the type must implement `PartialEq`
259256
260-
mir_build_nontrivial_structural_match =
261-
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)]`
262-
263257
mir_build_pattern_not_covered = refutable pattern in {$origin}
264258
.pattern_ty = the matched value is of type `{$pattern_ty}`
265259

‎compiler/rustc_mir_build/src/errors.rs

+5-18
Original file line numberDiff line numberDiff line change
@@ -794,9 +794,12 @@ pub struct NaNPattern {
794794
pub span: Span,
795795
}
796796

797-
#[derive(LintDiagnostic)]
797+
#[derive(Diagnostic)]
798798
#[diag(mir_build_pointer_pattern)]
799-
pub struct PointerPattern;
799+
pub struct PointerPattern {
800+
#[primary_span]
801+
pub span: Span,
802+
}
800803

801804
#[derive(Diagnostic)]
802805
#[diag(mir_build_non_empty_never_pattern)]
@@ -808,22 +811,6 @@ pub struct NonEmptyNeverPattern<'tcx> {
808811
pub ty: Ty<'tcx>,
809812
}
810813

811-
#[derive(LintDiagnostic)]
812-
#[diag(mir_build_indirect_structural_match)]
813-
#[note(mir_build_type_not_structural_tip)]
814-
#[note(mir_build_type_not_structural_more_info)]
815-
pub struct IndirectStructuralMatch<'tcx> {
816-
pub non_sm_ty: Ty<'tcx>,
817-
}
818-
819-
#[derive(LintDiagnostic)]
820-
#[diag(mir_build_nontrivial_structural_match)]
821-
#[note(mir_build_type_not_structural_tip)]
822-
#[note(mir_build_type_not_structural_more_info)]
823-
pub struct NontrivialStructuralMatch<'tcx> {
824-
pub non_sm_ty: Ty<'tcx>,
825-
}
826-
827814
#[derive(Diagnostic)]
828815
#[diag(mir_build_exceeds_mcdc_condition_num_limit)]
829816
pub(crate) struct MCDCExceedsConditionNumLimit {

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

+6-80
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,6 @@ use rustc_middle::mir;
77
use rustc_middle::span_bug;
88
use rustc_middle::thir::{FieldPat, Pat, PatKind};
99
use rustc_middle::ty::{self, Ty, TyCtxt, ValTree};
10-
use rustc_session::lint;
1110
use rustc_span::{ErrorGuaranteed, Span};
1211
use rustc_target::abi::{FieldIdx, VariantIdx};
1312
use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
@@ -18,8 +17,8 @@ use std::cell::Cell;
1817

1918
use super::PatCtxt;
2019
use crate::errors::{
21-
IndirectStructuralMatch, InvalidPattern, NaNPattern, PointerPattern, TypeNotPartialEq,
22-
TypeNotStructural, UnionPattern, UnsizedPattern,
20+
InvalidPattern, NaNPattern, PointerPattern, TypeNotPartialEq, TypeNotStructural, UnionPattern,
21+
UnsizedPattern,
2322
};
2423

2524
impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
@@ -51,15 +50,6 @@ struct ConstToPat<'tcx> {
5150
// value.
5251
saw_const_match_error: Cell<Option<ErrorGuaranteed>>,
5352

54-
// This tracks if we emitted some diagnostic for a given const value, so that
55-
// we will not subsequently issue an irrelevant lint for the same const
56-
// value.
57-
saw_const_match_lint: Cell<bool>,
58-
59-
// For backcompat we need to keep allowing non-structurally-eq types behind references.
60-
// See also all the `cant-hide-behind` tests.
61-
behind_reference: Cell<bool>,
62-
6353
// inference context used for checking `T: Structural` bounds.
6454
infcx: InferCtxt<'tcx>,
6555

@@ -86,8 +76,6 @@ impl<'tcx> ConstToPat<'tcx> {
8676
infcx,
8777
param_env: pat_ctxt.param_env,
8878
saw_const_match_error: Cell::new(None),
89-
saw_const_match_lint: Cell::new(false),
90-
behind_reference: Cell::new(false),
9179
treat_byte_string_as_slice: pat_ctxt
9280
.typeck_results
9381
.treat_byte_string_as_slice
@@ -199,15 +187,12 @@ impl<'tcx> ConstToPat<'tcx> {
199187
// complained about structural match violations there, so we don't
200188
// have to check anything any more.
201189
}
202-
} else if !have_valtree && !self.saw_const_match_lint.get() {
190+
} else if !have_valtree {
203191
// The only way valtree construction can fail without the structural match
204192
// checker finding a violation is if there is a pointer somewhere.
205-
self.tcx().emit_node_span_lint(
206-
lint::builtin::POINTER_STRUCTURAL_MATCH,
207-
self.id,
208-
self.span,
209-
PointerPattern,
210-
);
193+
let e = self.tcx().dcx().emit_err(PointerPattern { span: self.span });
194+
let kind = PatKind::Error(e);
195+
return Box::new(Pat { span: self.span, ty: cv.ty(), kind });
211196
}
212197

213198
// Always check for `PartialEq` if we had no other errors yet.
@@ -276,36 +261,11 @@ impl<'tcx> ConstToPat<'tcx> {
276261
cv: ValTree<'tcx>,
277262
ty: Ty<'tcx>,
278263
) -> Result<Box<Pat<'tcx>>, FallbackToOpaqueConst> {
279-
let id = self.id;
280264
let span = self.span;
281265
let tcx = self.tcx();
282266
let param_env = self.param_env;
283267

284268
let kind = match ty.kind() {
285-
// If the type is not structurally comparable, just emit the constant directly,
286-
// causing the pattern match code to treat it opaquely.
287-
// FIXME: This code doesn't emit errors itself, the caller emits the errors.
288-
// So instead of specific errors, you just get blanket errors about the whole
289-
// const type. See
290-
// https://github.com/rust-lang/rust/pull/70743#discussion_r404701963 for
291-
// details.
292-
// Backwards compatibility hack because we can't cause hard errors on these
293-
// types, so we compare them via `PartialEq::eq` at runtime.
294-
ty::Adt(..) if !self.type_marked_structural(ty) && self.behind_reference.get() => {
295-
if self.saw_const_match_error.get().is_none() && !self.saw_const_match_lint.get() {
296-
self.saw_const_match_lint.set(true);
297-
tcx.emit_node_span_lint(
298-
lint::builtin::INDIRECT_STRUCTURAL_MATCH,
299-
id,
300-
span,
301-
IndirectStructuralMatch { non_sm_ty: ty },
302-
);
303-
}
304-
// Since we are behind a reference, we can just bubble the error up so we get a
305-
// constant at reference type, making it easy to let the fallback call
306-
// `PartialEq::eq` on it.
307-
return Err(FallbackToOpaqueConst);
308-
}
309269
ty::FnDef(..) => {
310270
let e = tcx.dcx().emit_err(InvalidPattern { span, non_sm_ty: ty });
311271
self.saw_const_match_error.set(Some(e));
@@ -379,38 +339,6 @@ impl<'tcx> ConstToPat<'tcx> {
379339
ty::Str => {
380340
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_value(tcx, cv, ty)) }
381341
}
382-
// Backwards compatibility hack: support references to non-structural types,
383-
// but hard error if we aren't behind a double reference. We could just use
384-
// the fallback code path below, but that would allow *more* of this fishy
385-
// code to compile, as then it only goes through the future incompat lint
386-
// instead of a hard error.
387-
ty::Adt(_, _) if !self.type_marked_structural(*pointee_ty) => {
388-
if self.behind_reference.get() {
389-
if self.saw_const_match_error.get().is_none()
390-
&& !self.saw_const_match_lint.get()
391-
{
392-
self.saw_const_match_lint.set(true);
393-
tcx.emit_node_span_lint(
394-
lint::builtin::INDIRECT_STRUCTURAL_MATCH,
395-
self.id,
396-
span,
397-
IndirectStructuralMatch { non_sm_ty: *pointee_ty },
398-
);
399-
}
400-
return Err(FallbackToOpaqueConst);
401-
} else {
402-
if let Some(e) = self.saw_const_match_error.get() {
403-
// We already errored. Signal that in the pattern, so that follow up errors can be silenced.
404-
PatKind::Error(e)
405-
} else {
406-
let err = TypeNotStructural { span, non_sm_ty: *pointee_ty };
407-
let e = tcx.dcx().emit_err(err);
408-
self.saw_const_match_error.set(Some(e));
409-
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
410-
PatKind::Error(e)
411-
}
412-
}
413-
}
414342
// All other references are converted into deref patterns and then recursively
415343
// convert the dereferenced constant to a pattern that is the sub-pattern of the
416344
// deref pattern.
@@ -421,7 +349,6 @@ impl<'tcx> ConstToPat<'tcx> {
421349
// We errored. Signal that in the pattern, so that follow up errors can be silenced.
422350
PatKind::Error(e)
423351
} else {
424-
let old = self.behind_reference.replace(true);
425352
// `b"foo"` produces a `&[u8; 3]`, but you can't use constants of array type when
426353
// matching against references, you can only use byte string literals.
427354
// The typechecker has a special case for byte string literals, by treating them
@@ -436,7 +363,6 @@ impl<'tcx> ConstToPat<'tcx> {
436363
};
437364
// References have the same valtree representation as their pointee.
438365
let subpattern = self.recur(cv, pointee_ty)?;
439-
self.behind_reference.set(old);
440366
PatKind::Deref { subpattern }
441367
}
442368
}

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

+2-4
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,7 @@
22
//@ edition:2021
33

44
const PATTERN_REF: &str = "Hello World";
5-
const NUMBER: i32 = 30;
6-
const NUMBER_POINTER: *const i32 = &NUMBER;
5+
const NUMBER_POINTER: *const i32 = 30 as *const i32;
76

87
pub fn edge_case_ref(event: &str) {
98
let _ = || {
@@ -26,8 +25,7 @@ pub fn edge_case_str(event: String) {
2625
pub fn edge_case_raw_ptr(event: *const i32) {
2726
let _ = || {
2827
match event {
29-
NUMBER_POINTER => (), //~WARN behave unpredictably
30-
//~| previously accepted
28+
NUMBER_POINTER => (),
3129
_ => (),
3230
};
3331
};

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

-23
This file was deleted.

‎tests/ui/consts/const_in_pattern/accept_structural.rs

-1
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
//@ run-pass
22

33
#![allow(non_local_definitions)]
4-
#![warn(indirect_structural_match)]
54

65
// This test is checking our logic for structural match checking by enumerating
76
// the different kinds of const expressions. This test is collecting cases where

0 commit comments

Comments
 (0)