Skip to content

Commit 8aa46e5

Browse files
ManishearthManishearth
authored
Rollup merge of #88123 - camelid:tup-pat-precise-spans, r=estebank
Make spans for tuple patterns in E0023 more precise As suggested in #86307. Closes #86307. r? ````@estebank````
2 parents fb79597 + 8a6501d commit 8aa46e5

19 files changed

+1165
-77
lines changed

‎compiler/rustc_hir/src/hir.rs

+33-2
Original file line numberDiff line numberDiff line change
@@ -3183,6 +3183,20 @@ pub enum Node<'hir> {
31833183
}
31843184

31853185
impl<'hir> Node<'hir> {
3186+
/// Get the identifier of this `Node`, if applicable.
3187+
///
3188+
/// # Edge cases
3189+
///
3190+
/// Calling `.ident()` on a [`Node::Ctor`] will return `None`
3191+
/// because `Ctor`s do not have identifiers themselves.
3192+
/// Instead, call `.ident()` on the parent struct/variant, like so:
3193+
///
3194+
/// ```ignore (illustrative)
3195+
/// ctor
3196+
/// .ctor_hir_id()
3197+
/// .and_then(|ctor_id| tcx.hir().find(tcx.hir().get_parent_node(ctor_id)))
3198+
/// .and_then(|parent| parent.ident())
3199+
/// ```
31863200
pub fn ident(&self) -> Option<Ident> {
31873201
match self {
31883202
Node::TraitItem(TraitItem { ident, .. })
@@ -3191,8 +3205,25 @@ impl<'hir> Node<'hir> {
31913205
| Node::Field(FieldDef { ident, .. })
31923206
| Node::Variant(Variant { ident, .. })
31933207
| Node::MacroDef(MacroDef { ident, .. })
3194-
| Node::Item(Item { ident, .. }) => Some(*ident),
3195-
_ => None,
3208+
| Node::Item(Item { ident, .. })
3209+
| Node::PathSegment(PathSegment { ident, .. }) => Some(*ident),
3210+
Node::Lifetime(lt) => Some(lt.name.ident()),
3211+
Node::GenericParam(p) => Some(p.name.ident()),
3212+
Node::Param(..)
3213+
| Node::AnonConst(..)
3214+
| Node::Expr(..)
3215+
| Node::Stmt(..)
3216+
| Node::Block(..)
3217+
| Node::Ctor(..)
3218+
| Node::Pat(..)
3219+
| Node::Binding(..)
3220+
| Node::Arm(..)
3221+
| Node::Local(..)
3222+
| Node::Visibility(..)
3223+
| Node::Crate(..)
3224+
| Node::Ty(..)
3225+
| Node::TraitRef(..)
3226+
| Node::Infer(..) => None,
31963227
}
31973228
}
31983229

‎compiler/rustc_ty_utils/src/ty.rs

+12-1
Original file line numberDiff line numberDiff line change
@@ -223,7 +223,18 @@ fn associated_items(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItems<'_> {
223223
}
224224

225225
fn def_ident_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
226-
tcx.hir().get_if_local(def_id).and_then(|node| node.ident()).map(|ident| ident.span)
226+
tcx.hir()
227+
.get_if_local(def_id)
228+
.and_then(|node| match node {
229+
// A `Ctor` doesn't have an identifier itself, but its parent
230+
// struct/variant does. Compare with `hir::Map::opt_span`.
231+
hir::Node::Ctor(ctor) => ctor
232+
.ctor_hir_id()
233+
.and_then(|ctor_id| tcx.hir().find(tcx.hir().get_parent_node(ctor_id)))
234+
.and_then(|parent| parent.ident()),
235+
_ => node.ident(),
236+
})
237+
.map(|ident| ident.span)
227238
}
228239

229240
/// If the given `DefId` describes an item belonging to a trait,

‎compiler/rustc_typeck/src/check/pat.rs

+33-6
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ use rustc_span::hygiene::DesugaringKind;
1515
use rustc_span::lev_distance::find_best_match_for_name;
1616
use rustc_span::source_map::{Span, Spanned};
1717
use rustc_span::symbol::Ident;
18-
use rustc_span::{BytePos, DUMMY_SP};
18+
use rustc_span::{BytePos, MultiSpan, DUMMY_SP};
1919
use rustc_trait_selection::autoderef::Autoderef;
2020
use rustc_trait_selection::traits::{ObligationCause, Pattern};
2121
use ty::VariantDef;
@@ -990,10 +990,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
990990
) {
991991
let subpats_ending = pluralize!(subpats.len());
992992
let fields_ending = pluralize!(fields.len());
993+
994+
let subpat_spans = if subpats.is_empty() {
995+
vec![pat_span]
996+
} else {
997+
subpats.iter().map(|p| p.span).collect()
998+
};
999+
let last_subpat_span = *subpat_spans.last().unwrap();
9931000
let res_span = self.tcx.def_span(res.def_id());
1001+
let def_ident_span = self.tcx.def_ident_span(res.def_id()).unwrap_or(res_span);
1002+
let field_def_spans = if fields.is_empty() {
1003+
vec![res_span]
1004+
} else {
1005+
fields.iter().map(|f| f.ident.span).collect()
1006+
};
1007+
let last_field_def_span = *field_def_spans.last().unwrap();
1008+
9941009
let mut err = struct_span_err!(
9951010
self.tcx.sess,
996-
pat_span,
1011+
MultiSpan::from_spans(subpat_spans.clone()),
9971012
E0023,
9981013
"this pattern has {} field{}, but the corresponding {} has {} field{}",
9991014
subpats.len(),
@@ -1003,10 +1018,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
10031018
fields_ending,
10041019
);
10051020
err.span_label(
1006-
pat_span,
1007-
format!("expected {} field{}, found {}", fields.len(), fields_ending, subpats.len(),),
1008-
)
1009-
.span_label(res_span, format!("{} defined here", res.descr()));
1021+
last_subpat_span,
1022+
&format!("expected {} field{}, found {}", fields.len(), fields_ending, subpats.len()),
1023+
);
1024+
if self.tcx.sess.source_map().is_multiline(qpath.span().between(last_subpat_span)) {
1025+
err.span_label(qpath.span(), "");
1026+
}
1027+
if self.tcx.sess.source_map().is_multiline(def_ident_span.between(last_field_def_span)) {
1028+
err.span_label(def_ident_span, format!("{} defined here", res.descr()));
1029+
}
1030+
for span in &field_def_spans[..field_def_spans.len() - 1] {
1031+
err.span_label(*span, "");
1032+
}
1033+
err.span_label(
1034+
last_field_def_span,
1035+
&format!("{} has {} field{}", res.descr(), fields.len(), fields_ending),
1036+
);
10101037

