Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 93544d5

Browse files
Jules-BertholetJules-Bertholet
committed
Match ergonomics 2024: Implement eat-one-layer
1 parent 63f70b3 commit 93544d5

File tree

10 files changed

+472
-51
lines changed

10 files changed

+472
-51
lines changed

‎compiler/rustc_feature/src/unstable.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -571,6 +571,8 @@ declare_features! (
571571
(unstable, proc_macro_hygiene, "1.30.0", Some(54727)),
572572
/// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.
573573
(unstable, raw_ref_op, "1.41.0", Some(64490)),
574+
/// Makes `&` and `&mut` patterns eat only one layer of references in Rust 2024.
575+
(incomplete, ref_pat_eat_one_layer_2024, "CURRENT_RUSTC_VERSION", Some(123076)),
574576
/// Allows `&` and `&mut` patterns to consume match-ergonomics-inserted references.
575577
(incomplete, ref_pat_everywhere, "CURRENT_RUSTC_VERSION", Some(123076)),
576578
/// Allows using the `#[register_tool]` attribute.

‎compiler/rustc_hir_typeck/src/pat.rs

Lines changed: 69 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -294,7 +294,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
294294
AdjustMode::Pass => (expected, def_bm, false),
295295
AdjustMode::Reset => (expected, INITIAL_BM, false),
296296
AdjustMode::ResetAndConsumeRef(mutbl) => {
297-
(expected, INITIAL_BM, def_bm.0 == ByRef::Yes(mutbl))
297+
let mutbls_match = def_bm.0 == ByRef::Yes(mutbl);
298+
if pat.span.at_least_rust_2024() && self.tcx.features().ref_pat_eat_one_layer_2024 {
299+
if mutbls_match {
300+
(expected, INITIAL_BM, true)
301+
} else {
302+
(expected, def_bm, false)
303+
}
304+
} else {
305+
(expected, INITIAL_BM, mutbls_match)
306+
}
298307
}
299308
AdjustMode::Peel => {
300309
let peeled = self.peel_off_references(pat, expected, def_bm);
@@ -2056,61 +2065,70 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
20562065
pat_info: PatInfo<'tcx, '_>,
20572066
consumed_inherited_ref: bool,
20582067
) -> Ty<'tcx> {
2059-
let tcx = self.tcx;
2060-
let expected = self.shallow_resolve(expected);
2061-
let (ref_ty, inner_ty) = match self.check_dereferenceable(pat.span, expected, inner) {
2062-
Ok(()) => {
2063-
// `demand::subtype` would be good enough, but using `eqtype` turns
2064-
// out to be equally general. See (note_1) for details.
2065-
2066-
// Take region, inner-type from expected type if we can,
2067-
// to avoid creating needless variables. This also helps with
2068-
// the bad interactions of the given hack detailed in (note_1).
2069-
debug!("check_pat_ref: expected={:?}", expected);
2070-
match *expected.kind() {
2071-
ty::Ref(_, r_ty, r_mutbl) if r_mutbl == mutbl => (expected, r_ty),
2072-
_ => {
2073-
if consumed_inherited_ref && self.tcx.features().ref_pat_everywhere {
2074-
// We already matched against a match-ergonmics inserted reference,
2075-
// so we don't need to match against a reference from the original type.
2076-
// Save this infor for use in lowering later
2077-
self.typeck_results
2078-
.borrow_mut()
2079-
.skipped_ref_pats_mut()
2080-
.insert(pat.hir_id);
2081-
(expected, expected)
2082-
} else {
2083-
let inner_ty = self.next_ty_var(TypeVariableOrigin {
2084-
param_def_id: None,
2085-
span: inner.span,
2086-
});
2087-
let ref_ty = self.new_ref_ty(pat.span, mutbl, inner_ty);
2088-
debug!("check_pat_ref: demanding {:?} = {:?}", expected, ref_ty);
2089-
let err = self.demand_eqtype_pat_diag(
2090-
pat.span,
2091-
expected,
2092-
ref_ty,
2093-
pat_info.top_info,
2094-
);
2068+
if consumed_inherited_ref
2069+
&& pat.span.at_least_rust_2024()
2070+
&& self.tcx.features().ref_pat_eat_one_layer_2024
2071+
{
2072+
self.typeck_results.borrow_mut().skipped_ref_pats_mut().insert(pat.hir_id);
2073+
self.check_pat(inner, expected, pat_info);
2074+
expected
2075+
} else {
2076+
let tcx = self.tcx;
2077+
let expected = self.shallow_resolve(expected);
2078+
let (ref_ty, inner_ty) = match self.check_dereferenceable(pat.span, expected, inner) {
2079+
Ok(()) => {
2080+
// `demand::subtype` would be good enough, but using `eqtype` turns
2081+
// out to be equally general. See (note_1) for details.
2082+
2083+
// Take region, inner-type from expected type if we can,
2084+
// to avoid creating needless variables. This also helps with
2085+
// the bad interactions of the given hack detailed in (note_1).
2086+
debug!("check_pat_ref: expected={:?}", expected);
2087+
match *expected.kind() {
2088+
ty::Ref(_, r_ty, r_mutbl) if r_mutbl == mutbl => (expected, r_ty),
2089+
_ => {
2090+
if consumed_inherited_ref && self.tcx.features().ref_pat_everywhere {
2091+
// We already matched against a match-ergonmics inserted reference,
2092+
// so we don't need to match against a reference from the original type.
2093+
// Save this infor for use in lowering later
2094+
self.typeck_results
2095+
.borrow_mut()
2096+
.skipped_ref_pats_mut()
2097+
.insert(pat.hir_id);
2098+
(expected, expected)
2099+
} else {
2100+
let inner_ty = self.next_ty_var(TypeVariableOrigin {
2101+
param_def_id: None,
2102+
span: inner.span,
2103+
});
2104+
let ref_ty = self.new_ref_ty(pat.span, mutbl, inner_ty);
2105+
debug!("check_pat_ref: demanding {:?} = {:?}", expected, ref_ty);
2106+
let err = self.demand_eqtype_pat_diag(
2107+
pat.span,
2108+
expected,
2109+
ref_ty,
2110+
pat_info.top_info,
2111+
);
20952112

2096-
// Look for a case like `fn foo(&foo: u32)` and suggest
2097-
// `fn foo(foo: &u32)`
2098-
if let Some(mut err) = err {
2099-
self.borrow_pat_suggestion(&mut err, pat);
2100-
err.emit();
2113+
// Look for a case like `fn foo(&foo: u32)` and suggest
2114+
// `fn foo(foo: &u32)`
2115+
if let Some(mut err) = err {
2116+
self.borrow_pat_suggestion(&mut err, pat);
2117+
err.emit();
2118+
}
2119+
(ref_ty, inner_ty)
21012120
}
2102-
(ref_ty, inner_ty)
21032121
}
21042122
}
21052123
}
2106-
}
2107-
Err(guar) => {
2108-
let err = Ty::new_error(tcx, guar);
2109-
(err, err)
2110-
}
2111-
};
2112-
self.check_pat(inner, inner_ty, pat_info);
2113-
ref_ty
2124+
Err(guar) => {
2125+
let err = Ty::new_error(tcx, guar);
2126+
(err, err)
2127+
}
2128+
};
2129+
self.check_pat(inner, inner_ty, pat_info);
2130+
ref_ty
2131+
}
21142132
}
21152133

21162134
/// Create a reference type with a fresh region variable.

‎compiler/rustc_span/src/symbol.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1460,6 +1460,7 @@ symbols! {
14601460
receiver,
14611461
recursion_limit,
14621462
reexport_test_harness_main,
1463+
ref_pat_eat_one_layer_2024,
14631464
ref_pat_everywhere,
14641465
ref_unwind_safe_trait,
14651466
reference,

‎tests/ui/match/ref_pat_eat_one_layer_2024/feature-gate-ref_pat_eat_one_layer_2024.rs

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
//@ edition: 2024
2+
//@ compile-flags: -Zunstable-options
3+
4+
pub fn main() {
5+
if let Some(Some(&x)) = &Some(&Some(0)) {
6+
//~^ ERROR: mismatched types
7+
let _: u32 = x;
8+
}
9+
if let Some(Some(&x)) = &Some(Some(&0)) {
10+
let _: &u32 = x;
11+
//~^ ERROR: mismatched types
12+
}
13+
if let Some(Some(&&x)) = &Some(Some(&0)) {
14+
//~^ ERROR: mismatched types
15+
let _: u32 = x;
16+
}
17+
if let Some(&Some(x)) = &Some(Some(0)) {
18+
//~^ ERROR: mismatched types
19+
let _: u32 = x;
20+
}
21+
if let Some(Some(&mut x)) = &mut Some(&mut Some(0)) {
22+
//~^ ERROR: mismatched types
23+
let _: u32 = x;
24+
}
25+
if let Some(Some(&x)) = &Some(&Some(0)) {
26+
//~^ ERROR: mismatched types
27+
let _: u32 = x;
28+
}
29+
if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
30+
//~^ ERROR: mismatched types
31+
let _: u32 = x;
32+
}
33+
if let Some(&Some(&mut x)) = &mut Some(&Some(0)) {
34+
//~^ ERROR: mismatched types
35+
let _: u32 = x;
36+
}
37+
}

‎tests/ui/match/ref_pat_eat_one_layer_2024/feature-gate-ref_pat_eat_one_layer_2024.stderr

Lines changed: 128 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,128 @@
1+
error[E0308]: mismatched types
2+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:5:22
3+
|
4+
LL | if let Some(Some(&x)) = &Some(&Some(0)) {
5+
| ^^ --------------- this expression has type `&Option<&Option<{integer}>>`
6+
| |
7+
| expected integer, found `&_`
8+
|
9+
= note: expected type `{integer}`
10+
found reference `&_`
11+
help: consider removing `&` from the pattern
12+
|
13+
LL | if let Some(Some(x)) = &Some(&Some(0)) {
14+
| ~
15+
16+
error[E0308]: mismatched types
17+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:10:23
18+
|
19+
LL | let _: &u32 = x;
20+
| ---- ^ expected `&u32`, found integer
21+
| |
22+
| expected due to this
23+
|
24+
help: consider borrowing here
25+
|
26+
LL | let _: &u32 = &x;
27+
| +
28+
29+
error[E0308]: mismatched types
30+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:13:23
31+
|
32+
LL | if let Some(Some(&&x)) = &Some(Some(&0)) {
33+
| ^^ --------------- this expression has type `&Option<Option<&{integer}>>`
34+
| |
35+
| expected integer, found `&_`
36+
|
37+
= note: expected type `{integer}`
38+
found reference `&_`
39+
help: consider removing `&` from the pattern
40+
|
41+
LL - if let Some(Some(&&x)) = &Some(Some(&0)) {
42+
LL + if let Some(Some(&x)) = &Some(Some(&0)) {
43+
|
44+
45+
error[E0308]: mismatched types
46+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:17:17
47+
|
48+
LL | if let Some(&Some(x)) = &Some(Some(0)) {
49+
| ^^^^^^^^ -------------- this expression has type `&Option<Option<{integer}>>`
50+
| |
51+
| expected `Option<{integer}>`, found `&_`
52+
|
53+
= note: expected enum `Option<{integer}>`
54+
found reference `&_`
55+
56+
error[E0308]: mismatched types
57+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:21:22
58+
|
59+
LL | if let Some(Some(&mut x)) = &mut Some(&mut Some(0)) {
60+
| ^^^^^^ ----------------------- this expression has type `&mut Option<&mut Option<{integer}>>`
61+
| |
62+
| expected integer, found `&mut _`
63+
|
64+
= note: expected type `{integer}`
65+
found mutable reference `&mut _`
66+
note: to declare a mutable binding use: `mut x`
67+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:21:22
68+
|
69+
LL | if let Some(Some(&mut x)) = &mut Some(&mut Some(0)) {
70+
| ^^^^^^
71+
help: consider removing `&mut` from the pattern
72+
|
73+
LL | if let Some(Some(x)) = &mut Some(&mut Some(0)) {
74+
| ~
75+
76+
error[E0308]: mismatched types
77+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:25:22
78+
|
79+
LL | if let Some(Some(&x)) = &Some(&Some(0)) {
80+
| ^^ --------------- this expression has type `&Option<&Option<{integer}>>`
81+
| |
82+
| expected integer, found `&_`
83+
|
84+
= note: expected type `{integer}`
85+
found reference `&_`
86+
help: consider removing `&` from the pattern
87+
|
88+
LL | if let Some(Some(x)) = &Some(&Some(0)) {
89+
| ~
90+
91+
error[E0308]: mismatched types
92+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:29:27
93+
|
94+
LL | if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
95+
| ^^ ------------------- this expression has type `&Option<&mut Option<{integer}>>`
96+
| |
97+
| expected integer, found `&_`
98+
|
99+
= note: expected type `{integer}`
100+
found reference `&_`
101+
help: consider removing `&` from the pattern
102+
|
103+
LL | if let Some(&mut Some(x)) = &Some(&mut Some(0)) {
104+
| ~
105+
106+
error[E0308]: mismatched types
107+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:33:23
108+
|
109+
LL | if let Some(&Some(&mut x)) = &mut Some(&Some(0)) {
110+
| ^^^^^^ ------------------- this expression has type `&mut Option<&Option<{integer}>>`
111+
| |
112+
| expected integer, found `&mut _`
113+
|
114+
= note: expected type `{integer}`
115+
found mutable reference `&mut _`
116+
note: to declare a mutable binding use: `mut x`
117+
--> $DIR/feature-gate-ref_pat_eat_one_layer_2024.rs:33:23
118+
|
119+
LL | if let Some(&Some(&mut x)) = &mut Some(&Some(0)) {
120+
| ^^^^^^
121+
help: consider removing `&mut` from the pattern
122+
|
123+
LL | if let Some(&Some(x)) = &mut Some(&Some(0)) {
124+
| ~
125+
126+
error: aborting due to 8 previous errors
127+
128+
For more information about this error, try `rustc --explain E0308`.

‎tests/ui/match/ref_pat_eat_one_layer_2024/ref_pat_eat_one_layer_2021.rs

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
//@ edition: 2021
2+
#![allow(incomplete_features)]
3+
#![feature(ref_pat_eat_one_layer_2024)]
4+
pub fn main() {
5+
if let Some(Some(&x)) = &Some(&Some(0)) {
6+
//~^ ERROR: mismatched types
7+
let _: u32 = x;
8+
}
9+
if let Some(Some(&x)) = &Some(Some(&0)) {
10+
let _: &u32 = x;
11+
//~^ ERROR: mismatched types
12+
}
13+
if let Some(Some(&&x)) = &Some(Some(&0)) {
14+
//~^ ERROR: mismatched types
15+
let _: u32 = x;
16+
}
17+
if let Some(&Some(x)) = &Some(Some(0)) {
18+
//~^ ERROR: mismatched types
19+
let _: u32 = x;
20+
}
21+
if let Some(Some(&mut x)) = &mut Some(&mut Some(0)) {
22+
//~^ ERROR: mismatched types
23+
let _: u32 = x;
24+
}
25+
if let Some(Some(&x)) = &Some(&Some(0)) {
26+
//~^ ERROR: mismatched types
27+
let _: u32 = x;
28+
}
29+
if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
30+
//~^ ERROR: mismatched types
31+
let _: u32 = x;
32+
}
33+
if let Some(&Some(&mut x)) = &mut Some(&Some(0)) {
34+
//~^ ERROR: mismatched types
35+
let _: u32 = x;
36+
}
37+
}

0 commit comments

Comments
 (0)