mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a733082be9
rust/tests/ui/pattern/pat-tuple-underfield.stderr

168 lines
4.6 KiB
Plaintext
Raw Normal View History

Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
error[E0532]: expected unit struct, unit variant or constant, found tuple variant `E::S`
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
--> $DIR/pat-tuple-underfield.rs:56:9
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | S(i32, f32),
| ----------- `E::S` defined here
...
LL | E::S => {}
| ^^^^ help: use the tuple variant pattern syntax instead: `E::S(_, _)`
error[E0023]: this pattern has 1 field, but the corresponding tuple struct has 2 fields
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
--> $DIR/pat-tuple-underfield.rs:9:11
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | struct S(i32, f32);
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
| --- --- tuple struct has 2 fields
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
...
LL | S(x) => {}
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
| ^ expected 2 fields, found 1
Always show suggestions in their own subwindows
2021-01-12 21:06:20 -06:00
|
help: use `_` to explicitly ignore each field
|
LL | S(x, _) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| +++
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
error[E0023]: this pattern has 1 field, but the corresponding tuple struct has 2 fields
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
--> $DIR/pat-tuple-underfield.rs:14:11
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | struct S(i32, f32);
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
| --- --- tuple struct has 2 fields
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
...
LL | S(_) => {}
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
| ^ expected 2 fields, found 1
Always show suggestions in their own subwindows
2021-01-12 21:06:20 -06:00
|
help: use `_` to explicitly ignore each field
|
LL | S(_, _) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| +++
Include `..` suggestion if fields are all wildcards
2021-01-12 22:39:51 -06:00
help: use `..` to ignore all fields
|
LL | S(..) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| ~~
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
error[E0023]: this pattern has 0 fields, but the corresponding tuple struct has 2 fields
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
--> $DIR/pat-tuple-underfield.rs:20:9
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | struct S(i32, f32);
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
| --- --- tuple struct has 2 fields
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
...
LL | S() => {}
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
| ^^^ expected 2 fields, found 0
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
help: use `_` to explicitly ignore each field
|
LL | S(_, _) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| ++++
Specialize `..` help message for all fields vs. the rest
2020-12-18 22:17:09 -06:00
help: use `..` to ignore all fields
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | S(..) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| ++
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
error[E0023]: this pattern has 0 fields, but the corresponding tuple struct has 2 fields
--> $DIR/pat-tuple-underfield.rs:26:9
|
LL | struct S(i32, f32);
| --- --- tuple struct has 2 fields
...
LL | S () => {}
| ^^^^ expected 2 fields, found 0
|
help: use `_` to explicitly ignore each field
|
LL | S (_, _) => {}
| ++++
help: use `..` to ignore all fields
|
LL | S (..) => {}
| ++
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
error[E0023]: this pattern has 1 field, but the corresponding tuple variant has 2 fields
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
--> $DIR/pat-tuple-underfield.rs:33:14
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | S(i32, f32),
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
| --- --- tuple variant has 2 fields
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
...
LL | E::S(x) => {}
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
| ^ expected 2 fields, found 1
Always show suggestions in their own subwindows
2021-01-12 21:06:20 -06:00
|
help: use `_` to explicitly ignore each field
|
LL | E::S(x, _) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| +++
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
error[E0023]: this pattern has 1 field, but the corresponding tuple variant has 2 fields
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
--> $DIR/pat-tuple-underfield.rs:38:14
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | S(i32, f32),
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
| --- --- tuple variant has 2 fields
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
...
LL | E::S(_) => {}
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
| ^ expected 2 fields, found 1
Always show suggestions in their own subwindows
2021-01-12 21:06:20 -06:00
|
help: use `_` to explicitly ignore each field
|
LL | E::S(_, _) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| +++
Include `..` suggestion if fields are all wildcards
2021-01-12 22:39:51 -06:00
help: use `..` to ignore all fields
|
LL | E::S(..) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| ~~
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
error[E0023]: this pattern has 0 fields, but the corresponding tuple variant has 2 fields
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
--> $DIR/pat-tuple-underfield.rs:44:9
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | S(i32, f32),
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
| --- --- tuple variant has 2 fields
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
...
LL | E::S() => {}
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
| ^^^^^^ expected 2 fields, found 0
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
help: use `_` to explicitly ignore each field
|
LL | E::S(_, _) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| ++++
Specialize `..` help message for all fields vs. the rest
2020-12-18 22:17:09 -06:00
help: use `..` to ignore all fields
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
|
LL | E::S(..) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| ++
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
error[E0023]: this pattern has 0 fields, but the corresponding tuple variant has 2 fields
--> $DIR/pat-tuple-underfield.rs:50:9
|
LL | S(i32, f32),
| --- --- tuple variant has 2 fields
...
LL | E::S () => {}
| ^^^^^^^ expected 2 fields, found 0
|
help: use `_` to explicitly ignore each field
|
LL | E::S (_, _) => {}
| ++++
help: use `..` to ignore all fields
|
LL | E::S (..) => {}
| ++
Add a test case with lots of whitespace
2021-01-12 18:47:04 -06:00
error[E0023]: this pattern has 2 fields, but the corresponding tuple struct has 4 fields
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
--> $DIR/pat-tuple-underfield.rs:62:19
Add a test case with lots of whitespace
2021-01-12 18:47:04 -06:00
|
LL | struct Point4(i32, i32, i32, i32);
Make E0023 spans even more precise
2021-08-18 18:13:52 -05:00
| --- --- --- --- tuple struct has 4 fields
Add a test case with lots of whitespace
2021-01-12 18:47:04 -06:00
...
LL | Point4( a , _ ) => {}
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
| ^ ^ expected 4 fields, found 2
Add a test case with lots of whitespace
2021-01-12 18:47:04 -06:00
|
help: use `_` to explicitly ignore each field
|
LL | Point4( a , _ , _, _) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| ++++++
Add a test case with lots of whitespace
2021-01-12 18:47:04 -06:00
help: use `..` to ignore the rest of the fields
|
Account for existing `_` field pattern when suggesting `..` Follow up to #80017.
2021-01-26 18:53:56 -06:00
LL | Point4( a, ..) => {}
Modify structured suggestion output * On suggestions that include deletions, use a diff inspired output format * When suggesting addition, use `+` as underline * Color highlight modified span
2021-06-21 21:07:19 -05:00
| ~~~~
Add a test case with lots of whitespace
2021-01-12 18:47:04 -06:00
Adjust spans * Highlight the whole pattern if it has no fields * Highlight the whole definition if it has no fields * Only highlight the pattern name if the pattern is multi-line * Determine whether a pattern is multi-line based on distance from name to last field, rather than first field
2021-08-25 16:40:06 -05:00
error: aborting due to 10 previous errors
Suggest `_` and `..` if a pattern has too few fields For example, this code: struct S(i32, f32); let S(x) = S(0, 1.0); will make the compiler suggest either: let S(x, _) = S(0, 1.0); or: let S(x, ..) = S(0, 1.0);
2020-12-13 16:13:52 -06:00
Some errors have detailed explanations: E0023, E0532.
For more information about an error, try `rustc --explain E0023`.
Reference in New Issue Copy Permalink