os-rust/tests/ui/pattern/usefulness/floats.stderr

error[E0004]: non-exhaustive patterns: `_` not covered
  --> $DIR/floats.rs:11:11
   |
LL |     match 0.0 {
   |           ^^^ pattern `_` not covered
   |
   = note: the matched value is of type `f64`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
   |
LL ~         0.0..=1.0 => {},
LL +         _ => todo!()
   |

error: unreachable pattern
  --> $DIR/floats.rs:18:9
   |
LL |         0.01f16..=6.5f16 => {}
   |         ---------------- matches all the values already
LL |         0.01f16 => {}
   |         ^^^^^^^ unreachable pattern
   |
note: the lint level is defined here
  --> $DIR/floats.rs:1:9
   |
LL | #![deny(unreachable_patterns)]
   |         ^^^^^^^^^^^^^^^^^^^^

error: unreachable pattern
  --> $DIR/floats.rs:19:9
   |
LL |         0.01f16..=6.5f16 => {}
   |         ---------------- matches all the values already
LL |         0.01f16 => {}
LL |         0.02f16 => {}
   |         ^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:20:9
   |
LL |         0.01f16..=6.5f16 => {}
   |         ---------------- matches all the values already
...
LL |         6.5f16 => {}
   |         ^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:31:9
   |
LL |         0.01f32..=6.5f32 => {}
   |         ---------------- matches all the values already
LL |         0.01f32 => {}
   |         ^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:32:9
   |
LL |         0.01f32..=6.5f32 => {}
   |         ---------------- matches all the values already
LL |         0.01f32 => {}
LL |         0.02f32 => {}
   |         ^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:33:9
   |
LL |         0.01f32..=6.5f32 => {}
   |         ---------------- matches all the values already
...
LL |         6.5f32 => {}
   |         ^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:45:9
   |
LL |         0.01f64..=6.5f64 => {}
   |         ---------------- matches all the values already
LL |         0.005f64 => {}
LL |         0.01f64 => {}
   |         ^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:46:9
   |
LL |         0.01f64..=6.5f64 => {}
   |         ---------------- matches all the values already
...
LL |         0.02f64 => {}
   |         ^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:47:9
   |
LL |         0.01f64..=6.5f64 => {}
   |         ---------------- matches all the values already
...
LL |         6.5f64 => {}
   |         ^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:49:9
   |
LL |         0.01f64..=6.5f64 => {}
   |         ---------------- matches all the values already
...
LL |         1.0f64..=4.0f64 => {}
   |         ^^^^^^^^^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:62:9
   |
LL |         0.01f128..=6.5f128 => {}
   |         ------------------ matches all the values already
LL |         0.005f128 => {}
LL |         0.01f128 => {}
   |         ^^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:63:9
   |
LL |         0.01f128..=6.5f128 => {}
   |         ------------------ matches all the values already
...
LL |         0.02f128 => {}
   |         ^^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:64:9
   |
LL |         0.01f128..=6.5f128 => {}
   |         ------------------ matches all the values already
...
LL |         6.5f128 => {}
   |         ^^^^^^^ unreachable pattern

error: unreachable pattern
  --> $DIR/floats.rs:66:9
   |
LL |         0.01f128..=6.5f128 => {}
   |         ------------------ matches all the values already
...
LL |         1.0f128..=4.0f128 => {}
   |         ^^^^^^^^^^^^^^^^^ unreachable pattern

error: aborting due to 15 previous errors

For more information about this error, try `rustc --explain E0004`.
Fix bug in matching on floating-point ranges 2018-11-30 21:13:16 +00:00			error[E0004]: non-exhaustive patterns: `_` not covered
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`--> $DIR/floats.rs:11:11`
Fix bug in matching on floating-point ranges 2018-11-30 21:13:16 +00:00			`\|`
Update tests 2019-03-09 15:03:44 +03:00			`LL \| match 0.0 {`
Fix bug in matching on floating-point ranges 2018-11-30 21:13:16 +00:00			\| ^^^ pattern `_` not covered
Point at enum definition when match patterns are not exhaustive ``` error[E0004]: non-exhaustive patterns: type `X` is non-empty --> file.rs:9:11 \| 1 \| / enum X { 2 \| \| A, \| \| - variant not covered 3 \| \| B, \| \| - variant not covered 4 \| \| C, \| \| - variant not covered 5 \| \| } \| \|_- `X` defined here ... 9 \| match x { \| ^ \| = help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms error[E0004]: non-exhaustive patterns: `B` and `C` not covered --> file.rs:11:11 \| 1 \| / enum X { 2 \| \| A, 3 \| \| B, 4 \| \| C, \| \| - not covered 5 \| \| } \| \|_- `X` defined here ... 11 \| match x { \| ^ patterns `C` not covered ``` When a match expression doesn't have patterns covering every variant, point at the enum's definition span. On a best effort basis, point at the variant(s) that are missing. This does not handle the case when the missing pattern is due to a field's enum variants: ``` enum E1 { A, B, C, } enum E2 { A(E1), B, } fn foo() { match E2::A(E1::A) { E2::A(E1::B) => {} E2::B => {} } //~^ ERROR `E2::A(E1::A)` and `E2::A(E1::C)` not handled } ``` Unify look between match with no arms and match with some missing patterns. Fix #37518. 2019-02-10 05:12:00 -08:00			`\|`
non-exhastive diagnostic: add note re. scrutinee type 2020-03-27 06:44:30 +01:00			= note: the matched value is of type `f64`
Change wording of suggestion to add missing `match` arm 2021-12-16 22:46:13 +00:00			`help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown`
When finding a match expr with a single arm that requires more, suggest it Given ```rust match Some(42) { Some(0) => {} } ``` suggest ```rust match Some(42) { Some(0) => {} None \| Some(_) => todo!(), } ``` 2021-12-16 02:14:17 +00:00			`\|`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`LL ~ 0.0..=1.0 => {},`
			`LL + _ => todo!()`
When finding a match expr with a single arm that requires more, suggest it Given ```rust match Some(42) { Some(0) => {} } ``` suggest ```rust match Some(42) { Some(0) => {} None \| Some(_) => todo!(), } ``` 2021-12-16 02:14:17 +00:00			`\|`
Fix bug in matching on floating-point ranges 2018-11-30 21:13:16 +00:00
Improve integer range tests 2020-11-20 19:03:56 +00:00			`error: unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`--> $DIR/floats.rs:18:9`
Improve integer range tests 2020-11-20 19:03:56 +00:00			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f16..=6.5f16 => {}`
			`\| ---------------- matches all the values already`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 0.01f16 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^ unreachable pattern`
Improve integer range tests 2020-11-20 19:03:56 +00:00			`\|`
			`note: the lint level is defined here`
Stabilize exclusive_range 2024-04-27 20:35:32 -04:00			`--> $DIR/floats.rs:1:9`
Improve integer range tests 2020-11-20 19:03:56 +00:00			`\|`
			`LL \| #![deny(unreachable_patterns)]`
			`\| ^^^^^^^^^^^^^^^^^^^^`

Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`error: unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`--> $DIR/floats.rs:19:9`
			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f16..=6.5f16 => {}`
			`\| ---------------- matches all the values already`
			`LL \| 0.01f16 => {}`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 0.02f16 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^ unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00
			`error: unreachable pattern`
			`--> $DIR/floats.rs:20:9`
			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f16..=6.5f16 => {}`
			`\| ---------------- matches all the values already`
			`...`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 6.5f16 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^ unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00
			`error: unreachable pattern`
			`--> $DIR/floats.rs:31:9`
			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f32..=6.5f32 => {}`
			`\| ---------------- matches all the values already`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 0.01f32 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^ unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00
			`error: unreachable pattern`
			`--> $DIR/floats.rs:32:9`
			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f32..=6.5f32 => {}`
			`\| ---------------- matches all the values already`
			`LL \| 0.01f32 => {}`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 0.02f32 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^ unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00
			`error: unreachable pattern`
			`--> $DIR/floats.rs:33:9`
			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f32..=6.5f32 => {}`
			`\| ---------------- matches all the values already`
			`...`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 6.5f32 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^ unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00
			`error: unreachable pattern`
			`--> $DIR/floats.rs:45:9`
			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f64..=6.5f64 => {}`
			`\| ---------------- matches all the values already`
			`LL \| 0.005f64 => {}`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 0.01f64 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^ unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00
			`error: unreachable pattern`
			`--> $DIR/floats.rs:46:9`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f64..=6.5f64 => {}`
			`\| ---------------- matches all the values already`
			`...`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`LL \| 0.02f64 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^ unreachable pattern`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00
			`error: unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`--> $DIR/floats.rs:47:9`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f64..=6.5f64 => {}`
			`\| ---------------- matches all the values already`
			`...`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`LL \| 6.5f64 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^ unreachable pattern`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00
			`error: unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`--> $DIR/floats.rs:49:9`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f64..=6.5f64 => {}`
			`\| ---------------- matches all the values already`
			`...`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`LL \| 1.0f64..=4.0f64 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^^^^^^^^^ unreachable pattern`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00
			`error: unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`--> $DIR/floats.rs:62:9`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f128..=6.5f128 => {}`
			`\| ------------------ matches all the values already`
			`LL \| 0.005f128 => {}`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 0.01f128 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^^ unreachable pattern`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00
			`error: unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`--> $DIR/floats.rs:63:9`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f128..=6.5f128 => {}`
			`\| ------------------ matches all the values already`
			`...`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 0.02f128 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^^ unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00
			`error: unreachable pattern`
			`--> $DIR/floats.rs:64:9`
			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f128..=6.5f128 => {}`
			`\| ------------------ matches all the values already`
			`...`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 6.5f128 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^ unreachable pattern`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00
			`error: unreachable pattern`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`--> $DIR/floats.rs:66:9`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00			`\|`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`LL \| 0.01f128..=6.5f128 => {}`
			`\| ------------------ matches all the values already`
			`...`
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`LL \| 1.0f128..=4.0f128 => {}`
Explain why a given pattern is considered unreachable 2024-07-21 14:46:05 +02:00			`\| ^^^^^^^^^^^^^^^^^ unreachable pattern`
Evaluate float consts eagerly 2023-09-29 18:33:07 +02:00
Replace `f16` and `f128` pattern matching stubs with real implementations This section of code depends on `rustc_apfloat` rather than our internal types, so this is one potential ICE that we should be able to melt now. This also fixes some missing range and match handling in `rustc_middle`. 2024-03-26 06:01:09 -04:00			`error: aborting due to 15 previous errors`
Fix bug in matching on floating-point ranges 2018-11-30 21:13:16 +00:00
			For more information about this error, try `rustc --explain E0004`.