10111038
// Identify the case `Some(x, y)` where the expected type is e.g. `Option<(T, U)>`.
10121039
// More generally, the expected type wants a tuple variant with one field of an

‎src/test/ui/destructuring-assignment/tuple_struct_destructure_fail.stderr

+12-12
Original file line numberDiff line numberDiff line change
@@ -15,22 +15,22 @@ LL | Enum::SingleVariant(a, .., b, ..) = Enum::SingleVariant(0, 1);
1515
| previously used here
1616

1717
error[E0023]: this pattern has 3 fields, but the corresponding tuple struct has 2 fields
18-
--> $DIR/tuple_struct_destructure_fail.rs:30:5
18+
--> $DIR/tuple_struct_destructure_fail.rs:30:17
1919
|
2020
LL | struct TupleStruct<S, T>(S, T);
21-
| ------------------------------- tuple struct defined here
21+
| - - tuple struct has 2 fields
2222
...
2323
LL | TupleStruct(a, a, b) = TupleStruct(1, 2);
24-
| ^^^^^^^^^^^^^^^^^^^^ expected 2 fields, found 3
24+
| ^ ^ ^ expected 2 fields, found 3
2525

2626
error[E0023]: this pattern has 1 field, but the corresponding tuple struct has 2 fields
27-
--> $DIR/tuple_struct_destructure_fail.rs:32:5
27+
--> $DIR/tuple_struct_destructure_fail.rs:32:17
2828
|
2929
LL | struct TupleStruct<S, T>(S, T);
30-
| ------------------------------- tuple struct defined here
30+
| - - tuple struct has 2 fields
3131
...
3232
LL | TupleStruct(_) = TupleStruct(1, 2);
33-
| ^^^^^^^^^^^^^^ expected 2 fields, found 1
33+
| ^ expected 2 fields, found 1
3434
|
3535
help: use `_` to explicitly ignore each field
3636
|
@@ -42,22 +42,22 @@ LL | TupleStruct(..) = TupleStruct(1, 2);
4242
| ~~
4343

