mirror of
https://github.com/rust-lang/rust.git
synced 2025-04-28 11:07:42 +00:00
Rollup merge of #134394 - dianne:clarify-pat-2024-migration, r=compiler-errors
Clarify the match ergonomics 2024 migration lint's output This makes a few changes: - Rather than using the whole pattern as a span for the lint, this collects spans for each problematic default binding mode reset and labels them with why they're problems. - The lint's suggestions are now verbose-styled, so that it's clear what's being suggested vs. what's problematic. - The wording is now less technical, and the hard error version of this diagnostic now links to the same reference material as the lint (currently an unwritten page of the edition guide). I'm not totally confident in the wording or formatting, so I'd appreciate feedback on that in particular. I tried to draw a connection with word choice between the labels and the suggestion, but it might be imprecise, unclear, or cluttered. If so, it might be worth making the labels more terse and adding notes that explain them, but that's harder to read in a way too. cc ```@Nadrieril``` ```@Jules-Bertholet``` Closes #133854. For reference, the error from that issue becomes: ``` error: pattern uses features incompatible with edition 2024 --> $DIR/remove-me.rs:6:25 | LL | map.iter().filter(|(&(_x, _y), &_c)| false); | ^ ^ cannot implicitly match against multiple layers of reference | | | cannot implicitly match against multiple layers of reference | help: make the implied reference pattern explicit | LL | map.iter().filter(|&(&(_x, _y), &_c)| false); | + ```
This commit is contained in:
许杰友 Jieyou Xu (Joe)
GitHub
commit
f3faaf524c
@ -717,12 +717,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
||||
BindingMode(def_br, Mutability::Mut)
|
||||
} else {
|
||||
// `mut` resets the binding mode on edition <= 2021
|
||||
*self
|
||||
.typeck_results
|
||||
.borrow_mut()
|
||||
.rust_2024_migration_desugared_pats_mut()
|
||||
.entry(pat_info.top_info.hir_id)
|
||||
.or_default() |= pat.span.at_least_rust_2024();
|
||||
self.add_rust_2024_migration_desugared_pat(
|
||||
pat_info.top_info.hir_id,
|
||||
pat.span,
|
||||
ident.span,
|
||||
"requires binding by-value, but the implicit default is by-reference",
|
||||
);
|
||||
BindingMode(ByRef::No, Mutability::Mut)
|
||||
}
|
||||
}
|
||||
@ -730,12 +730,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
||||
BindingMode(ByRef::Yes(_), _) => {
|
||||
if matches!(def_br, ByRef::Yes(_)) {
|
||||
// `ref`/`ref mut` overrides the binding mode on edition <= 2021
|
||||
*self
|
||||
.typeck_results
|
||||
.borrow_mut()
|
||||
.rust_2024_migration_desugared_pats_mut()
|
||||
.entry(pat_info.top_info.hir_id)
|
||||
.or_default() |= pat.span.at_least_rust_2024();
|
||||
self.add_rust_2024_migration_desugared_pat(
|
||||
pat_info.top_info.hir_id,
|
||||
pat.span,
|
||||
ident.span,
|
||||
"cannot override to bind by-reference when that is the implicit default",
|
||||
);
|
||||
}
|
||||
user_bind_annot
|
||||
}
|
||||
@ -2265,12 +2265,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
||||
// Reset binding mode on old editions
|
||||
if pat_info.binding_mode != ByRef::No {
|
||||
pat_info.binding_mode = ByRef::No;
|
||||
*self
|
||||
.typeck_results
|
||||
.borrow_mut()
|
||||
.rust_2024_migration_desugared_pats_mut()
|
||||
.entry(pat_info.top_info.hir_id)
|
||||
.or_default() |= pat.span.at_least_rust_2024();
|
||||
self.add_rust_2024_migration_desugared_pat(
|
||||
pat_info.top_info.hir_id,
|
||||
pat.span,
|
||||
inner.span,
|
||||
"cannot implicitly match against multiple layers of reference",
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@ -2629,4 +2629,39 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
|
||||
_ => (false, ty),
|
||||
}
|
||||
}
|
||||
|
||||
/// Record a pattern that's invalid under Rust 2024 match ergonomics, along with a problematic
|
||||
/// span, so that the pattern migration lint can desugar it during THIR construction.
|
||||
fn add_rust_2024_migration_desugared_pat(
|
||||
&self,
|
||||
pat_id: HirId,
|
||||
subpat_span: Span,
|
||||
cutoff_span: Span,
|
||||
detailed_label: &str,
|
||||
) {
|
||||
// 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.
|
||||
let source_map = self.tcx.sess.source_map();
|
||||
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
|
||||
// error if the subpattern is of edition >= 2024.
|
||||
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"
|
||||
} else {
|
||||
detailed_label
|
||||
};
|
||||
|
||||
self.typeck_results
|
||||
.borrow_mut()
|
||||
.rust_2024_migration_desugared_pats_mut()
|
||||
.entry(pat_id)
|
||||
.or_default()
|
||||
.push((trimmed_span, desc.to_owned()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -74,9 +74,8 @@ pub struct TypeckResults<'tcx> {
|
||||
pat_binding_modes: ItemLocalMap<BindingMode>,
|
||||
|
||||
/// Top-level patterns whose match ergonomics need to be desugared by the Rust 2021 -> 2024
|
||||
/// migration lint. The boolean indicates whether the emitted diagnostic should be a hard error
|
||||
/// (if any of the incompatible pattern elements are in edition 2024).
|
||||
rust_2024_migration_desugared_pats: ItemLocalMap<bool>,
|
||||
/// migration lint. Problematic subpatterns are stored in the `Vec` for the lint to highlight.
|
||||
rust_2024_migration_desugared_pats: ItemLocalMap<Vec<(Span, String)>>,
|
||||
|
||||
/// Stores the types which were implicitly dereferenced in pattern binding modes
|
||||
/// for later usage in THIR lowering. For example,
|
||||
@ -419,14 +418,18 @@ impl<'tcx> TypeckResults<'tcx> {
|
||||
LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.pat_adjustments }
|
||||
}
|
||||
|
||||
pub fn rust_2024_migration_desugared_pats(&self) -> LocalTableInContext<'_, bool> {
|
||||
pub fn rust_2024_migration_desugared_pats(
|
||||
&self,
|
||||
) -> LocalTableInContext<'_, Vec<(Span, String)>> {
|
||||
LocalTableInContext {
|
||||
hir_owner: self.hir_owner,
|
||||
data: &self.rust_2024_migration_desugared_pats,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn rust_2024_migration_desugared_pats_mut(&mut self) -> LocalTableInContextMut<'_, bool> {
|
||||
pub fn rust_2024_migration_desugared_pats_mut(
|
||||
&mut self,
|
||||
) -> LocalTableInContextMut<'_, Vec<(Span, String)>> {
|
||||
LocalTableInContextMut {
|
||||
hir_owner: self.hir_owner,
|
||||
data: &mut self.rust_2024_migration_desugared_pats,
|
||||
|
||||
@ -285,7 +285,7 @@ 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 = patterns are not allowed to reset the default binding mode in edition 2024
|
||||
mir_build_rust_2024_incompatible_pat = this pattern relies on behavior which may change in edition 2024
|
||||
|
||||
mir_build_rustc_box_attribute_error = `#[rustc_box]` attribute used incorrectly
|
||||
.attributes = no other attributes may be applied
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
use rustc_errors::codes::*;
|
||||
use rustc_errors::{
|
||||
Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
|
||||
MultiSpan, SubdiagMessageOp, Subdiagnostic,
|
||||
MultiSpan, SubdiagMessageOp, Subdiagnostic, pluralize,
|
||||
};
|
||||
use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
|
||||
use rustc_middle::ty::{self, Ty};
|
||||
@ -1088,18 +1088,20 @@ pub(crate) enum RustcBoxAttrReason {
|
||||
|
||||
#[derive(LintDiagnostic)]
|
||||
#[diag(mir_build_rust_2024_incompatible_pat)]
|
||||
pub(crate) struct Rust2024IncompatiblePat {
|
||||
pub(crate) struct Rust2024IncompatiblePat<'a> {
|
||||
#[subdiagnostic]
|
||||
pub(crate) sugg: Rust2024IncompatiblePatSugg,
|
||||
pub(crate) sugg: Rust2024IncompatiblePatSugg<'a>,
|
||||
}
|
||||
|
||||
pub(crate) struct Rust2024IncompatiblePatSugg {
|
||||
pub(crate) struct Rust2024IncompatiblePatSugg<'a> {
|
||||
pub(crate) suggestion: Vec<(Span, String)>,
|
||||
/// Whether the incompatibility is a hard error because a relevant span is in edition 2024.
|
||||
pub(crate) is_hard_error: bool,
|
||||
pub(crate) ref_pattern_count: usize,
|
||||
pub(crate) binding_mode_count: usize,
|
||||
/// Labeled spans for subpatterns invalid in Rust 2024.
|
||||
pub(crate) labels: &'a [(Span, String)],
|
||||
}
|
||||
|
||||
impl Subdiagnostic for Rust2024IncompatiblePatSugg {
|
||||
impl<'a> Subdiagnostic for Rust2024IncompatiblePatSugg<'a> {
|
||||
fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
|
||||
self,
|
||||
diag: &mut Diag<'_, G>,
|
||||
@ -1111,6 +1113,16 @@ impl Subdiagnostic for Rust2024IncompatiblePatSugg {
|
||||
} else {
|
||||
Applicability::MaybeIncorrect
|
||||
};
|
||||
diag.multipart_suggestion("desugar the match ergonomics", self.suggestion, applicability);
|
||||
let plural_derefs = pluralize!(self.ref_pattern_count);
|
||||
let and_modes = if self.binding_mode_count > 0 {
|
||||
format!(" and variable binding mode{}", pluralize!(self.binding_mode_count))
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
diag.multipart_suggestion_verbose(
|
||||
format!("make the implied reference pattern{plural_derefs}{and_modes} explicit"),
|
||||
self.suggestion,
|
||||
applicability,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,6 +6,7 @@ mod const_to_pat;
|
||||
use std::cmp::Ordering;
|
||||
|
||||
use rustc_abi::{FieldIdx, Integer};
|
||||
use rustc_errors::MultiSpan;
|
||||
use rustc_errors::codes::*;
|
||||
use rustc_hir::def::{CtorOf, DefKind, Res};
|
||||
use rustc_hir::pat_util::EnumerateAndAdjustIterator;
|
||||
@ -34,7 +35,7 @@ struct PatCtxt<'a, 'tcx> {
|
||||
typeck_results: &'a ty::TypeckResults<'tcx>,
|
||||
|
||||
/// Used by the Rust 2024 migration lint.
|
||||
rust_2024_migration_suggestion: Option<Rust2024IncompatiblePatSugg>,
|
||||
rust_2024_migration_suggestion: Option<Rust2024IncompatiblePatSugg<'a>>,
|
||||
}
|
||||
|
||||
pub(super) fn pat_from_hir<'a, 'tcx>(
|
||||
@ -50,24 +51,36 @@ pub(super) fn pat_from_hir<'a, 'tcx>(
|
||||
rust_2024_migration_suggestion: typeck_results
|
||||
.rust_2024_migration_desugared_pats()
|
||||
.get(pat.hir_id)
|
||||
.map(|&is_hard_error| Rust2024IncompatiblePatSugg {
|
||||
.map(|labels| Rust2024IncompatiblePatSugg {
|
||||
suggestion: Vec::new(),
|
||||
is_hard_error,
|
||||
ref_pattern_count: 0,
|
||||
binding_mode_count: 0,
|
||||
labels: labels.as_slice(),
|
||||
}),
|
||||
};
|
||||
let result = pcx.lower_pattern(pat);
|
||||
debug!("pat_from_hir({:?}) = {:?}", pat, result);
|
||||
if let Some(sugg) = pcx.rust_2024_migration_suggestion {
|
||||
if sugg.is_hard_error {
|
||||
let mut spans = MultiSpan::from_spans(sugg.labels.iter().map(|(span, _)| *span).collect());
|
||||
for (span, label) in sugg.labels {
|
||||
spans.push_span_label(*span, label.clone());
|
||||
}
|
||||
// If a relevant span is from at least edition 2024, this is a hard error.
|
||||
let is_hard_error = spans.primary_spans().iter().any(|span| span.at_least_rust_2024());
|
||||
if is_hard_error {
|
||||
let mut err =
|
||||
tcx.dcx().struct_span_err(pat.span, fluent::mir_build_rust_2024_incompatible_pat);
|
||||
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 {
|
||||
// provide the same reference link as the lint
|
||||
err.note(format!("for more information, see {}", info.reference));
|
||||
}
|
||||
err.subdiagnostic(sugg);
|
||||
err.emit();
|
||||
} else {
|
||||
tcx.emit_node_span_lint(
|
||||
lint::builtin::RUST_2024_INCOMPATIBLE_PAT,
|
||||
pat.hir_id,
|
||||
pat.span,
|
||||
spans,
|
||||
Rust2024IncompatiblePat { sugg },
|
||||
);
|
||||
}
|
||||
@ -133,6 +146,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
|
||||
})
|
||||
.collect();
|
||||
s.suggestion.push((pat.span.shrink_to_lo(), suggestion_str));
|
||||
s.ref_pattern_count += adjustments.len();
|
||||
};
|
||||
|
||||
adjusted_pat
|
||||
@ -371,7 +385,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
|
||||
s.suggestion.push((
|
||||
pat.span.with_lo(ident.span.lo()).shrink_to_lo(),
|
||||
sugg_str.to_owned(),
|
||||
))
|
||||
));
|
||||
s.binding_mode_count += 1;
|
||||
}
|
||||
|
||||
// A ref x pattern is the same node used for x, and as such it has
|
||||
|
||||
@ -23,22 +23,22 @@ fn main() {
|
||||
assert_type_eq(x, &mut 0u8);
|
||||
|
||||
let &Foo(mut x) = &Foo(0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let &mut Foo(mut x) = &mut Foo(0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let &Foo(ref x) = &Foo(0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, &0u8);
|
||||
|
||||
let &mut Foo(ref x) = &mut Foo(0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let &Foo(&mut x) = &Foo(&mut 0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let &mut Foo(&x) = &mut Foo(&0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let &mut Foo(&mut x) = &mut Foo(&mut 0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
}
|
||||
|
||||
if let &&&&&Some(&mut x) = &&&&&Some(&mut 0u8) {
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
}
|
||||
|
||||
if let &&&&&mut Some(&x) = &&&&&mut Some(&0u8) {
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
assert_type_eq(x, 0u32);
|
||||
assert_type_eq(y, 0u32);
|
||||
}
|
||||
|
||||
@ -23,22 +23,22 @@ fn main() {
|
||||
assert_type_eq(x, &mut 0u8);
|
||||
|
||||
let Foo(mut x) = &Foo(0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let Foo(mut x) = &mut Foo(0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let Foo(ref x) = &Foo(0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, &0u8);
|
||||
|
||||
let Foo(ref x) = &mut Foo(0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let Foo(&mut x) = &Foo(&mut 0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let Foo(&x) = &mut Foo(&0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
|
||||
let Foo(&mut x) = &mut Foo(&mut 0);
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
}
|
||||
|
||||
if let Some(&mut x) = &&&&&Some(&mut 0u8) {
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
//~| WARN: this changes meaning in Rust 2024
|
||||
assert_type_eq(x, 0u8);
|
||||
}
|
||||
|
||||
if let Some(&x) = &&&&&mut Some(&0u8) {
|
||||
//~^ ERROR: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 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: patterns are not allowed to reset the default binding mode
|
||||
//~^ ERROR: this pattern relies on behavior which may change in edition 2024
|
||||
assert_type_eq(x, 0u32);
|
||||
assert_type_eq(y, 0u32);
|
||||
}
|
||||
|
||||
@ -1,10 +1,8 @@
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:25:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:25:13
|
||||
|
|
||||
LL | let Foo(mut x) = &Foo(0);
|
||||
| -^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^^^ requires binding by-value, but the implicit default is by-reference
|
||||
|
|
||||
= 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>
|
||||
@ -13,176 +11,211 @@ note: the lint level is defined here
|
||||
|
|
||||
LL | #![deny(rust_2024_incompatible_pat)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | let &Foo(mut x) = &Foo(0);
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:30:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:30:13
|
||||
|
|
||||
LL | let Foo(mut x) = &mut Foo(0);
|
||||
| -^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&mut`
|
||||
| ^^^ requires binding by-value, but the implicit default is by-reference
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | let &mut Foo(mut x) = &mut Foo(0);
|
||||
| ++++
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:35:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:35:13
|
||||
|
|
||||
LL | let Foo(ref x) = &Foo(0);
|
||||
| -^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^^^ cannot override to bind by-reference when that is the implicit default
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | let &Foo(ref x) = &Foo(0);
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:40:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:40:13
|
||||
|
|
||||
LL | let Foo(ref x) = &mut Foo(0);
|
||||
| -^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&mut`
|
||||
| ^^^ cannot override to bind by-reference when that is the implicit default
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | let &mut Foo(ref x) = &mut Foo(0);
|
||||
| ++++
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:57:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:57:13
|
||||
|
|
||||
LL | let Foo(&x) = &Foo(&0);
|
||||
| -^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | let &Foo(&x) = &Foo(&0);
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:62:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:62:13
|
||||
|
|
||||
LL | let Foo(&mut x) = &Foo(&mut 0);
|
||||
| -^^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^^^^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | let &Foo(&mut x) = &Foo(&mut 0);
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:67:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:67:13
|
||||
|
|
||||
LL | let Foo(&x) = &mut Foo(&0);
|
||||
| -^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&mut`
|
||||
| ^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | let &mut Foo(&x) = &mut Foo(&0);
|
||||
| ++++
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:72:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:72:13
|
||||
|
|
||||
LL | let Foo(&mut x) = &mut Foo(&mut 0);
|
||||
| -^^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&mut`
|
||||
| ^^^^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | let &mut Foo(&mut x) = &mut Foo(&mut 0);
|
||||
| ++++
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:81:12
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:81:17
|
||||
|
|
||||
LL | if let Some(&x) = &&&&&Some(&0u8) {
|
||||
| -^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&&&&&`
|
||||
| ^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference patterns explicit
|
||||
|
|
||||
LL | if let &&&&&Some(&x) = &&&&&Some(&0u8) {
|
||||
| +++++
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:87:12
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:87:17
|
||||
|
|
||||
LL | if let Some(&mut x) = &&&&&Some(&mut 0u8) {
|
||||
| -^^^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&&&&&`
|
||||
| ^^^^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference patterns explicit
|
||||
|
|
||||
LL | if let &&&&&Some(&mut x) = &&&&&Some(&mut 0u8) {
|
||||
| +++++
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:93:12
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:93:17
|
||||
|
|
||||
LL | if let Some(&x) = &&&&&mut Some(&0u8) {
|
||||
| -^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&&&&&mut`
|
||||
| ^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: make the implied reference patterns explicit
|
||||
|
|
||||
LL | if let &&&&&mut Some(&x) = &&&&&mut Some(&0u8) {
|
||||
| ++++++++
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:99:12
|
||||
error: this pattern relies on behavior which may change in edition 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
|
||||
|
|
||||
= 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>
|
||||
help: desugar the match ergonomics
|
||||
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: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:111:9
|
||||
error: this pattern relies on behavior which may change in edition 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
|
||||
|
|
||||
= 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>
|
||||
help: desugar the match ergonomics
|
||||
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: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:117:9
|
||||
error: this pattern relies on behavior which may change in edition 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
|
||||
| |
|
||||
| cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: desugar the match ergonomics
|
||||
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: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:124:12
|
||||
error: this pattern relies on behavior which may change in edition 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
|
||||
| |
|
||||
| cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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>
|
||||
help: desugar the match ergonomics
|
||||
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: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/migration_lint.rs:137:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/migration_lint.rs:137:15
|
||||
|
|
||||
LL | (Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
|
||||
| -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ default binding mode is reset within expansion
|
||||
| |
|
||||
| requires binding by-value, but the implicit default is by-reference
|
||||
|
|
||||
= 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)
|
||||
help: make the implied reference pattern explicit
|
||||
|
|
||||
LL | &(Some(mut x), migration_lint_macros::mixed_edition_pat!(y)) => {
|
||||
| +
|
||||
|
||||
error: aborting due to 16 previous errors
|
||||
|
||||
|
||||
@ -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 patterns are not allowed to reset the default binding mode
|
||||
test_pat_on_type![(&x,): &(&T,)]; //~ ERROR this pattern relies on behavior which may change in edition 2024
|
||||
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 patterns are not allowed to reset the default binding mode
|
||||
test_pat_on_type![(&mut x,): &(&mut T,)]; //~ ERROR this pattern relies on behavior which may change in edition 2024
|
||||
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 patterns are not allowed to reset the default binding mode
|
||||
test_pat_on_type![(mut x,): &(T,)]; //~ ERROR patterns are not allowed to reset the default binding mode
|
||||
test_pat_on_type![(ref x,): &(T,)]; //~ ERROR patterns are not allowed to reset the default binding mode
|
||||
test_pat_on_type![(ref mut x,): &mut (T,)]; //~ ERROR patterns are not allowed to reset the default binding mode
|
||||
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
|
||||
|
||||
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 patterns are not allowed to reset the default binding mode
|
||||
(&x,) => x, //~ ERROR this pattern relies on behavior which may change in edition 2024
|
||||
}
|
||||
}
|
||||
|
||||
@ -99,61 +99,89 @@ LL - test_pat_on_type![Foo { f: (&x,) }: &mut Foo];
|
||||
LL + test_pat_on_type![Foo { f: (x,) }: &mut Foo];
|
||||
|
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:24:19
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:24:20
|
||||
|
|
||||
LL | test_pat_on_type![(&x,): &(&T,)];
|
||||
| -^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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
|
||||
|
|
||||
LL | test_pat_on_type![&(&x,): &(&T,)];
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:27:19
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:27:20
|
||||
|
|
||||
LL | test_pat_on_type![(&mut x,): &(&mut T,)];
|
||||
| -^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^^^^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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
|
||||
|
|
||||
LL | test_pat_on_type![&(&mut x,): &(&mut T,)];
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:31:19
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:31:28
|
||||
|
|
||||
LL | test_pat_on_type![Foo { f: &(x,) }: &Foo];
|
||||
| -^^^^^^^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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
|
||||
|
|
||||
LL | test_pat_on_type![&Foo { f: &(x,) }: &Foo];
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:32:19
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:32:20
|
||||
|
|
||||
LL | test_pat_on_type![(mut x,): &(T,)];
|
||||
| -^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^^^ requires binding by-value, but the implicit default is by-reference
|
||||
|
|
||||
= 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
|
||||
|
|
||||
LL | test_pat_on_type![&(mut x,): &(T,)];
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:33:19
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:33:20
|
||||
|
|
||||
LL | test_pat_on_type![(ref x,): &(T,)];
|
||||
| -^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^^^ cannot override to bind by-reference when that is the implicit default
|
||||
|
|
||||
= 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
|
||||
|
|
||||
LL | test_pat_on_type![&(ref x,): &(T,)];
|
||||
| +
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:34:19
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:34:20
|
||||
|
|
||||
LL | test_pat_on_type![(ref mut x,): &mut (T,)];
|
||||
| -^^^^^^^^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&mut`
|
||||
| ^^^^^^^ cannot override to bind by-reference when that is the implicit default
|
||||
|
|
||||
= 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
|
||||
|
|
||||
LL | test_pat_on_type![&mut (ref mut x,): &mut (T,)];
|
||||
| ++++
|
||||
|
||||
error: patterns are not allowed to reset the default binding mode in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:43:9
|
||||
error: this pattern relies on behavior which may change in edition 2024
|
||||
--> $DIR/min_match_ergonomics_fail.rs:43:10
|
||||
|
|
||||
LL | (&x,) => x,
|
||||
| -^^^^
|
||||
| |
|
||||
| help: desugar the match ergonomics: `&`
|
||||
| ^ cannot implicitly match against multiple layers of reference
|
||||
|
|
||||
= 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
|
||||
|
|
||||
LL | &(&x,) => x,
|
||||
| +
|
||||
|
||||
error: aborting due to 13 previous errors
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user