bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

reword pattern migration diagnostic to make sense in all editions

Browse source 
This aligns the main error message a bit more with the phrasing in the
Edition Guide and provides a bit more information on the labels to
(hopefully!) aid in understanding.
This commit is contained in:
dianne 2025-02-03 01:50:14 -08:00
parent 724b885b4e
commit bdc6c4d07b
15 changed files with 224 additions and 196 deletions
Download patch file Download diff file Expand all files Collapse all files

49
compiler/rustc_hir_typeck/src/pat.rs
View file

@ -804,7 +804,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Determine the binding mode...
let bm = match user_bind_annot {
BindingMode(ByRef::No, Mutability::Mut) if matches!(def_br, ByRef::Yes(_)) => {
BindingMode(ByRef::No, Mutability::Mut) if let ByRef::Yes(def_br_mutbl) = def_br => {
// Only mention the experimental `mut_ref` feature if if we're in edition 2024 and
// using other experimental matching features compatible with it.
if pat.span.at_least_rust_2024()
@ -826,22 +826,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// `mut` resets the binding mode on edition <= 2021
self.add_rust_2024_migration_desugared_pat(
pat_info.top_info.hir_id,
pat.span,
pat,
ident.span,
"requires binding by-value, but the implicit default is by-reference",
def_br_mutbl,
);
BindingMode(ByRef::No, Mutability::Mut)
}
}
BindingMode(ByRef::No, mutbl) => BindingMode(def_br, mutbl),
BindingMode(ByRef::Yes(_), _) => {
if matches!(def_br, ByRef::Yes(_)) {
if let ByRef::Yes(def_br_mutbl) = def_br {
// `ref`/`ref mut` overrides the binding mode on edition <= 2021
self.add_rust_2024_migration_desugared_pat(
pat_info.top_info.hir_id,
pat.span,
pat,
ident.span,
"cannot override to bind by-reference when that is the implicit default",
def_br_mutbl,
);
}
user_bind_annot
@ -2378,9 +2378,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pat_info.binding_mode = ByRef::No;
self.add_rust_2024_migration_desugared_pat(
pat_info.top_info.hir_id,
pat.span,
pat,
inner.span,
"cannot implicitly match against multiple layers of reference",
inh_mut,
)
}
}
@ -2770,9 +2770,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn add_rust_2024_migration_desugared_pat(
&self,
pat_id: HirId,
subpat_span: Span,
subpat: &'tcx Pat<'tcx>,
cutoff_span: Span,
detailed_label: &str,
def_br_mutbl: Mutability,
) {
// Try to trim the span we're labeling to just the `&` or binding mode that's an issue.
// If the subpattern's span is is from an expansion, the emitted label will not be trimmed.
@ -2780,23 +2780,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let cutoff_span = source_map
.span_extend_prev_while(cutoff_span, char::is_whitespace)
.unwrap_or(cutoff_span);
// Ensure we use the syntax context and thus edition of `subpat_span`; this will be a hard
// Ensure we use the syntax context and thus edition of `subpat.span`; this will be a hard
// error if the subpattern is of edition >= 2024.
let trimmed_span = subpat_span.until(cutoff_span).with_ctxt(subpat_span.ctxt());
let trimmed_span = subpat.span.until(cutoff_span).with_ctxt(subpat.span.ctxt());
// Only provide a detailed label if the problematic subpattern isn't from an expansion.
// In the case that it's from a macro, we'll add a more detailed note in the emitter.
let desc = if subpat_span.from_expansion() {
"default binding mode is reset within expansion"
let desc = if subpat.span.from_expansion() {
"occurs within expansion"
} else {
detailed_label
match def_br_mutbl {
Mutability::Not => "default binding mode is `ref`",
Mutability::Mut => "default binding mode is `ref mut`",
}
};
self.typeck_results
.borrow_mut()
.rust_2024_migration_desugared_pats_mut()
.entry(pat_id)
.or_default()
.push((trimmed_span, desc.to_owned()));
let mut typeck_results = self.typeck_results.borrow_mut();
let mut table = typeck_results.rust_2024_migration_desugared_pats_mut();
let info = table.entry(pat_id).or_default();
info.labels.push((trimmed_span, desc.to_owned()));
if matches!(subpat.kind, PatKind::Binding(_, _, _, _)) {
info.bad_modifiers |= true;
} else {
info.bad_ref_pats |= true;
}
}
}

2
compiler/rustc_middle/src/ty/mod.rs
View file

@ -94,7 +94,7 @@ pub use self::sty::{
pub use self::trait_def::TraitDef;
pub use self::typeck_results::{
CanonicalUserType, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, IsIdentity,
TypeckResults, UserType, UserTypeAnnotationIndex, UserTypeKind,
Rust2024IncompatiblePatInfo, TypeckResults, UserType, UserTypeAnnotationIndex, UserTypeKind,
};
pub use self::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
use crate::error::{OpaqueHiddenTypeMismatch, TypeMismatchReason};

22
compiler/rustc_middle/src/ty/typeck_results.rs
View file

@ -73,9 +73,9 @@ pub struct TypeckResults<'tcx> {
/// Stores the actual binding mode for all instances of [`BindingMode`].
pat_binding_modes: ItemLocalMap<BindingMode>,
/// Top-level patterns whose match ergonomics need to be desugared by the Rust 2021 -> 2024
/// migration lint. Problematic subpatterns are stored in the `Vec` for the lint to highlight.
rust_2024_migration_desugared_pats: ItemLocalMap<Vec<(Span, String)>>,
/// Top-level patterns incompatible with Rust 2024's match ergonomics. These will be translated
/// to a form valid in all Editions, either as a lint diagnostic or hard error.
rust_2024_migration_desugared_pats: ItemLocalMap<Rust2024IncompatiblePatInfo>,
/// Stores the types which were implicitly dereferenced in pattern binding modes
/// for later usage in THIR lowering. For example,
@ -420,7 +420,7 @@ impl<'tcx> TypeckResults<'tcx> {
pub fn rust_2024_migration_desugared_pats(
&self,
) -> LocalTableInContext<'_, Vec<(Span, String)>> {
) -> LocalTableInContext<'_, Rust2024IncompatiblePatInfo> {
LocalTableInContext {
hir_owner: self.hir_owner,
data: &self.rust_2024_migration_desugared_pats,
@ -429,7 +429,7 @@ impl<'tcx> TypeckResults<'tcx> {
pub fn rust_2024_migration_desugared_pats_mut(
&mut self,
) -> LocalTableInContextMut<'_, Vec<(Span, String)>> {
) -> LocalTableInContextMut<'_, Rust2024IncompatiblePatInfo> {
LocalTableInContextMut {
hir_owner: self.hir_owner,
data: &mut self.rust_2024_migration_desugared_pats,
@ -811,3 +811,15 @@ impl<'tcx> std::fmt::Display for UserTypeKind<'tcx> {
}
}
}
/// Information on a pattern incompatible with Rust 2024, for use by the error/migration diagnostic
/// emitted during THIR construction.
#[derive(TyEncodable, TyDecodable, Debug, HashStable, Default)]
pub struct Rust2024IncompatiblePatInfo {
/// Labels for subpatterns incompatible with Rust 2024.
pub labels: Vec<(Span, String)>,
/// Whether any binding modifiers occur under a non-`move` default binding mode.
pub bad_modifiers: bool,
/// Whether any `&` or `&mut` patterns occur under a non-`move` default binding mode.
pub bad_ref_pats: bool,
}

11
compiler/rustc_mir_build/messages.ftl
View file

@ -285,7 +285,16 @@ mir_build_pointer_pattern = function pointers and raw pointers not derived from
mir_build_privately_uninhabited = pattern `{$witness_1}` is currently uninhabited, but this variant contains private fields which may become inhabited in the future
mir_build_rust_2024_incompatible_pat = this pattern relies on behavior which may change in edition 2024
mir_build_rust_2024_incompatible_pat = {$bad_modifiers ->
*[true] binding modifiers{$bad_ref_pats ->
*[true] {" "}and reference patterns
[false] {""}
}
[false] reference patterns
} may only be written when the default binding mode is `move`{$is_hard_error ->
*[true] {""}
[false] {" "}in Rust 2024
}
mir_build_static_in_pattern = statics cannot be referenced in patterns
.label = can't be used in patterns

3
compiler/rustc_mir_build/src/errors.rs
View file

@ -1100,6 +1100,9 @@ pub(crate) enum MiscPatternSuggestion {
pub(crate) struct Rust2024IncompatiblePat {
#[subdiagnostic]
pub(crate) sugg: Rust2024IncompatiblePatSugg,
pub(crate) bad_modifiers: bool,
pub(crate) bad_ref_pats: bool,
pub(crate) is_hard_error: bool,
}
pub(crate) struct Rust2024IncompatiblePatSugg {

24
compiler/rustc_mir_build/src/thir/pattern/mod.rs
View file

@ -44,12 +44,12 @@ pub(super) fn pat_from_hir<'a, 'tcx>(
typeck_results: &'a ty::TypeckResults<'tcx>,
pat: &'tcx hir::Pat<'tcx>,
) -> Box<Pat<'tcx>> {
let migration_labels = typeck_results.rust_2024_migration_desugared_pats().get(pat.hir_id);
let migration_info = typeck_results.rust_2024_migration_desugared_pats().get(pat.hir_id);
let mut pcx = PatCtxt {
tcx,
typing_env,
typeck_results,
rust_2024_migration_suggestion: migration_labels.and(Some(Rust2024IncompatiblePatSugg {
rust_2024_migration_suggestion: migration_info.and(Some(Rust2024IncompatiblePatSugg {
suggestion: Vec::new(),
ref_pattern_count: 0,
binding_mode_count: 0,
@ -57,10 +57,10 @@ pub(super) fn pat_from_hir<'a, 'tcx>(
};
let result = pcx.lower_pattern(pat);
debug!("pat_from_hir({:?}) = {:?}", pat, result);
if let Some(labels) = migration_labels {
if let Some(info) = migration_info {
let sugg = pcx.rust_2024_migration_suggestion.expect("suggestion should be present");
let mut spans = MultiSpan::from_spans(labels.iter().map(|(span, _)| *span).collect());
for (span, label) in labels {
let mut spans = MultiSpan::from_spans(info.labels.iter().map(|(span, _)| *span).collect());
for (span, label) in &info.labels {
spans.push_span_label(*span, label.clone());
}
// If a relevant span is from at least edition 2024, this is a hard error.
@ -68,10 +68,13 @@ pub(super) fn pat_from_hir<'a, 'tcx>(
if is_hard_error {
let mut err =
tcx.dcx().struct_span_err(spans, fluent::mir_build_rust_2024_incompatible_pat);
if let Some(info) = lint::builtin::RUST_2024_INCOMPATIBLE_PAT.future_incompatible {
if let Some(lint_info) = lint::builtin::RUST_2024_INCOMPATIBLE_PAT.future_incompatible {
// provide the same reference link as the lint
err.note(format!("for more information, see {}", info.reference));
err.note(format!("for more information, see {}", lint_info.reference));
}
err.arg("bad_modifiers", info.bad_modifiers);
err.arg("bad_ref_pats", info.bad_ref_pats);
err.arg("is_hard_error", true);
err.subdiagnostic(sugg);
err.emit();
} else {
@ -79,7 +82,12 @@ pub(super) fn pat_from_hir<'a, 'tcx>(
lint::builtin::RUST_2024_INCOMPATIBLE_PAT,
pat.hir_id,
spans,
Rust2024IncompatiblePat { sugg },
Rust2024IncompatiblePat {
sugg,
bad_modifiers: info.bad_modifiers,
bad_ref_pats: info.bad_ref_pats,
is_hard_error,
},
);
}
}

28
tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.classic2024.stderr
View file

@ -1,5 +1,5 @@
error[E0308]: mismatched types
--> $DIR/ref-binding-on-inh-ref-errors.rs:60:10
--> $DIR/ref-binding-on-inh-ref-errors.rs:54:10
|
LL | let [&mut ref x] = &[&mut 0];
| ^^^^^
@ -10,11 +10,11 @@ help: replace this `&mut` pattern with `&`
LL | let [&ref x] = &[&mut 0];
| ~
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:67:10
|
LL | let [ref mut x] = &[0];
| ^^^^^^^ cannot override to bind by-reference when that is the implicit default
| ^^^^^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -23,16 +23,16 @@ LL | let &[ref mut x] = &[0];
| +
error[E0596]: cannot borrow data in a `&` reference as mutable
--> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
--> $DIR/ref-binding-on-inh-ref-errors.rs:67:10
|
LL | let [ref mut x] = &[0];
| ^^^^^^^^^ cannot borrow as mutable
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:83:10
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:75:10
|
LL | let [ref x] = &[0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -40,11 +40,11 @@ help: make the implied reference pattern explicit
LL | let &[ref x] = &[0];
| +
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:88:10
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:79:10
|
LL | let [ref x] = &mut [0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref mut`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -52,11 +52,11 @@ help: make the implied reference pattern explicit
LL | let &mut [ref x] = &mut [0];
| ++++
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:93:10
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:83:10
|
LL | let [ref mut x] = &mut [0];
| ^^^^^^^ cannot override to bind by-reference when that is the implicit default
| ^^^^^^^ default binding mode is `ref mut`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit

33
tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.rs
View file

@ -13,26 +13,22 @@
/// The eat-outer variant eats the inherited reference, so binding with `ref` isn't a problem.
fn errors_from_eating_the_real_reference() {
let [&ref x] = &[&0];
//[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
//[structural2024]~| cannot override to bind by-reference when that is the implicit default
//[structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(stable2021)] let _: &u32 = x;
#[cfg(classic2024)] let _: &&u32 = x;
let [&ref x] = &mut [&0];
//[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
//[structural2024]~| cannot override to bind by-reference when that is the implicit default
//[structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(stable2021)] let _: &u32 = x;
#[cfg(classic2024)] let _: &&u32 = x;
let [&mut ref x] = &mut [&mut 0];
//[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
//[structural2024]~| cannot override to bind by-reference when that is the implicit default
//[structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(stable2021)] let _: &u32 = x;
#[cfg(classic2024)] let _: &&mut u32 = x;
let [&mut ref mut x] = &mut [&mut 0];
//[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
//[structural2024]~| cannot override to bind by-reference when that is the implicit default
//[structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(stable2021)] let _: &mut u32 = x;
#[cfg(classic2024)] let _: &mut &mut u32 = x;
}
@ -43,15 +39,13 @@ fn errors_from_eating_the_real_reference_caught_in_hir_typeck_on_stable() {
let [&ref x] = &[&mut 0];
//[stable2021]~^ ERROR: mismatched types
//[stable2021]~| types differ in mutability
//[structural2024]~^^^ ERROR: this pattern relies on behavior which may change in edition 2024
//[structural2024]~| cannot override to bind by-reference when that is the implicit default
//[structural2024]~^^^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(classic2024)] let _: &&mut u32 = x;
let [&ref x] = &mut [&mut 0];
//[stable2021]~^ ERROR: mismatched types
//[stable2021]~| types differ in mutability
//[structural2024]~^^^ ERROR: this pattern relies on behavior which may change in edition 2024
//[structural2024]~| cannot override to bind by-reference when that is the implicit default
//[structural2024]~^^^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(classic2024)] let _: &&mut u32 = x;
}
@ -60,8 +54,7 @@ fn errors_dependent_on_eating_order_caught_in_hir_typeck_when_eating_outer() {
let [&mut ref x] = &[&mut 0];
//[classic2024]~^ ERROR: mismatched types
//[classic2024]~| cannot match inherited `&` with `&mut` pattern
//[structural2024]~^^^ ERROR: this pattern relies on behavior which may change in edition 2024
//[structural2024]~| cannot override to bind by-reference when that is the implicit default
//[structural2024]~^^^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(stable2021)] let _: &u32 = x;
}
@ -73,25 +66,21 @@ fn errors_dependent_on_eating_order_caught_in_hir_typeck_when_eating_outer() {
fn borrowck_errors_in_old_editions() {
let [ref mut x] = &[0];
//~^ ERROR: cannot borrow data in a `&` reference as mutable
//[classic2024,structural2024]~| ERROR: this pattern relies on behavior which may change in edition 2024
//[classic2024,structural2024]~| cannot override to bind by-reference when that is the implicit default
//[classic2024,structural2024]~| ERROR: binding modifiers may only be written when the default binding mode is `move`
}
/// The remaining tests are purely for testing `ref` bindings in the presence of an inherited
/// reference. These should always fail on edition 2024 and succeed on edition 2021.
pub fn main() {
let [ref x] = &[0];
//[classic2024,structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
//[classic2024,structural2024]~| cannot override to bind by-reference when that is the implicit default
//[classic2024,structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(stable2021)] let _: &u32 = x;
let [ref x] = &mut [0];
//[classic2024,structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
//[classic2024,structural2024]~| cannot override to bind by-reference when that is the implicit default
//[classic2024,structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(stable2021)] let _: &u32 = x;
let [ref mut x] = &mut [0];
//[classic2024,structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
//[classic2024,structural2024]~| cannot override to bind by-reference when that is the implicit default
//[classic2024,structural2024]~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
#[cfg(stable2021)] let _: &mut u32 = x;
}

6
tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.stable2021.stderr
View file

@ -1,5 +1,5 @@
error[E0308]: mismatched types
--> $DIR/ref-binding-on-inh-ref-errors.rs:43:10
--> $DIR/ref-binding-on-inh-ref-errors.rs:39:10
|
LL | let [&ref x] = &[&mut 0];
| ^^^^^^ --------- this expression has type `&[&mut {integer}; 1]`
@ -15,7 +15,7 @@ LL + let [ref x] = &[&mut 0];
|
error[E0308]: mismatched types
--> $DIR/ref-binding-on-inh-ref-errors.rs:50:10
--> $DIR/ref-binding-on-inh-ref-errors.rs:45:10
|
LL | let [&ref x] = &mut [&mut 0];
| ^^^^^^ ------------- this expression has type `&mut [&mut {integer}; 1]`
@ -31,7 +31,7 @@ LL + let [ref x] = &mut [&mut 0];
|
error[E0596]: cannot borrow data in a `&` reference as mutable
--> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
--> $DIR/ref-binding-on-inh-ref-errors.rs:67:10
|
LL | let [ref mut x] = &[0];
| ^^^^^^^^^ cannot borrow as mutable

66
tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.structural2024.stderr
View file

@ -1,8 +1,8 @@
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:15:11
|
LL | let [&ref x] = &[&0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -10,11 +10,11 @@ help: make the implied reference pattern explicit
LL | let &[&ref x] = &[&0];
| +
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:21:11
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:20:11
|
LL | let [&ref x] = &mut [&0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -22,11 +22,11 @@ help: make the implied reference pattern explicit
LL | let &mut [&ref x] = &mut [&0];
| ++++
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:27:15
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:25:15
|
LL | let [&mut ref x] = &mut [&mut 0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref mut`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -34,11 +34,11 @@ help: make the implied reference pattern explicit
LL | let &mut [&mut ref x] = &mut [&mut 0];
| ++++
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:33:15
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:30:15
|
LL | let [&mut ref mut x] = &mut [&mut 0];
| ^^^^^^^ cannot override to bind by-reference when that is the implicit default
| ^^^^^^^ default binding mode is `ref mut`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -46,11 +46,11 @@ help: make the implied reference pattern explicit
LL | let &mut [&mut ref mut x] = &mut [&mut 0];
| ++++
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:43:11
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:39:11
|
LL | let [&ref x] = &[&mut 0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -58,11 +58,11 @@ help: make the implied reference pattern explicit
LL | let &[&ref x] = &[&mut 0];
| +
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:50:11
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:45:11
|
LL | let [&ref x] = &mut [&mut 0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -70,11 +70,11 @@ help: make the implied reference pattern explicit
LL | let &mut [&ref x] = &mut [&mut 0];
| ++++
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:60:15
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:54:15
|
LL | let [&mut ref x] = &[&mut 0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -82,11 +82,11 @@ help: make the implied reference pattern explicit
LL | let &[&mut ref x] = &[&mut 0];
| +
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:67:10
|
LL | let [ref mut x] = &[0];
| ^^^^^^^ cannot override to bind by-reference when that is the implicit default
| ^^^^^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -95,16 +95,16 @@ LL | let &[ref mut x] = &[0];
| +
error[E0596]: cannot borrow data in a `&` reference as mutable
--> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
--> $DIR/ref-binding-on-inh-ref-errors.rs:67:10
|
LL | let [ref mut x] = &[0];
| ^^^^^^^^^ cannot borrow as mutable
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:83:10
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:75:10
|
LL | let [ref x] = &[0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -112,11 +112,11 @@ help: make the implied reference pattern explicit
LL | let &[ref x] = &[0];
| +
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:88:10
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:79:10
|
LL | let [ref x] = &mut [0];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref mut`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -124,11 +124,11 @@ help: make the implied reference pattern explicit
LL | let &mut [ref x] = &mut [0];
| ++++
error: this pattern relies on behavior which may change in edition 2024
--> $DIR/ref-binding-on-inh-ref-errors.rs:93:10
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/ref-binding-on-inh-ref-errors.rs:83:10
|
LL | let [ref mut x] = &mut [0];
| ^^^^^^^ cannot override to bind by-reference when that is the implicit default
| ^^^^^^^ default binding mode is `ref mut`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit

32
tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.fixed
View file

@ -23,22 +23,22 @@ fn main() {
assert_type_eq(x, &mut 0u8);
let &Foo(mut x) = &Foo(0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let &mut Foo(mut x) = &mut Foo(0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let &Foo(ref x) = &Foo(0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, &0u8);
let &mut Foo(ref x) = &mut Foo(0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, &0u8);
@ -55,22 +55,22 @@ fn main() {
assert_type_eq(x, &0u8);
let &Foo(&x) = &Foo(&0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let &Foo(&mut x) = &Foo(&mut 0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let &mut Foo(&x) = &mut Foo(&0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let &mut Foo(&mut x) = &mut Foo(&mut 0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
@ -79,25 +79,25 @@ fn main() {
}
if let &&&&&Some(&x) = &&&&&Some(&0u8) {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
}
if let &&&&&Some(&mut x) = &&&&&Some(&mut 0u8) {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
}
if let &&&&&mut Some(&x) = &&&&&mut Some(&0u8) {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
}
if let &mut Some(&mut Some(&mut Some(ref mut x))) = &mut Some(&mut Some(&mut Some(0u8))) {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, &mut 0u8);
}
@ -109,20 +109,20 @@ fn main() {
}
let &Struct { ref a, mut b, ref c } = &Struct { a: 0, b: 0, c: 0 };
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(a, &0u32);
assert_type_eq(b, 0u32);
let &Struct { a: &a, ref b, ref c } = &Struct { a: &0, b: &0, c: &0 };
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(a, 0u32);
assert_type_eq(b, &&0u32);
assert_type_eq(c, &&0u32);
if let &Struct { a: &Some(a), b: &Some(&b), c: &Some(ref c) } =
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
&(Struct { a: &Some(&0), b: &Some(&0), c: &Some(&0) })
{
@ -135,7 +135,7 @@ fn main() {
// The two patterns are the same syntactically, but because they're defined in different
// editions they don't mean the same thing.
&(Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
assert_type_eq(x, 0u32);
assert_type_eq(y, 0u32);
}

32
tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.rs
View file

@ -23,22 +23,22 @@ fn main() {
assert_type_eq(x, &mut 0u8);
let Foo(mut x) = &Foo(0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let Foo(mut x) = &mut Foo(0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let Foo(ref x) = &Foo(0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, &0u8);
let Foo(ref x) = &mut Foo(0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, &0u8);
@ -55,22 +55,22 @@ fn main() {
assert_type_eq(x, &0u8);
let Foo(&x) = &Foo(&0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let Foo(&mut x) = &Foo(&mut 0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let Foo(&x) = &mut Foo(&0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
let Foo(&mut x) = &mut Foo(&mut 0);
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
@ -79,25 +79,25 @@ fn main() {
}
if let Some(&x) = &&&&&Some(&0u8) {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
}
if let Some(&mut x) = &&&&&Some(&mut 0u8) {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
}
if let Some(&x) = &&&&&mut Some(&0u8) {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, 0u8);
}
if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(x, &mut 0u8);
}
@ -109,20 +109,20 @@ fn main() {
}
let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(a, &0u32);
assert_type_eq(b, 0u32);
let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
assert_type_eq(a, 0u32);
assert_type_eq(b, &&0u32);
assert_type_eq(c, &&0u32);
if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: reference patterns may only be written when the default binding mode is `move` in Rust 2024
//~| WARN: this changes meaning in Rust 2024
&(Struct { a: &Some(&0), b: &Some(&0), c: &Some(&0) })
{
@ -135,7 +135,7 @@ fn main() {
// The two patterns are the same syntactically, but because they're defined in different
// editions they don't mean the same thing.
(Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
//~^ ERROR: binding modifiers may only be written when the default binding mode is `move`
assert_type_eq(x, 0u32);
assert_type_eq(y, 0u32);
}

70
tests/ui/pattern/rfc-3627-match-ergonomics-2024/migration_lint.stderr
View file

@ -1,8 +1,8 @@
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:25:13
|
LL | let Foo(mut x) = &Foo(0);
| ^^^ requires binding by-value, but the implicit default is by-reference
| ^^^ default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -16,11 +16,11 @@ help: make the implied reference pattern explicit
LL | let &Foo(mut x) = &Foo(0);
| +
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:30:13
|
LL | let Foo(mut x) = &mut Foo(0);
| ^^^ requires binding by-value, but the implicit default is by-reference
| ^^^ default binding mode is `ref mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -29,11 +29,11 @@ help: make the implied reference pattern explicit
LL | let &mut Foo(mut x) = &mut Foo(0);
| ++++
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:35:13
|
LL | let Foo(ref x) = &Foo(0);
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -42,11 +42,11 @@ help: make the implied reference pattern explicit
LL | let &Foo(ref x) = &Foo(0);
| +
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:40:13
|
LL | let Foo(ref x) = &mut Foo(0);
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -55,11 +55,11 @@ help: make the implied reference pattern explicit
LL | let &mut Foo(ref x) = &mut Foo(0);
| ++++
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:57:13
|
LL | let Foo(&x) = &Foo(&0);
| ^ cannot implicitly match against multiple layers of reference
| ^ default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -68,11 +68,11 @@ help: make the implied reference pattern explicit
LL | let &Foo(&x) = &Foo(&0);
| +
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:62:13
|
LL | let Foo(&mut x) = &Foo(&mut 0);
| ^^^^ cannot implicitly match against multiple layers of reference
| ^^^^ default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -81,11 +81,11 @@ help: make the implied reference pattern explicit
LL | let &Foo(&mut x) = &Foo(&mut 0);
| +
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:67:13
|
LL | let Foo(&x) = &mut Foo(&0);
| ^ cannot implicitly match against multiple layers of reference
| ^ default binding mode is `ref mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -94,11 +94,11 @@ help: make the implied reference pattern explicit
LL | let &mut Foo(&x) = &mut Foo(&0);
| ++++
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:72:13
|
LL | let Foo(&mut x) = &mut Foo(&mut 0);
| ^^^^ cannot implicitly match against multiple layers of reference
| ^^^^ default binding mode is `ref mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -107,11 +107,11 @@ help: make the implied reference pattern explicit
LL | let &mut Foo(&mut x) = &mut Foo(&mut 0);
| ++++
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:81:17
|
LL | if let Some(&x) = &&&&&Some(&0u8) {
| ^ cannot implicitly match against multiple layers of reference
| ^ default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -120,11 +120,11 @@ help: make the implied reference patterns explicit
LL | if let &&&&&Some(&x) = &&&&&Some(&0u8) {
| +++++
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:87:17
|
LL | if let Some(&mut x) = &&&&&Some(&mut 0u8) {
| ^^^^ cannot implicitly match against multiple layers of reference
| ^^^^ default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -133,11 +133,11 @@ help: make the implied reference patterns explicit
LL | if let &&&&&Some(&mut x) = &&&&&Some(&mut 0u8) {
| +++++
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:93:17
|
LL | if let Some(&x) = &&&&&mut Some(&0u8) {
| ^ cannot implicitly match against multiple layers of reference
| ^ default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -146,11 +146,11 @@ help: make the implied reference patterns explicit
LL | if let &&&&&mut Some(&x) = &&&&&mut Some(&0u8) {
| ++++++++
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:99:17
|
LL | if let Some(&mut Some(Some(x))) = &mut Some(&mut Some(&mut Some(0u8))) {
| ^^^^ cannot implicitly match against multiple layers of reference
| ^^^^ default binding mode is `ref mut`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -159,11 +159,11 @@ help: make the implied reference patterns and variable binding mode explicit
LL | if let &mut Some(&mut Some(&mut Some(ref mut x))) = &mut Some(&mut Some(&mut Some(0u8))) {
| ++++ ++++ +++++++
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:111:21
|
LL | let Struct { a, mut b, c } = &Struct { a: 0, b: 0, c: 0 };
| ^^^ requires binding by-value, but the implicit default is by-reference
| ^^^ default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -172,13 +172,13 @@ help: make the implied reference pattern and variable binding modes explicit
LL | let &Struct { ref a, mut b, ref c } = &Struct { a: 0, b: 0, c: 0 };
| + +++ +++
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers and reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:117:21
|
LL | let Struct { a: &a, b, ref c } = &Struct { a: &0, b: &0, c: &0 };
| ^ ^^^ cannot override to bind by-reference when that is the implicit default
| ^ ^^^ default binding mode is `ref`
| |
| cannot implicitly match against multiple layers of reference
| default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -187,13 +187,13 @@ help: make the implied reference pattern and variable binding mode explicit
LL | let &Struct { a: &a, ref b, ref c } = &Struct { a: &0, b: &0, c: &0 };
| + +++
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move` in Rust 2024
--> $DIR/migration_lint.rs:124:24
|
LL | if let Struct { a: &Some(a), b: Some(&b), c: Some(c) } =
| ^ ^ cannot implicitly match against multiple layers of reference
| ^ ^ default binding mode is `ref`
| |
| cannot implicitly match against multiple layers of reference
| default binding mode is `ref`
|
= warning: this changes meaning in Rust 2024
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
@ -202,13 +202,13 @@ help: make the implied reference patterns and variable binding mode explicit
LL | if let &Struct { a: &Some(a), b: &Some(&b), c: &Some(ref c) } =
| + + + +++
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/migration_lint.rs:137:15
|
LL | (Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
| ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ default binding mode is reset within expansion
| ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ occurs within expansion
| |
| requires binding by-value, but the implicit default is by-reference
| default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
= note: this error originates in the macro `migration_lint_macros::mixed_edition_pat` (in Nightly builds, run with -Z macro-backtrace for more info)

14
tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.rs
View file

@ -21,17 +21,17 @@ macro_rules! test_pat_on_type {
}
test_pat_on_type![(&x,): &(T,)]; //~ ERROR mismatched types
test_pat_on_type![(&x,): &(&T,)]; //~ ERROR this pattern relies on behavior which may change in edition 2024
test_pat_on_type![(&x,): &(&T,)]; //~ ERROR reference patterns may only be written when the default binding mode is `move`
test_pat_on_type![(&x,): &(&mut T,)]; //~ ERROR mismatched types
test_pat_on_type![(&mut x,): &(&T,)]; //~ ERROR mismatched types
test_pat_on_type![(&mut x,): &(&mut T,)]; //~ ERROR this pattern relies on behavior which may change in edition 2024
test_pat_on_type![(&mut x,): &(&mut T,)]; //~ ERROR reference patterns may only be written when the default binding mode is `move`
test_pat_on_type![(&x,): &&mut &(T,)]; //~ ERROR mismatched types
test_pat_on_type![Foo { f: (&x,) }: Foo]; //~ ERROR mismatched types
test_pat_on_type![Foo { f: (&x,) }: &mut Foo]; //~ ERROR mismatched types
test_pat_on_type![Foo { f: &(x,) }: &Foo]; //~ ERROR this pattern relies on behavior which may change in edition 2024
test_pat_on_type![(mut x,): &(T,)]; //~ ERROR this pattern relies on behavior which may change in edition 2024
test_pat_on_type![(ref x,): &(T,)]; //~ ERROR this pattern relies on behavior which may change in edition 2024
test_pat_on_type![(ref mut x,): &mut (T,)]; //~ ERROR this pattern relies on behavior which may change in edition 2024
test_pat_on_type![Foo { f: &(x,) }: &Foo]; //~ ERROR reference patterns may only be written when the default binding mode is `move`
test_pat_on_type![(mut x,): &(T,)]; //~ ERROR binding modifiers may only be written when the default binding mode is `move`
test_pat_on_type![(ref x,): &(T,)]; //~ ERROR binding modifiers may only be written when the default binding mode is `move`
test_pat_on_type![(ref mut x,): &mut (T,)]; //~ ERROR binding modifiers may only be written when the default binding mode is `move`
fn get<X>() -> X {
unimplemented!()
@ -40,6 +40,6 @@ fn get<X>() -> X {
// Make sure this works even when the underlying type is inferred. This test passes on rust stable.
fn infer<X: Copy>() -> X {
match &get() {
(&x,) => x, //~ ERROR this pattern relies on behavior which may change in edition 2024
(&x,) => x, //~ ERROR reference patterns may only be written when the default binding mode is `move`
}
}

28
tests/ui/pattern/rfc-3627-match-ergonomics-2024/min_match_ergonomics_fail.stderr
View file

@ -99,11 +99,11 @@ LL - test_pat_on_type![Foo { f: (&x,) }: &mut Foo];
LL + test_pat_on_type![Foo { f: (x,) }: &mut Foo];
|
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move`
--> $DIR/min_match_ergonomics_fail.rs:24:20
|
LL | test_pat_on_type![(&x,): &(&T,)];
| ^ cannot implicitly match against multiple layers of reference
| ^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -111,11 +111,11 @@ help: make the implied reference pattern explicit
LL | test_pat_on_type![&(&x,): &(&T,)];
| +
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move`
--> $DIR/min_match_ergonomics_fail.rs:27:20
|
LL | test_pat_on_type![(&mut x,): &(&mut T,)];
| ^^^^ cannot implicitly match against multiple layers of reference
| ^^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -123,11 +123,11 @@ help: make the implied reference pattern explicit
LL | test_pat_on_type![&(&mut x,): &(&mut T,)];
| +
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move`
--> $DIR/min_match_ergonomics_fail.rs:31:28
|
LL | test_pat_on_type![Foo { f: &(x,) }: &Foo];
| ^ cannot implicitly match against multiple layers of reference
| ^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -135,11 +135,11 @@ help: make the implied reference pattern explicit
LL | test_pat_on_type![&Foo { f: &(x,) }: &Foo];
| +
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/min_match_ergonomics_fail.rs:32:20
|
LL | test_pat_on_type![(mut x,): &(T,)];
| ^^^ requires binding by-value, but the implicit default is by-reference
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -147,11 +147,11 @@ help: make the implied reference pattern explicit
LL | test_pat_on_type![&(mut x,): &(T,)];
| +
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/min_match_ergonomics_fail.rs:33:20
|
LL | test_pat_on_type![(ref x,): &(T,)];
| ^^^ cannot override to bind by-reference when that is the implicit default
| ^^^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -159,11 +159,11 @@ help: make the implied reference pattern explicit
LL | test_pat_on_type![&(ref x,): &(T,)];
| +
error: this pattern relies on behavior which may change in edition 2024
error: binding modifiers may only be written when the default binding mode is `move`
--> $DIR/min_match_ergonomics_fail.rs:34:20
|
LL | test_pat_on_type![(ref mut x,): &mut (T,)];
| ^^^^^^^ cannot override to bind by-reference when that is the implicit default
| ^^^^^^^ default binding mode is `ref mut`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit
@ -171,11 +171,11 @@ help: make the implied reference pattern explicit
LL | test_pat_on_type![&mut (ref mut x,): &mut (T,)];
| ++++
error: this pattern relies on behavior which may change in edition 2024
error: reference patterns may only be written when the default binding mode is `move`
--> $DIR/min_match_ergonomics_fail.rs:43:10
|
LL | (&x,) => x,
| ^ cannot implicitly match against multiple layers of reference
| ^ default binding mode is `ref`
|
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>
help: make the implied reference pattern explicit