4444
error[E0023]: this pattern has 3 fields, but the corresponding tuple variant has 2 fields
45-
--> $DIR/tuple_struct_destructure_fail.rs:34:5
45+
--> $DIR/tuple_struct_destructure_fail.rs:34:25
4646
|
4747
LL | SingleVariant(S, T)
48-
| ------------------- tuple variant defined here
48+
| - - tuple variant has 2 fields
4949
...
5050
LL | Enum::SingleVariant(a, a, b) = Enum::SingleVariant(1, 2);
51-
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected 2 fields, found 3
51+
| ^ ^ ^ expected 2 fields, found 3
5252

5353
error[E0023]: this pattern has 1 field, but the corresponding tuple variant has 2 fields
54-
--> $DIR/tuple_struct_destructure_fail.rs:36:5
54+
--> $DIR/tuple_struct_destructure_fail.rs:36:25
5555
|
5656
LL | SingleVariant(S, T)
57-
| ------------------- tuple variant defined here
57+
| - - tuple variant has 2 fields
5858
...
5959
LL | Enum::SingleVariant(_) = Enum::SingleVariant(1, 2);
60-
| ^^^^^^^^^^^^^^^^^^^^^^ expected 2 fields, found 1
60+
| ^ expected 2 fields, found 1
6161
|
6262
help: use `_` to explicitly ignore each field
6363
|

‎src/test/ui/error-codes/E0023.stderr

+13-13
Original file line numberDiff line numberDiff line change
@@ -1,43 +1,43 @@
11
error[E0023]: this pattern has 1 field, but the corresponding tuple variant has 2 fields
2-
--> $DIR/E0023.rs:11:9
2+
--> $DIR/E0023.rs:11:22
33
|
44
LL | Apple(String, String),
5-
| --------------------- tuple variant defined here
5+
| ------ ------ tuple variant has 2 fields
66
...
77
LL | Fruit::Apple(a) => {},
8-
| ^^^^^^^^^^^^^^^ expected 2 fields, found 1
8+
| ^ expected 2 fields, found 1
99
|
1010
help: use `_` to explicitly ignore each field
1111
|
1212
LL | Fruit::Apple(a, _) => {},
1313
| +++
1414

1515
error[E0023]: this pattern has 3 fields, but the corresponding tuple variant has 2 fields
16-
--> $DIR/E0023.rs:12:9
16+
--> $DIR/E0023.rs:12:22
1717
|
1818
LL | Apple(String, String),
19-
| --------------------- tuple variant defined here
19+
| ------ ------ tuple variant has 2 fields
2020
...
2121
LL | Fruit::Apple(a, b, c) => {},
22-
| ^^^^^^^^^^^^^^^^^^^^^ expected 2 fields, found 3
22+
| ^ ^ ^ expected 2 fields, found 3
2323

2424
error[E0023]: this pattern has 2 fields, but the corresponding tuple variant has 1 field
25-
--> $DIR/E0023.rs:13:9
25+
--> $DIR/E0023.rs:13:21
2626
|
2727
LL | Pear(u32),
28-
| --------- tuple variant defined here
28+
| --- tuple variant has 1 field
2929
...
3030
LL | Fruit::Pear(1, 2) => {},
31-
| ^^^^^^^^^^^^^^^^^ expected 1 field, found 2
31+
| ^ ^ expected 1 field, found 2
3232

3333
error[E0023]: this pattern has 2 fields, but the corresponding tuple variant has 1 field
34-
--> $DIR/E0023.rs:14:9
34+
--> $DIR/E0023.rs:14:23
3535
|
3636
LL | Orange((String, String)),
37-
| ------------------------ tuple variant defined here
37+
| ---------------- tuple variant has 1 field
3838
...
3939
LL | Fruit::Orange(a, b) => {},
40-
| ^^^^^^^^^^^^^^^^^^^ expected 1 field, found 2
40+
| ^ ^ expected 1 field, found 2
4141
|
4242
help: missing parentheses
4343
|
@@ -48,7 +48,7 @@ error[E0023]: this pattern has 0 fields, but the corresponding tuple variant has
4848
--> $DIR/E0023.rs:15:9
4949
|
5050
LL | Banana(()),
51-
| ---------- tuple variant defined here
51+
| -- tuple variant has 1 field
5252
...
5353
LL | Fruit::Banana() => {},
5454
| ^^^^^^^^^^^^^^^ expected 1 field, found 0

‎src/test/ui/issues/issue-72574-2.stderr

+3-3
Original file line numberDiff line numberDiff line change
@@ -19,13 +19,13 @@ LL | Binder(_a, _x @ ..) => {}
1919
= note: only allowed in tuple, tuple struct, and slice patterns
2020

2121
error[E0023]: this pattern has 2 fields, but the corresponding tuple struct has 3 fields
22-
--> $DIR/issue-72574-2.rs:6:9
22+
--> $DIR/issue-72574-2.rs:6:16
2323
|
2424
LL | struct Binder(i32, i32, i32);
25-
| ----------------------------- tuple struct defined here
25+
| --- --- --- tuple struct has 3 fields
2626
...
2727
LL | Binder(_a, _x @ ..) => {}
28-
| ^^^^^^^^^^^^^^^^^^^ expected 3 fields, found 2
28+
| ^^ ^^^^^^^ expected 3 fields, found 2
2929
|
3030
help: use `_` to explicitly ignore each field
3131
|

‎src/test/ui/match/match-pattern-field-mismatch.stderr

+3-3
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
error[E0023]: this pattern has 2 fields, but the corresponding tuple variant has 3 fields
2-
--> $DIR/match-pattern-field-mismatch.rs:10:11
2+
--> $DIR/match-pattern-field-mismatch.rs:10:22
33
|
44
LL | Rgb(usize, usize, usize),
5-
| ------------------------ tuple variant defined here
5+
| ----- ----- ----- tuple variant has 3 fields
66
...
77
LL | Color::Rgb(_, _) => { }
8-
| ^^^^^^^^^^^^^^^^ expected 3 fields, found 2
8+
| ^ ^ expected 3 fields, found 2
99
|
1010
help: use `_` to explicitly ignore each field
1111
|

‎src/test/ui/pattern/auxiliary/declarations-for-tuple-field-count-errors.rs

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
pub struct Z0;
2+
pub struct Z1();
3+
4+
pub struct S(pub u8, pub u8, pub u8);
5+
pub struct M(
6+
pub u8,
7+
pub u8,
8+
pub u8,
9+
);
10+
11+
pub enum E1 { Z0, Z1(), S(u8, u8, u8) }
12+
13+
pub enum E2 {
14+
S(u8, u8, u8),
15+
M(
16+
u8,
17+
u8,
18+
u8,
19+
),
20+
}

‎src/test/ui/pattern/issue-67037-pat-tup-scrut-ty-diff-less-fields.stderr

+1-1
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ error[E0023]: this pattern has 0 fields, but the corresponding tuple struct has
1313
--> $DIR/issue-67037-pat-tup-scrut-ty-diff-less-fields.rs:19:9
1414
|
1515
LL | struct P<T>(T); // 1 type parameter wanted
16-
| --------------- tuple struct defined here
16+
| - tuple struct has 1 field
1717
...
1818
LL | let P() = U {};
1919
| ^^^ expected 1 field, found 0

‎src/test/ui/pattern/issue-74539.stderr

+3-3
Original file line numberDiff line numberDiff line change
@@ -19,13 +19,13 @@ LL | E::A(x @ ..) => {
1919
= note: only allowed in tuple, tuple struct, and slice patterns
2020

2121
error[E0023]: this pattern has 1 field, but the corresponding tuple variant has 2 fields
22-
--> $DIR/issue-74539.rs:8:9
22+
--> $DIR/issue-74539.rs:8:14
2323
|
2424
LL | A(u8, u8),
25-
| --------- tuple variant defined here
25+
| -- -- tuple variant has 2 fields
2626
...
2727
LL | E::A(x @ ..) => {
28-
| ^^^^^^^^^^^^ expected 2 fields, found 1
28+
| ^^^^^^ expected 2 fields, found 1
2929
|
3030
help: use `_` to explicitly ignore each field
3131
|

‎src/test/ui/pattern/pat-tuple-field-count-cross.rs

+57
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
// aux-build:declarations-for-tuple-field-count-errors.rs
2+
3+
extern crate declarations_for_tuple_field_count_errors;
4+
5+
use declarations_for_tuple_field_count_errors::*;
6+
7+
fn main() {
8+
match Z0 {
9+
Z0() => {} //~ ERROR expected tuple struct or tuple variant, found unit struct `Z0`
10+
Z0(x) => {} //~ ERROR expected tuple struct or tuple variant, found unit struct `Z0`
11+
}
12+
match Z1() {
13+
Z1 => {} //~ ERROR match bindings cannot shadow tuple structs
14+
Z1(x) => {} //~ ERROR this pattern has 1 field, but the corresponding tuple struct has 0 fields
15+
}
16+
17+
match S(1, 2, 3) {
18+
S() => {} //~ ERROR this pattern has 0 fields, but the corresponding tuple struct has 3 fields
19+
S(1) => {} //~ ERROR this pattern has 1 field, but the corresponding tuple struct has 3 fields
20+
S(xyz, abc) => {} //~ ERROR this pattern has 2 fields, but the corresponding tuple struct has 3 fields
21+
S(1, 2, 3, 4) => {} //~ ERROR this pattern has 4 fields, but the corresponding tuple struct has 3 fields
22+
}
23+
match M(1, 2, 3) {
24+
M() => {} //~ ERROR this pattern has 0 fields, but the corresponding tuple struct has 3 fields
25+
M(1) => {} //~ ERROR this pattern has 1 field, but the corresponding tuple struct has 3 fields
26+
M(xyz, abc) => {} //~ ERROR this pattern has 2 fields, but the corresponding tuple struct has 3 fields
27+
M(1, 2, 3, 4) => {} //~ ERROR this pattern has 4 fields, but the corresponding tuple struct has 3 fields
28+
}
29+
30+
match E1::Z0 {
31+
E1::Z0() => {} //~ ERROR expected tuple struct or tuple variant, found unit variant `E1::Z0`
32+
E1::Z0(x) => {} //~ ERROR expected tuple struct or tuple variant, found unit variant `E1::Z0`
33+
}
34+
match E1::Z1() {
35+
E1::Z1 => {} //~ ERROR expected unit struct, unit variant or constant, found tuple variant `E1::Z1`
36+
E1::Z1(x) => {} //~ ERROR this pattern has 1 field, but the corresponding tuple variant has 0 fields
37+
}
38+
match E1::S(1, 2, 3) {
39+
E1::S() => {} //~ ERROR this pattern has 0 fields, but the corresponding tuple variant has 3 fields
40+
E1::S(1) => {} //~ ERROR this pattern has 1 field, but the corresponding tuple variant has 3 fields
41+
E1::S(xyz, abc) => {} //~ ERROR this pattern has 2 fields, but the corresponding tuple variant has 3 fields
42+
E1::S(1, 2, 3, 4) => {} //~ ERROR this pattern has 4 fields, but the corresponding tuple variant has 3 fields
43+
}
44+
45+
match E2::S(1, 2, 3) {
46+
E2::S() => {} //~ ERROR this pattern has 0 fields, but the corresponding tuple variant has 3 fields
47+
E2::S(1) => {} //~ ERROR this pattern has 1 field, but the corresponding tuple variant has 3 fields
48+
E2::S(xyz, abc) => {} //~ ERROR this pattern has 2 fields, but the corresponding tuple variant has 3 fields
49+
E2::S(1, 2, 3, 4) => {} //~ ERROR this pattern has 4 fields, but the corresponding tuple variant has 3 fields
50+
}
51+
match E2::M(1, 2, 3) {
52+
E2::M() => {} //~ ERROR this pattern has 0 fields, but the corresponding tuple variant has 3 fields
53+
E2::M(1) => {} //~ ERROR this pattern has 1 field, but the corresponding tuple variant has 3 fields
54+
E2::M(xyz, abc) => {} //~ ERROR this pattern has 2 fields, but the corresponding tuple variant has 3 fields
55+
E2::M(1, 2, 3, 4) => {} //~ ERROR this pattern has 4 fields, but the corresponding tuple variant has 3 fields
56+
}
57+
}

0 commit comments

Comments
 (0)