mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-25 16:24:46 +00:00
Rollup merge of #116284 - RalfJung:no-nan-match, r=cjgillot
make matching on NaN a hard error, and remove the rest of illegal_floating_point_literal_pattern These arms would never be hit anyway, so the pattern makes little sense. We have had a future-compat lint against float matches in general for a *long* time, so I hope we can get away with immediately making this a hard error. This is part of implementing https://github.com/rust-lang/rfcs/pull/3535. Closes https://github.com/rust-lang/rust/issues/41620 by removing the lint. https://github.com/rust-lang/reference/pull/1456 updates the reference to match.
This commit is contained in:
Matthias Krüger
GitHub
commit
ed27148812
@ -516,6 +516,10 @@ fn register_builtins(store: &mut LintStore) {
|
||||
"converted into hard error, see PR #118649 \
|
||||
<https://github.com/rust-lang/rust/pull/118649> for more information",
|
||||
);
|
||||
store.register_removed(
|
||||
"illegal_floating_point_literal_pattern",
|
||||
"no longer a warning, float patterns behave the same as `==`",
|
||||
);
|
||||
}
|
||||
|
||||
fn register_internals(store: &mut LintStore) {
|
||||
|
||||
@ -45,7 +45,6 @@ declare_lint_pass! {
|
||||
FUZZY_PROVENANCE_CASTS,
|
||||
HIDDEN_GLOB_REEXPORTS,
|
||||
ILL_FORMED_ATTRIBUTE_INPUT,
|
||||
ILLEGAL_FLOATING_POINT_LITERAL_PATTERN,
|
||||
INCOMPLETE_INCLUDE,
|
||||
INDIRECT_STRUCTURAL_MATCH,
|
||||
INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
|
||||
@ -1873,55 +1872,6 @@ declare_lint! {
|
||||
};
|
||||
}
|
||||
|
||||
declare_lint! {
|
||||
/// The `illegal_floating_point_literal_pattern` lint detects
|
||||
/// floating-point literals used in patterns.
|
||||
///
|
||||
/// ### Example
|
||||
///
|
||||
/// ```rust
|
||||
/// let x = 42.0;
|
||||
///
|
||||
/// match x {
|
||||
/// 5.0 => {}
|
||||
/// _ => {}
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// {{produces}}
|
||||
///
|
||||
/// ### Explanation
|
||||
///
|
||||
/// Previous versions of the compiler accepted floating-point literals in
|
||||
/// patterns, but it was later determined this was a mistake. The
|
||||
/// semantics of comparing floating-point values may not be clear in a
|
||||
/// pattern when contrasted with "structural equality". Typically you can
|
||||
/// work around this by using a [match guard], such as:
|
||||
///
|
||||
/// ```rust
|
||||
/// # let x = 42.0;
|
||||
///
|
||||
/// match x {
|
||||
/// y if y == 5.0 => {}
|
||||
/// _ => {}
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// This is a [future-incompatible] lint to transition this to a hard
|
||||
/// error in the future. See [issue #41620] for more details.
|
||||
///
|
||||
/// [issue #41620]: https://github.com/rust-lang/rust/issues/41620
|
||||
/// [match guard]: https://doc.rust-lang.org/reference/expressions/match-expr.html#match-guards
|
||||
/// [future-incompatible]: ../index.md#future-incompatible-lints
|
||||
pub ILLEGAL_FLOATING_POINT_LITERAL_PATTERN,
|
||||
Warn,
|
||||
"floating-point literals cannot be used in patterns",
|
||||
@future_incompatible = FutureIncompatibleInfo {
|
||||
reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
|
||||
reference: "issue #41620 <https://github.com/rust-lang/rust/issues/41620>",
|
||||
};
|
||||
}
|
||||
|
||||
declare_lint! {
|
||||
/// The `unstable_name_collisions` lint detects that you have used a name
|
||||
/// that the standard library plans to add in the future.
|
||||
|
||||
@ -418,8 +418,8 @@ impl<'tcx, Prov: Provenance> Scalar<Prov> {
|
||||
|
||||
#[inline]
|
||||
pub fn to_float<F: Float>(self) -> InterpResult<'tcx, F> {
|
||||
// Going through `to_uint` to check size and truncation.
|
||||
Ok(F::from_bits(self.to_uint(Size::from_bits(F::BITS))?))
|
||||
// Going through `to_bits` to check size and truncation.
|
||||
Ok(F::from_bits(self.to_bits(Size::from_bits(F::BITS))?))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
||||
@ -249,11 +249,6 @@ impl ScalarInt {
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn try_to_target_usize(&self, tcx: TyCtxt<'_>) -> Result<u64, Size> {
|
||||
Ok(self.to_bits(tcx.data_layout.pointer_size)? as u64)
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to an unsigned integer of the given size.
|
||||
/// Fails if the size of the `ScalarInt` is not equal to `size` and returns the
|
||||
/// `ScalarInt`s size in that case.
|
||||
@ -262,6 +257,51 @@ impl ScalarInt {
|
||||
self.to_bits(size)
|
||||
}
|
||||
|
||||
// Tries to convert the `ScalarInt` to `u8`. Fails if the `size` of the `ScalarInt`
|
||||
// in not equal to `Size { raw: 1 }` and returns the `size` value of the `ScalarInt` in
|
||||
// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u8(self) -> Result<u8, Size> {
|
||||
self.try_to_uint(Size::from_bits(8)).map(|v| u8::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to `u16`. Fails if the size of the `ScalarInt`
|
||||
/// in not equal to `Size { raw: 2 }` and returns the `size` value of the `ScalarInt` in
|
||||
/// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u16(self) -> Result<u16, Size> {
|
||||
self.try_to_uint(Size::from_bits(16)).map(|v| u16::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to `u32`. Fails if the `size` of the `ScalarInt`
|
||||
/// in not equal to `Size { raw: 4 }` and returns the `size` value of the `ScalarInt` in
|
||||
/// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u32(self) -> Result<u32, Size> {
|
||||
self.try_to_uint(Size::from_bits(32)).map(|v| u32::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to `u64`. Fails if the `size` of the `ScalarInt`
|
||||
/// in not equal to `Size { raw: 8 }` and returns the `size` value of the `ScalarInt` in
|
||||
/// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u64(self) -> Result<u64, Size> {
|
||||
self.try_to_uint(Size::from_bits(64)).map(|v| u64::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to `u128`. Fails if the `size` of the `ScalarInt`
|
||||
/// in not equal to `Size { raw: 16 }` and returns the `size` value of the `ScalarInt` in
|
||||
/// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u128(self) -> Result<u128, Size> {
|
||||
self.try_to_uint(Size::from_bits(128))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn try_to_target_usize(&self, tcx: TyCtxt<'_>) -> Result<u64, Size> {
|
||||
self.try_to_uint(tcx.data_layout.pointer_size).map(|v| u64::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
// Tries to convert the `ScalarInt` to `bool`. Fails if the `size` of the `ScalarInt`
|
||||
// in not equal to `Size { raw: 1 }` or if the value is not 0 or 1 and returns the `size`
|
||||
// value of the `ScalarInt` in that case.
|
||||
@ -274,46 +314,6 @@ impl ScalarInt {
|
||||
}
|
||||
}
|
||||
|
||||
// Tries to convert the `ScalarInt` to `u8`. Fails if the `size` of the `ScalarInt`
|
||||
// in not equal to `Size { raw: 1 }` and returns the `size` value of the `ScalarInt` in
|
||||
// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u8(self) -> Result<u8, Size> {
|
||||
self.to_bits(Size::from_bits(8)).map(|v| u8::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to `u16`. Fails if the size of the `ScalarInt`
|
||||
/// in not equal to `Size { raw: 2 }` and returns the `size` value of the `ScalarInt` in
|
||||
/// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u16(self) -> Result<u16, Size> {
|
||||
self.to_bits(Size::from_bits(16)).map(|v| u16::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to `u32`. Fails if the `size` of the `ScalarInt`
|
||||
/// in not equal to `Size { raw: 4 }` and returns the `size` value of the `ScalarInt` in
|
||||
/// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u32(self) -> Result<u32, Size> {
|
||||
self.to_bits(Size::from_bits(32)).map(|v| u32::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to `u64`. Fails if the `size` of the `ScalarInt`
|
||||
/// in not equal to `Size { raw: 8 }` and returns the `size` value of the `ScalarInt` in
|
||||
/// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u64(self) -> Result<u64, Size> {
|
||||
self.to_bits(Size::from_bits(64)).map(|v| u64::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to `u128`. Fails if the `size` of the `ScalarInt`
|
||||
/// in not equal to `Size { raw: 16 }` and returns the `size` value of the `ScalarInt` in
|
||||
/// that case.
|
||||
#[inline]
|
||||
pub fn try_to_u128(self) -> Result<u128, Size> {
|
||||
self.to_bits(Size::from_bits(128))
|
||||
}
|
||||
|
||||
/// Tries to convert the `ScalarInt` to a signed integer of the given size.
|
||||
/// Fails if the size of the `ScalarInt` is not equal to `size` and returns the
|
||||
/// `ScalarInt`s size in that case.
|
||||
@ -357,6 +357,27 @@ impl ScalarInt {
|
||||
pub fn try_to_i128(self) -> Result<i128, Size> {
|
||||
self.try_to_int(Size::from_bits(128))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn try_to_target_isize(&self, tcx: TyCtxt<'_>) -> Result<i64, Size> {
|
||||
self.try_to_int(tcx.data_layout.pointer_size).map(|v| i64::try_from(v).unwrap())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn try_to_float<F: Float>(self) -> Result<F, Size> {
|
||||
// Going through `to_uint` to check size and truncation.
|
||||
Ok(F::from_bits(self.to_bits(Size::from_bits(F::BITS))?))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn try_to_f32(self) -> Result<Single, Size> {
|
||||
self.try_to_float()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn try_to_f64(self) -> Result<Double, Size> {
|
||||
self.try_to_float()
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! from {
|
||||
@ -399,11 +420,7 @@ impl TryFrom<ScalarInt> for bool {
|
||||
type Error = Size;
|
||||
#[inline]
|
||||
fn try_from(int: ScalarInt) -> Result<Self, Size> {
|
||||
int.to_bits(Size::from_bytes(1)).and_then(|u| match u {
|
||||
0 => Ok(false),
|
||||
1 => Ok(true),
|
||||
_ => Err(Size::from_bytes(1)),
|
||||
})
|
||||
int.try_to_bool()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -107,8 +107,6 @@ mir_build_extern_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
|
||||
.note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
|
||||
.label = use of extern static
|
||||
|
||||
mir_build_float_pattern = floating-point types cannot be used in patterns
|
||||
|
||||
mir_build_indirect_structural_match =
|
||||
to use a constant of type `{$non_sm_ty}` in a pattern, `{$non_sm_ty}` must be annotated with `#[derive(PartialEq)]`
|
||||
|
||||
@ -232,6 +230,10 @@ mir_build_mutation_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsa
|
||||
.note = mutating layout constrained fields cannot statically be checked for valid values
|
||||
.label = mutation of layout constrained field
|
||||
|
||||
mir_build_nan_pattern = cannot use NaN in patterns
|
||||
.note = NaNs compare inequal to everything, even themselves, so this pattern would never match
|
||||
.help = try using the `is_nan` method instead
|
||||
|
||||
mir_build_non_const_path = runtime values cannot be referenced in patterns
|
||||
|
||||
mir_build_non_empty_never_pattern =
|
||||
|
||||
@ -780,9 +780,14 @@ pub struct UnsizedPattern<'tcx> {
|
||||
pub non_sm_ty: Ty<'tcx>,
|
||||
}
|
||||
|
||||
#[derive(LintDiagnostic)]
|
||||
#[diag(mir_build_float_pattern)]
|
||||
pub struct FloatPattern;
|
||||
#[derive(Diagnostic)]
|
||||
#[diag(mir_build_nan_pattern)]
|
||||
#[note]
|
||||
#[help]
|
||||
pub struct NaNPattern {
|
||||
#[primary_span]
|
||||
pub span: Span,
|
||||
}
|
||||
|
||||
#[derive(LintDiagnostic)]
|
||||
#[diag(mir_build_pointer_pattern)]
|
||||
|
||||
@ -1,3 +1,4 @@
|
||||
use rustc_apfloat::Float;
|
||||
use rustc_hir as hir;
|
||||
use rustc_hir::def_id::DefId;
|
||||
use rustc_index::Idx;
|
||||
@ -16,7 +17,7 @@ use std::cell::Cell;
|
||||
|
||||
use super::PatCtxt;
|
||||
use crate::errors::{
|
||||
FloatPattern, IndirectStructuralMatch, InvalidPattern, NonPartialEqMatch,
|
||||
IndirectStructuralMatch, InvalidPattern, NaNPattern, NonPartialEqMatch,
|
||||
NontrivialStructuralMatch, PointerPattern, TypeNotStructural, UnionPattern, UnsizedPattern,
|
||||
};
|
||||
|
||||
@ -317,16 +318,6 @@ impl<'tcx> ConstToPat<'tcx> {
|
||||
let param_env = self.param_env;
|
||||
|
||||
let kind = match ty.kind() {
|
||||
ty::Float(_) => {
|
||||
self.saw_const_match_lint.set(true);
|
||||
tcx.emit_node_span_lint(
|
||||
lint::builtin::ILLEGAL_FLOATING_POINT_LITERAL_PATTERN,
|
||||
id,
|
||||
span,
|
||||
FloatPattern,
|
||||
);
|
||||
return Err(FallbackToOpaqueConst);
|
||||
}
|
||||
// If the type is not structurally comparable, just emit the constant directly,
|
||||
// causing the pattern match code to treat it opaquely.
|
||||
// FIXME: This code doesn't emit errors itself, the caller emits the errors.
|
||||
@ -486,6 +477,22 @@ impl<'tcx> ConstToPat<'tcx> {
|
||||
}
|
||||
}
|
||||
},
|
||||
ty::Float(flt) => {
|
||||
let v = cv.unwrap_leaf();
|
||||
let is_nan = match flt {
|
||||
ty::FloatTy::F32 => v.try_to_f32().unwrap().is_nan(),
|
||||
ty::FloatTy::F64 => v.try_to_f64().unwrap().is_nan(),
|
||||
};
|
||||
if is_nan {
|
||||
// NaNs are not ever equal to anything so they make no sense as patterns.
|
||||
// Also see <https://github.com/rust-lang/rfcs/pull/3535>.
|
||||
let e = tcx.dcx().emit_err(NaNPattern { span });
|
||||
self.saw_const_match_error.set(Some(e));
|
||||
return Err(FallbackToOpaqueConst);
|
||||
} else {
|
||||
PatKind::Constant { value: mir::Const::Ty(ty::Const::new_value(tcx, cv, ty)) }
|
||||
}
|
||||
}
|
||||
ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::RawPtr(..) => {
|
||||
// The raw pointers we see here have been "vetted" by valtree construction to be
|
||||
// just integers, so we simply allow them.
|
||||
|
||||
@ -20,12 +20,8 @@ mod rustc_ok {
|
||||
pub fn rustc_lints() {
|
||||
let x = 42.0;
|
||||
|
||||
#[expect(illegal_floating_point_literal_pattern)]
|
||||
match x {
|
||||
5.0 => {}
|
||||
6.0 => {}
|
||||
_ => {}
|
||||
}
|
||||
#[expect(invalid_nan_comparisons)]
|
||||
let _b = x == f32::NAN;
|
||||
}
|
||||
}
|
||||
|
||||
@ -38,13 +34,9 @@ mod rustc_warn {
|
||||
pub fn rustc_lints() {
|
||||
let x = 42;
|
||||
|
||||
#[expect(illegal_floating_point_literal_pattern)]
|
||||
#[expect(invalid_nan_comparisons)]
|
||||
//~^ ERROR: this lint expectation is unfulfilled
|
||||
match x {
|
||||
5 => {}
|
||||
6 => {}
|
||||
_ => {}
|
||||
}
|
||||
let _b = x == 5;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
error: this lint expectation is unfulfilled
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:35:14
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:31:14
|
||||
|
|
||||
LL | #[expect(dead_code)]
|
||||
| ^^^^^^^^^
|
||||
@ -8,31 +8,31 @@ LL | #[expect(dead_code)]
|
||||
= help: to override `-D warnings` add `#[allow(unfulfilled_lint_expectations)]`
|
||||
|
||||
error: this lint expectation is unfulfilled
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:41:18
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:37:18
|
||||
|
|
||||
LL | #[expect(illegal_floating_point_literal_pattern)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
LL | #[expect(invalid_nan_comparisons)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this lint expectation is unfulfilled
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:116:14
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:108:14
|
||||
|
|
||||
LL | #[expect(clippy::almost_swapped)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this lint expectation is unfulfilled
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:124:14
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:116:14
|
||||
|
|
||||
LL | #[expect(clippy::bytes_nth)]
|
||||
| ^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this lint expectation is unfulfilled
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:130:14
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:122:14
|
||||
|
|
||||
LL | #[expect(clippy::if_same_then_else)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this lint expectation is unfulfilled
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:136:14
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:128:14
|
||||
|
|
||||
LL | #[expect(clippy::overly_complex_bool_expr)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
@ -24,10 +24,9 @@ mod rustc_ok {
|
||||
pub fn rustc_lints() {
|
||||
let x = 42.0;
|
||||
|
||||
#[expect(illegal_floating_point_literal_pattern)]
|
||||
#[expect(invalid_nan_comparisons)]
|
||||
match x {
|
||||
5.0 => {}
|
||||
6.0 => {}
|
||||
f32::NAN => {}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
@ -40,7 +39,7 @@ mod rustc_warn {
|
||||
pub fn rustc_lints() {
|
||||
let x = 42;
|
||||
|
||||
#[expect(illegal_floating_point_literal_pattern)]
|
||||
#[expect(invalid_nan_comparisons)]
|
||||
match x {
|
||||
5 => {}
|
||||
6 => {}
|
||||
|
||||
@ -7,19 +7,19 @@ LL | #![expect(rustdoc::missing_crate_level_docs)]
|
||||
= note: `#[warn(unfulfilled_lint_expectations)]` on by default
|
||||
|
||||
warning: this lint expectation is unfulfilled
|
||||
--> $DIR/expect-tool-lint-rfc-2383.rs:71:14
|
||||
--> $DIR/expect-tool-lint-rfc-2383.rs:70:14
|
||||
|
|
||||
LL | #[expect(rustdoc::broken_intra_doc_links)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
warning: this lint expectation is unfulfilled
|
||||
--> $DIR/expect-tool-lint-rfc-2383.rs:76:14
|
||||
--> $DIR/expect-tool-lint-rfc-2383.rs:75:14
|
||||
|
|
||||
LL | #[expect(rustdoc::invalid_html_tags)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
warning: this lint expectation is unfulfilled
|
||||
--> $DIR/expect-tool-lint-rfc-2383.rs:81:14
|
||||
--> $DIR/expect-tool-lint-rfc-2383.rs:80:14
|
||||
|
|
||||
LL | #[expect(rustdoc::bare_urls)]
|
||||
| ^^^^^^^^^^^^^^^^^^
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
// run-pass
|
||||
#![allow(illegal_floating_point_literal_pattern)] // FIXME #41620
|
||||
|
||||
pub fn main() {
|
||||
let x = [1, 2, 3];
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
// run-pass
|
||||
#![allow(illegal_floating_point_literal_pattern)] // FIXME #41620
|
||||
#![feature(exclusive_range_pattern)]
|
||||
|
||||
pub fn main() {
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
// Test various non-exhaustive matches for `X..`, `..=X` and `..X` ranges.
|
||||
|
||||
#![feature(exclusive_range_pattern)]
|
||||
#![allow(illegal_floating_point_literal_pattern)]
|
||||
|
||||
fn main() {}
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
error[E0004]: non-exhaustive patterns: `_` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:15:8
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:14:8
|
||||
|
|
||||
LL | m!(0f32, f32::NEG_INFINITY..);
|
||||
| ^^^^ pattern `_` not covered
|
||||
@ -11,7 +11,7 @@ LL | match $s { $($t)+ => {}, _ => todo!() }
|
||||
| ++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `_` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:16:8
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:15:8
|
||||
|
|
||||
LL | m!(0f32, ..f32::INFINITY);
|
||||
| ^^^^ pattern `_` not covered
|
||||
@ -23,7 +23,7 @@ LL | match $s { $($t)+ => {}, _ => todo!() }
|
||||
| ++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `'\u{10ffff}'` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:25:8
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:24:8
|
||||
|
|
||||
LL | m!('a', ..core::char::MAX);
|
||||
| ^^^ pattern `'\u{10ffff}'` not covered
|
||||
@ -35,7 +35,7 @@ LL | match $s { $($t)+ => {}, '\u{10ffff}' => todo!() }
|
||||
| +++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `'\u{10fffe}'..='\u{10ffff}'` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:26:8
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:25:8
|
||||
|
|
||||
LL | m!('a', ..ALMOST_MAX);
|
||||
| ^^^ pattern `'\u{10fffe}'..='\u{10ffff}'` not covered
|
||||
@ -47,7 +47,7 @@ LL | match $s { $($t)+ => {}, '\u{10fffe}'..='\u{10ffff}' => todo!() }
|
||||
| ++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `'\0'` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:27:8
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:26:8
|
||||
|
|
||||
LL | m!('a', ALMOST_MIN..);
|
||||
| ^^^ pattern `'\0'` not covered
|
||||
@ -59,7 +59,7 @@ LL | match $s { $($t)+ => {}, '\0' => todo!() }
|
||||
| +++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `'\u{10ffff}'` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:28:8
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:27:8
|
||||
|
|
||||
LL | m!('a', ..=ALMOST_MAX);
|
||||
| ^^^ pattern `'\u{10ffff}'` not covered
|
||||
@ -71,7 +71,7 @@ LL | match $s { $($t)+ => {}, '\u{10ffff}' => todo!() }
|
||||
| +++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `'b'` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:29:8
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:28:8
|
||||
|
|
||||
LL | m!('a', ..=VAL | VAL_2..);
|
||||
| ^^^ pattern `'b'` not covered
|
||||
@ -83,7 +83,7 @@ LL | match $s { $($t)+ => {}, 'b' => todo!() }
|
||||
| ++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `'b'` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:30:8
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:29:8
|
||||
|
|
||||
LL | m!('a', ..VAL_1 | VAL_2..);
|
||||
| ^^^ pattern `'b'` not covered
|
||||
@ -95,7 +95,7 @@ LL | match $s { $($t)+ => {}, 'b' => todo!() }
|
||||
| ++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u8::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:40:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:39:12
|
||||
|
|
||||
LL | m!(0, ..u8::MAX);
|
||||
| ^ pattern `u8::MAX` not covered
|
||||
@ -107,7 +107,7 @@ LL | match $s { $($t)+ => {}, u8::MAX => todo!() }
|
||||
| ++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `254_u8..=u8::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:41:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:40:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `254_u8..=u8::MAX` not covered
|
||||
@ -119,7 +119,7 @@ LL | match $s { $($t)+ => {}, 254_u8..=u8::MAX => todo!() }
|
||||
| +++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `0_u8` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:42:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:41:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `0_u8` not covered
|
||||
@ -131,7 +131,7 @@ LL | match $s { $($t)+ => {}, 0_u8 => todo!() }
|
||||
| +++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u8::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:43:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:42:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `u8::MAX` not covered
|
||||
@ -143,7 +143,7 @@ LL | match $s { $($t)+ => {}, u8::MAX => todo!() }
|
||||
| ++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u8` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:44:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:43:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_u8` not covered
|
||||
@ -155,7 +155,7 @@ LL | match $s { $($t)+ => {}, 43_u8 => todo!() }
|
||||
| ++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u8` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:45:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:44:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_u8` not covered
|
||||
@ -167,7 +167,7 @@ LL | match $s { $($t)+ => {}, 43_u8 => todo!() }
|
||||
| ++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u16::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:53:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:52:12
|
||||
|
|
||||
LL | m!(0, ..u16::MAX);
|
||||
| ^ pattern `u16::MAX` not covered
|
||||
@ -179,7 +179,7 @@ LL | match $s { $($t)+ => {}, u16::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `65534_u16..=u16::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:54:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:53:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `65534_u16..=u16::MAX` not covered
|
||||
@ -191,7 +191,7 @@ LL | match $s { $($t)+ => {}, 65534_u16..=u16::MAX => todo!() }
|
||||
| +++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `0_u16` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:55:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:54:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `0_u16` not covered
|
||||
@ -203,7 +203,7 @@ LL | match $s { $($t)+ => {}, 0_u16 => todo!() }
|
||||
| ++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u16::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:56:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:55:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `u16::MAX` not covered
|
||||
@ -215,7 +215,7 @@ LL | match $s { $($t)+ => {}, u16::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u16` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:57:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:56:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_u16` not covered
|
||||
@ -227,7 +227,7 @@ LL | match $s { $($t)+ => {}, 43_u16 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u16` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:58:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:57:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_u16` not covered
|
||||
@ -239,7 +239,7 @@ LL | match $s { $($t)+ => {}, 43_u16 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u32::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:66:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:65:12
|
||||
|
|
||||
LL | m!(0, ..u32::MAX);
|
||||
| ^ pattern `u32::MAX` not covered
|
||||
@ -251,7 +251,7 @@ LL | match $s { $($t)+ => {}, u32::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `4294967294_u32..=u32::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:67:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:66:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `4294967294_u32..=u32::MAX` not covered
|
||||
@ -263,7 +263,7 @@ LL | match $s { $($t)+ => {}, 4294967294_u32..=u32::MAX => todo!() }
|
||||
| ++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `0_u32` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:68:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:67:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `0_u32` not covered
|
||||
@ -275,7 +275,7 @@ LL | match $s { $($t)+ => {}, 0_u32 => todo!() }
|
||||
| ++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u32::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:69:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:68:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `u32::MAX` not covered
|
||||
@ -287,7 +287,7 @@ LL | match $s { $($t)+ => {}, u32::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u32` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:70:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:69:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_u32` not covered
|
||||
@ -299,7 +299,7 @@ LL | match $s { $($t)+ => {}, 43_u32 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u32` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:71:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:70:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_u32` not covered
|
||||
@ -311,7 +311,7 @@ LL | match $s { $($t)+ => {}, 43_u32 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u64::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:79:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:78:12
|
||||
|
|
||||
LL | m!(0, ..u64::MAX);
|
||||
| ^ pattern `u64::MAX` not covered
|
||||
@ -323,7 +323,7 @@ LL | match $s { $($t)+ => {}, u64::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `18446744073709551614_u64..=u64::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:80:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:79:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `18446744073709551614_u64..=u64::MAX` not covered
|
||||
@ -335,7 +335,7 @@ LL | match $s { $($t)+ => {}, 18446744073709551614_u64..=u64::MAX => tod
|
||||
| ++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `0_u64` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:81:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:80:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `0_u64` not covered
|
||||
@ -347,7 +347,7 @@ LL | match $s { $($t)+ => {}, 0_u64 => todo!() }
|
||||
| ++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u64::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:82:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:81:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `u64::MAX` not covered
|
||||
@ -359,7 +359,7 @@ LL | match $s { $($t)+ => {}, u64::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u64` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:83:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:82:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_u64` not covered
|
||||
@ -371,7 +371,7 @@ LL | match $s { $($t)+ => {}, 43_u64 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u64` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:84:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:83:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_u64` not covered
|
||||
@ -383,7 +383,7 @@ LL | match $s { $($t)+ => {}, 43_u64 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u128::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:92:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:91:12
|
||||
|
|
||||
LL | m!(0, ..u128::MAX);
|
||||
| ^ pattern `u128::MAX` not covered
|
||||
@ -395,7 +395,7 @@ LL | match $s { $($t)+ => {}, u128::MAX => todo!() }
|
||||
| ++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `340282366920938463463374607431768211454_u128..=u128::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:93:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:92:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `340282366920938463463374607431768211454_u128..=u128::MAX` not covered
|
||||
@ -407,7 +407,7 @@ LL | match $s { $($t)+ => {}, 340282366920938463463374607431768211454_u1
|
||||
| +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `0_u128` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:94:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:93:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `0_u128` not covered
|
||||
@ -419,7 +419,7 @@ LL | match $s { $($t)+ => {}, 0_u128 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `u128::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:95:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:94:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `u128::MAX` not covered
|
||||
@ -431,7 +431,7 @@ LL | match $s { $($t)+ => {}, u128::MAX => todo!() }
|
||||
| ++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u128` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:96:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:95:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_u128` not covered
|
||||
@ -443,7 +443,7 @@ LL | match $s { $($t)+ => {}, 43_u128 => todo!() }
|
||||
| ++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_u128` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:97:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:96:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_u128` not covered
|
||||
@ -455,7 +455,7 @@ LL | match $s { $($t)+ => {}, 43_u128 => todo!() }
|
||||
| ++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i8::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:108:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:107:12
|
||||
|
|
||||
LL | m!(0, ..i8::MAX);
|
||||
| ^ pattern `i8::MAX` not covered
|
||||
@ -467,7 +467,7 @@ LL | match $s { $($t)+ => {}, i8::MAX => todo!() }
|
||||
| ++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `126_i8..=i8::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:109:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:108:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `126_i8..=i8::MAX` not covered
|
||||
@ -479,7 +479,7 @@ LL | match $s { $($t)+ => {}, 126_i8..=i8::MAX => todo!() }
|
||||
| +++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i8::MIN` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:110:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:109:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `i8::MIN` not covered
|
||||
@ -491,7 +491,7 @@ LL | match $s { $($t)+ => {}, i8::MIN => todo!() }
|
||||
| ++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i8::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:111:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:110:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `i8::MAX` not covered
|
||||
@ -503,7 +503,7 @@ LL | match $s { $($t)+ => {}, i8::MAX => todo!() }
|
||||
| ++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i8` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:112:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:111:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_i8` not covered
|
||||
@ -515,7 +515,7 @@ LL | match $s { $($t)+ => {}, 43_i8 => todo!() }
|
||||
| ++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i8` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:113:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:112:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_i8` not covered
|
||||
@ -527,7 +527,7 @@ LL | match $s { $($t)+ => {}, 43_i8 => todo!() }
|
||||
| ++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i16::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:121:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:120:12
|
||||
|
|
||||
LL | m!(0, ..i16::MAX);
|
||||
| ^ pattern `i16::MAX` not covered
|
||||
@ -539,7 +539,7 @@ LL | match $s { $($t)+ => {}, i16::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `32766_i16..=i16::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:122:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:121:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `32766_i16..=i16::MAX` not covered
|
||||
@ -551,7 +551,7 @@ LL | match $s { $($t)+ => {}, 32766_i16..=i16::MAX => todo!() }
|
||||
| +++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i16::MIN` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:123:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:122:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `i16::MIN` not covered
|
||||
@ -563,7 +563,7 @@ LL | match $s { $($t)+ => {}, i16::MIN => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i16::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:124:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:123:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `i16::MAX` not covered
|
||||
@ -575,7 +575,7 @@ LL | match $s { $($t)+ => {}, i16::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i16` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:125:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:124:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_i16` not covered
|
||||
@ -587,7 +587,7 @@ LL | match $s { $($t)+ => {}, 43_i16 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i16` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:126:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:125:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_i16` not covered
|
||||
@ -599,7 +599,7 @@ LL | match $s { $($t)+ => {}, 43_i16 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i32::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:134:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:133:12
|
||||
|
|
||||
LL | m!(0, ..i32::MAX);
|
||||
| ^ pattern `i32::MAX` not covered
|
||||
@ -611,7 +611,7 @@ LL | match $s { $($t)+ => {}, i32::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `2147483646_i32..=i32::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:135:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:134:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `2147483646_i32..=i32::MAX` not covered
|
||||
@ -623,7 +623,7 @@ LL | match $s { $($t)+ => {}, 2147483646_i32..=i32::MAX => todo!() }
|
||||
| ++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i32::MIN` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:136:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:135:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `i32::MIN` not covered
|
||||
@ -635,7 +635,7 @@ LL | match $s { $($t)+ => {}, i32::MIN => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i32::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:137:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:136:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `i32::MAX` not covered
|
||||
@ -647,7 +647,7 @@ LL | match $s { $($t)+ => {}, i32::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i32` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:138:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:137:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_i32` not covered
|
||||
@ -659,7 +659,7 @@ LL | match $s { $($t)+ => {}, 43_i32 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i32` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:139:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:138:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_i32` not covered
|
||||
@ -671,7 +671,7 @@ LL | match $s { $($t)+ => {}, 43_i32 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i64::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:147:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:146:12
|
||||
|
|
||||
LL | m!(0, ..i64::MAX);
|
||||
| ^ pattern `i64::MAX` not covered
|
||||
@ -683,7 +683,7 @@ LL | match $s { $($t)+ => {}, i64::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `9223372036854775806_i64..=i64::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:148:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:147:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `9223372036854775806_i64..=i64::MAX` not covered
|
||||
@ -695,7 +695,7 @@ LL | match $s { $($t)+ => {}, 9223372036854775806_i64..=i64::MAX => todo
|
||||
| +++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i64::MIN` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:149:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:148:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `i64::MIN` not covered
|
||||
@ -707,7 +707,7 @@ LL | match $s { $($t)+ => {}, i64::MIN => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i64::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:150:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:149:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `i64::MAX` not covered
|
||||
@ -719,7 +719,7 @@ LL | match $s { $($t)+ => {}, i64::MAX => todo!() }
|
||||
| +++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i64` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:151:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:150:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_i64` not covered
|
||||
@ -731,7 +731,7 @@ LL | match $s { $($t)+ => {}, 43_i64 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i64` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:152:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:151:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_i64` not covered
|
||||
@ -743,7 +743,7 @@ LL | match $s { $($t)+ => {}, 43_i64 => todo!() }
|
||||
| +++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i128::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:160:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:159:12
|
||||
|
|
||||
LL | m!(0, ..i128::MAX);
|
||||
| ^ pattern `i128::MAX` not covered
|
||||
@ -755,7 +755,7 @@ LL | match $s { $($t)+ => {}, i128::MAX => todo!() }
|
||||
| ++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `170141183460469231731687303715884105726_i128..=i128::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:161:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:160:12
|
||||
|
|
||||
LL | m!(0, ..ALMOST_MAX);
|
||||
| ^ pattern `170141183460469231731687303715884105726_i128..=i128::MAX` not covered
|
||||
@ -767,7 +767,7 @@ LL | match $s { $($t)+ => {}, 170141183460469231731687303715884105726_i1
|
||||
| +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i128::MIN` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:162:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:161:12
|
||||
|
|
||||
LL | m!(0, ALMOST_MIN..);
|
||||
| ^ pattern `i128::MIN` not covered
|
||||
@ -779,7 +779,7 @@ LL | match $s { $($t)+ => {}, i128::MIN => todo!() }
|
||||
| ++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `i128::MAX` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:163:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:162:12
|
||||
|
|
||||
LL | m!(0, ..=ALMOST_MAX);
|
||||
| ^ pattern `i128::MAX` not covered
|
||||
@ -791,7 +791,7 @@ LL | match $s { $($t)+ => {}, i128::MAX => todo!() }
|
||||
| ++++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i128` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:164:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:163:12
|
||||
|
|
||||
LL | m!(0, ..=VAL | VAL_2..);
|
||||
| ^ pattern `43_i128` not covered
|
||||
@ -803,7 +803,7 @@ LL | match $s { $($t)+ => {}, 43_i128 => todo!() }
|
||||
| ++++++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `43_i128` not covered
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:165:12
|
||||
--> $DIR/half-open-range-pats-exhaustive-fail.rs:164:12
|
||||
|
|
||||
LL | m!(0, ..VAL_1 | VAL_2..);
|
||||
| ^ pattern `43_i128` not covered
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
// via `.contains(...)` and make sure the dynamic semantics match.
|
||||
|
||||
#![feature(exclusive_range_pattern)]
|
||||
#![allow(illegal_floating_point_literal_pattern)]
|
||||
#![allow(unreachable_patterns)]
|
||||
|
||||
macro_rules! yes {
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
#![feature(exclusive_range_pattern)]
|
||||
#![allow(illegal_floating_point_literal_pattern)]
|
||||
|
||||
macro_rules! m {
|
||||
($s:expr, $($t:tt)+) => {
|
||||
|
||||
@ -1,77 +1,77 @@
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:11:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:10:11
|
||||
|
|
||||
LL | m!(0, ..u8::MIN);
|
||||
| ^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:13:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:12:11
|
||||
|
|
||||
LL | m!(0, ..u16::MIN);
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:15:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:14:11
|
||||
|
|
||||
LL | m!(0, ..u32::MIN);
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:17:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:16:11
|
||||
|
|
||||
LL | m!(0, ..u64::MIN);
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:19:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:18:11
|
||||
|
|
||||
LL | m!(0, ..u128::MIN);
|
||||
| ^^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:22:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:21:11
|
||||
|
|
||||
LL | m!(0, ..i8::MIN);
|
||||
| ^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:24:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:23:11
|
||||
|
|
||||
LL | m!(0, ..i16::MIN);
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:26:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:25:11
|
||||
|
|
||||
LL | m!(0, ..i32::MIN);
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:28:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:27:11
|
||||
|
|
||||
LL | m!(0, ..i64::MIN);
|
||||
| ^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:30:11
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:29:11
|
||||
|
|
||||
LL | m!(0, ..i128::MIN);
|
||||
| ^^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:33:14
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:32:14
|
||||
|
|
||||
LL | m!(0f32, ..f32::NEG_INFINITY);
|
||||
| ^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:35:14
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:34:14
|
||||
|
|
||||
LL | m!(0f64, ..f64::NEG_INFINITY);
|
||||
| ^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:38:13
|
||||
--> $DIR/half-open-range-pats-thir-lower-empty.rs:37:13
|
||||
|
|
||||
LL | m!('a', ..'\u{0}');
|
||||
| ^^^^^^^^^
|
||||
|
||||
@ -1,15 +0,0 @@
|
||||
// Regression test for #86600, where an instance of the
|
||||
// `illegal_floating_point_literal_pattern` lint was issued twice.
|
||||
|
||||
// check-pass
|
||||
|
||||
fn main() {
|
||||
let x = 42.0;
|
||||
|
||||
match x {
|
||||
5.0 => {}
|
||||
//~^ WARNING: floating-point types cannot be used in patterns
|
||||
//~| WARNING: this was previously accepted by the compiler
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
@ -1,12 +0,0 @@
|
||||
warning: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-86600-lint-twice.rs:10:9
|
||||
|
|
||||
LL | 5.0 => {}
|
||||
| ^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
= note: `#[warn(illegal_floating_point_literal_pattern)]` on by default
|
||||
|
||||
warning: 1 warning emitted
|
||||
|
||||
@ -22,12 +22,8 @@ mod rustc_ok {
|
||||
pub fn rustc_lints() {
|
||||
let x = 42.0;
|
||||
|
||||
#[expect(illegal_floating_point_literal_pattern)]
|
||||
match x {
|
||||
5.0 => {}
|
||||
6.0 => {}
|
||||
_ => {}
|
||||
}
|
||||
#[expect(invalid_nan_comparisons)]
|
||||
let _b = x == f32::NAN;
|
||||
}
|
||||
}
|
||||
|
||||
@ -40,13 +36,9 @@ mod rustc_warn {
|
||||
pub fn rustc_lints() {
|
||||
let x = 42;
|
||||
|
||||
#[expect(illegal_floating_point_literal_pattern)]
|
||||
#[expect(invalid_nan_comparisons)]
|
||||
//~^ WARNING this lint expectation is unfulfilled [unfulfilled_lint_expectations]
|
||||
match x {
|
||||
5 => {}
|
||||
6 => {}
|
||||
_ => {}
|
||||
}
|
||||
let _b = x == 5;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
warning: this lint expectation is unfulfilled
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:37:14
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:33:14
|
||||
|
|
||||
LL | #[expect(dead_code)]
|
||||
| ^^^^^^^^^
|
||||
@ -7,10 +7,10 @@ LL | #[expect(dead_code)]
|
||||
= note: `#[warn(unfulfilled_lint_expectations)]` on by default
|
||||
|
||||
warning: this lint expectation is unfulfilled
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:43:18
|
||||
--> $DIR/expect_tool_lint_rfc_2383.rs:39:18
|
||||
|
|
||||
LL | #[expect(illegal_floating_point_literal_pattern)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
LL | #[expect(invalid_nan_comparisons)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
warning: 2 warnings emitted
|
||||
|
||||
|
||||
@ -1,50 +0,0 @@
|
||||
// Matching against float literals should result in a linter error
|
||||
|
||||
#![feature(exclusive_range_pattern)]
|
||||
#![allow(unused)]
|
||||
#![forbid(illegal_floating_point_literal_pattern)]
|
||||
|
||||
fn main() {
|
||||
let x = 42.0;
|
||||
match x {
|
||||
5.0 => {}, //~ ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING hard error
|
||||
5.0f32 => {}, //~ ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING hard error
|
||||
-5.0 => {}, //~ ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING hard error
|
||||
1.0 .. 33.0 => {}, //~ ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING hard error
|
||||
//~| ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING hard error
|
||||
39.0 ..= 70.0 => {}, //~ ERROR floating-point types cannot be used in patterns
|
||||
//~| ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING hard error
|
||||
//~| WARNING hard error
|
||||
|
||||
..71.0 => {}
|
||||
//~^ ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING this was previously accepted by the compiler
|
||||
..=72.0 => {}
|
||||
//~^ ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING this was previously accepted by the compiler
|
||||
71.0.. => {}
|
||||
//~^ ERROR floating-point types cannot be used in patterns
|
||||
//~| WARNING this was previously accepted by the compiler
|
||||
_ => {},
|
||||
};
|
||||
let y = 5.0;
|
||||
// Same for tuples
|
||||
match (x, 5) {
|
||||
(3.14, 1) => {}, //~ ERROR floating-point types cannot be used
|
||||
//~| WARNING hard error
|
||||
_ => {},
|
||||
}
|
||||
// Or structs
|
||||
struct Foo { x: f32 };
|
||||
match (Foo { x }) {
|
||||
Foo { x: 2.0 } => {}, //~ ERROR floating-point types cannot be used
|
||||
//~| WARNING hard error
|
||||
_ => {},
|
||||
}
|
||||
}
|
||||
@ -1,115 +0,0 @@
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:10:9
|
||||
|
|
||||
LL | 5.0 => {},
|
||||
| ^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
note: the lint level is defined here
|
||||
--> $DIR/issue-41255.rs:5:11
|
||||
|
|
||||
LL | #![forbid(illegal_floating_point_literal_pattern)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:12:9
|
||||
|
|
||||
LL | 5.0f32 => {},
|
||||
| ^^^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:14:10
|
||||
|
|
||||
LL | -5.0 => {},
|
||||
| ^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:16:9
|
||||
|
|
||||
LL | 1.0 .. 33.0 => {},
|
||||
| ^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:16:16
|
||||
|
|
||||
LL | 1.0 .. 33.0 => {},
|
||||
| ^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:20:9
|
||||
|
|
||||
LL | 39.0 ..= 70.0 => {},
|
||||
| ^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:20:18
|
||||
|
|
||||
LL | 39.0 ..= 70.0 => {},
|
||||
| ^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:25:11
|
||||
|
|
||||
LL | ..71.0 => {}
|
||||
| ^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:28:12
|
||||
|
|
||||
LL | ..=72.0 => {}
|
||||
| ^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:31:9
|
||||
|
|
||||
LL | 71.0.. => {}
|
||||
| ^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:39:10
|
||||
|
|
||||
LL | (3.14, 1) => {},
|
||||
| ^^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-41255.rs:46:18
|
||||
|
|
||||
LL | Foo { x: 2.0 } => {},
|
||||
| ^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: aborting due to 12 previous errors
|
||||
|
||||
11
tests/ui/match/match-float.rs
Normal file
11
tests/ui/match/match-float.rs
Normal file
@ -0,0 +1,11 @@
|
||||
// run-pass
|
||||
// Makes sure we use `==` (not bitwise) semantics for float comparison.
|
||||
|
||||
fn main() {
|
||||
const F1: f32 = 0.0;
|
||||
const F2: f32 = -0.0;
|
||||
assert_eq!(F1, F2);
|
||||
assert_ne!(F1.to_bits(), F2.to_bits());
|
||||
assert!(matches!(F1, F2));
|
||||
assert!(matches!(F2, F1));
|
||||
}
|
||||
@ -1,6 +1,5 @@
|
||||
// run-pass
|
||||
// pretty-expanded FIXME #23616
|
||||
#![allow(illegal_floating_point_literal_pattern)] // FIXME #41620
|
||||
|
||||
pub fn main() {
|
||||
const FOO: f64 = 10.0;
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
#![feature(exclusive_range_pattern)]
|
||||
#![allow(illegal_floating_point_literal_pattern)]
|
||||
#![deny(unreachable_patterns)]
|
||||
|
||||
fn main() {
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
error[E0004]: non-exhaustive patterns: `_` not covered
|
||||
--> $DIR/floats.rs:11:11
|
||||
--> $DIR/floats.rs:10:11
|
||||
|
|
||||
LL | match 0.0 {
|
||||
| ^^^ pattern `_` not covered
|
||||
@ -12,49 +12,49 @@ LL + _ => todo!()
|
||||
|
|
||||
|
||||
error: unreachable pattern
|
||||
--> $DIR/floats.rs:19:9
|
||||
--> $DIR/floats.rs:18:9
|
||||
|
|
||||
LL | 0.01f64 => {}
|
||||
| ^^^^^^^
|
||||
|
|
||||
note: the lint level is defined here
|
||||
--> $DIR/floats.rs:3:9
|
||||
--> $DIR/floats.rs:2:9
|
||||
|
|
||||
LL | #![deny(unreachable_patterns)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: unreachable pattern
|
||||
--> $DIR/floats.rs:20:9
|
||||
--> $DIR/floats.rs:19:9
|
||||
|
|
||||
LL | 0.02f64 => {}
|
||||
| ^^^^^^^
|
||||
|
||||
error: unreachable pattern
|
||||
--> $DIR/floats.rs:21:9
|
||||
--> $DIR/floats.rs:20:9
|
||||
|
|
||||
LL | 6.5f64 => {}
|
||||
| ^^^^^^
|
||||
|
||||
error: unreachable pattern
|
||||
--> $DIR/floats.rs:23:9
|
||||
--> $DIR/floats.rs:22:9
|
||||
|
|
||||
LL | 1.0f64..=4.0f64 => {}
|
||||
| ^^^^^^^^^^^^^^^
|
||||
|
||||
error: unreachable pattern
|
||||
--> $DIR/floats.rs:35:9
|
||||
--> $DIR/floats.rs:34:9
|
||||
|
|
||||
LL | 0.01f32 => {}
|
||||
| ^^^^^^^
|
||||
|
||||
error: unreachable pattern
|
||||
--> $DIR/floats.rs:36:9
|
||||
--> $DIR/floats.rs:35:9
|
||||
|
|
||||
LL | 0.02f32 => {}
|
||||
| ^^^^^^^
|
||||
|
||||
error: unreachable pattern
|
||||
--> $DIR/floats.rs:37:9
|
||||
--> $DIR/floats.rs:36:9
|
||||
|
|
||||
LL | 6.5f32 => {}
|
||||
| ^^^^^^
|
||||
|
||||
@ -1,5 +1,3 @@
|
||||
#![allow(illegal_floating_point_literal_pattern)]
|
||||
|
||||
enum T { A, B }
|
||||
|
||||
fn main() {
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
error[E0004]: non-exhaustive patterns: `T::A` not covered
|
||||
--> $DIR/non-exhaustive-match.rs:7:11
|
||||
--> $DIR/non-exhaustive-match.rs:5:11
|
||||
|
|
||||
LL | match x { T::B => { } }
|
||||
| ^ pattern `T::A` not covered
|
||||
|
|
||||
note: `T` defined here
|
||||
--> $DIR/non-exhaustive-match.rs:3:6
|
||||
--> $DIR/non-exhaustive-match.rs:1:6
|
||||
|
|
||||
LL | enum T { A, B }
|
||||
| ^ - not covered
|
||||
@ -16,7 +16,7 @@ LL | match x { T::B => { }, T::A => todo!() }
|
||||
| +++++++++++++++++
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `false` not covered
|
||||
--> $DIR/non-exhaustive-match.rs:8:11
|
||||
--> $DIR/non-exhaustive-match.rs:6:11
|
||||
|
|
||||
LL | match true {
|
||||
| ^^^^ pattern `false` not covered
|
||||
@ -29,7 +29,7 @@ LL + false => todo!()
|
||||
|
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `Some(_)` not covered
|
||||
--> $DIR/non-exhaustive-match.rs:11:11
|
||||
--> $DIR/non-exhaustive-match.rs:9:11
|
||||
|
|
||||
LL | match Some(10) {
|
||||
| ^^^^^^^^ pattern `Some(_)` not covered
|
||||
@ -47,7 +47,7 @@ LL + Some(_) => todo!()
|
||||
|
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `(_, _, i32::MIN..=3_i32)` and `(_, _, 5_i32..=i32::MAX)` not covered
|
||||
--> $DIR/non-exhaustive-match.rs:14:11
|
||||
--> $DIR/non-exhaustive-match.rs:12:11
|
||||
|
|
||||
LL | match (2, 3, 4) {
|
||||
| ^^^^^^^^^ patterns `(_, _, i32::MIN..=3_i32)` and `(_, _, 5_i32..=i32::MAX)` not covered
|
||||
@ -60,7 +60,7 @@ LL + (_, _, i32::MIN..=3_i32) | (_, _, 5_i32..=i32::MAX) => todo!()
|
||||
|
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `(T::A, T::A)` and `(T::B, T::B)` not covered
|
||||
--> $DIR/non-exhaustive-match.rs:18:11
|
||||
--> $DIR/non-exhaustive-match.rs:16:11
|
||||
|
|
||||
LL | match (T::A, T::A) {
|
||||
| ^^^^^^^^^^^^ patterns `(T::A, T::A)` and `(T::B, T::B)` not covered
|
||||
@ -73,13 +73,13 @@ LL + (T::A, T::A) | (T::B, T::B) => todo!()
|
||||
|
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `T::B` not covered
|
||||
--> $DIR/non-exhaustive-match.rs:22:11
|
||||
--> $DIR/non-exhaustive-match.rs:20:11
|
||||
|
|
||||
LL | match T::A {
|
||||
| ^^^^ pattern `T::B` not covered
|
||||
|
|
||||
note: `T` defined here
|
||||
--> $DIR/non-exhaustive-match.rs:3:6
|
||||
--> $DIR/non-exhaustive-match.rs:1:6
|
||||
|
|
||||
LL | enum T { A, B }
|
||||
| ^ - not covered
|
||||
@ -91,7 +91,7 @@ LL + T::B => todo!()
|
||||
|
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `[]` not covered
|
||||
--> $DIR/non-exhaustive-match.rs:33:11
|
||||
--> $DIR/non-exhaustive-match.rs:31:11
|
||||
|
|
||||
LL | match *vec {
|
||||
| ^^^^ pattern `[]` not covered
|
||||
@ -104,7 +104,7 @@ LL + [] => todo!()
|
||||
|
|
||||
|
||||
error[E0004]: non-exhaustive patterns: `[_, _, _, _, ..]` not covered
|
||||
--> $DIR/non-exhaustive-match.rs:46:11
|
||||
--> $DIR/non-exhaustive-match.rs:44:11
|
||||
|
|
||||
LL | match *vec {
|
||||
| ^^^^ pattern `[_, _, _, _, ..]` not covered
|
||||
|
||||
@ -0,0 +1,41 @@
|
||||
// Matching against NaN should result in an error
|
||||
#![feature(exclusive_range_pattern)]
|
||||
#![allow(unused)]
|
||||
|
||||
const NAN: f64 = f64::NAN;
|
||||
|
||||
#[derive(PartialEq, Eq)]
|
||||
struct MyType<T>(T);
|
||||
|
||||
const C: MyType<f32> = MyType(f32::NAN);
|
||||
|
||||
fn main() {
|
||||
let x = NAN;
|
||||
match x {
|
||||
NAN => {}, //~ ERROR cannot use NaN in patterns
|
||||
_ => {},
|
||||
};
|
||||
|
||||
match [x, 1.0] {
|
||||
[NAN, _] => {}, //~ ERROR cannot use NaN in patterns
|
||||
_ => {},
|
||||
};
|
||||
|
||||
match MyType(1.0f32) {
|
||||
C => {}, //~ ERROR cannot use NaN in patterns
|
||||
_ => {},
|
||||
}
|
||||
|
||||
// Also cover range patterns
|
||||
match x {
|
||||
NAN..=1.0 => {}, //~ ERROR cannot use NaN in patterns
|
||||
//~^ ERROR lower range bound must be less than or equal to upper
|
||||
-1.0..=NAN => {}, //~ ERROR cannot use NaN in patterns
|
||||
//~^ ERROR lower range bound must be less than or equal to upper
|
||||
NAN.. => {}, //~ ERROR cannot use NaN in patterns
|
||||
//~^ ERROR lower range bound must be less than or equal to upper
|
||||
..NAN => {}, //~ ERROR cannot use NaN in patterns
|
||||
//~^ ERROR lower range bound must be less than upper
|
||||
_ => {},
|
||||
};
|
||||
}
|
||||
@ -0,0 +1,91 @@
|
||||
error: cannot use NaN in patterns
|
||||
--> $DIR/issue-6804-nan-match.rs:15:9
|
||||
|
|
||||
LL | NAN => {},
|
||||
| ^^^
|
||||
|
|
||||
= note: NaNs compare inequal to everything, even themselves, so this pattern would never match
|
||||
= help: try using the `is_nan` method instead
|
||||
|
||||
error: cannot use NaN in patterns
|
||||
--> $DIR/issue-6804-nan-match.rs:20:10
|
||||
|
|
||||
LL | [NAN, _] => {},
|
||||
| ^^^
|
||||
|
|
||||
= note: NaNs compare inequal to everything, even themselves, so this pattern would never match
|
||||
= help: try using the `is_nan` method instead
|
||||
|
||||
error: cannot use NaN in patterns
|
||||
--> $DIR/issue-6804-nan-match.rs:25:9
|
||||
|
|
||||
LL | C => {},
|
||||
| ^
|
||||
|
|
||||
= note: NaNs compare inequal to everything, even themselves, so this pattern would never match
|
||||
= help: try using the `is_nan` method instead
|
||||
|
||||
error: cannot use NaN in patterns
|
||||
--> $DIR/issue-6804-nan-match.rs:31:9
|
||||
|
|
||||
LL | NAN..=1.0 => {},
|
||||
| ^^^
|
||||
|
|
||||
= note: NaNs compare inequal to everything, even themselves, so this pattern would never match
|
||||
= help: try using the `is_nan` method instead
|
||||
|
||||
error[E0030]: lower range bound must be less than or equal to upper
|
||||
--> $DIR/issue-6804-nan-match.rs:31:9
|
||||
|
|
||||
LL | NAN..=1.0 => {},
|
||||
| ^^^^^^^^^ lower bound larger than upper bound
|
||||
|
||||
error: cannot use NaN in patterns
|
||||
--> $DIR/issue-6804-nan-match.rs:33:16
|
||||
|
|
||||
LL | -1.0..=NAN => {},
|
||||
| ^^^
|
||||
|
|
||||
= note: NaNs compare inequal to everything, even themselves, so this pattern would never match
|
||||
= help: try using the `is_nan` method instead
|
||||
|
||||
error[E0030]: lower range bound must be less than or equal to upper
|
||||
--> $DIR/issue-6804-nan-match.rs:33:9
|
||||
|
|
||||
LL | -1.0..=NAN => {},
|
||||
| ^^^^^^^^^^ lower bound larger than upper bound
|
||||
|
||||
error: cannot use NaN in patterns
|
||||
--> $DIR/issue-6804-nan-match.rs:35:9
|
||||
|
|
||||
LL | NAN.. => {},
|
||||
| ^^^
|
||||
|
|
||||
= note: NaNs compare inequal to everything, even themselves, so this pattern would never match
|
||||
= help: try using the `is_nan` method instead
|
||||
|
||||
error[E0030]: lower range bound must be less than or equal to upper
|
||||
--> $DIR/issue-6804-nan-match.rs:35:9
|
||||
|
|
||||
LL | NAN.. => {},
|
||||
| ^^^^^ lower bound larger than upper bound
|
||||
|
||||
error: cannot use NaN in patterns
|
||||
--> $DIR/issue-6804-nan-match.rs:37:11
|
||||
|
|
||||
LL | ..NAN => {},
|
||||
| ^^^
|
||||
|
|
||||
= note: NaNs compare inequal to everything, even themselves, so this pattern would never match
|
||||
= help: try using the `is_nan` method instead
|
||||
|
||||
error[E0579]: lower range bound must be less than upper
|
||||
--> $DIR/issue-6804-nan-match.rs:37:9
|
||||
|
|
||||
LL | ..NAN => {},
|
||||
| ^^^^^
|
||||
|
||||
error: aborting due to 11 previous errors
|
||||
|
||||
Some errors have detailed explanations: E0030, E0579.
|
||||
For more information about an error, try `rustc --explain E0030`.
|
||||
@ -1,21 +0,0 @@
|
||||
// Matching against NaN should result in a warning
|
||||
|
||||
#![allow(unused)]
|
||||
#![deny(illegal_floating_point_literal_pattern)]
|
||||
|
||||
const NAN: f64 = f64::NAN;
|
||||
|
||||
fn main() {
|
||||
let x = NAN;
|
||||
match x {
|
||||
NAN => {}, //~ ERROR floating-point types cannot be used
|
||||
//~| WARN this was previously accepted by the compiler but is being phased out
|
||||
_ => {},
|
||||
};
|
||||
|
||||
match [x, 1.0] {
|
||||
[NAN, _] => {}, //~ ERROR floating-point types cannot be used
|
||||
//~| WARN this was previously accepted by the compiler but is being phased out
|
||||
_ => {},
|
||||
};
|
||||
}
|
||||
@ -1,25 +0,0 @@
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-6804.rs:11:9
|
||||
|
|
||||
LL | NAN => {},
|
||||
| ^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
note: the lint level is defined here
|
||||
--> $DIR/issue-6804.rs:4:9
|
||||
|
|
||||
LL | #![deny(illegal_floating_point_literal_pattern)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: floating-point types cannot be used in patterns
|
||||
--> $DIR/issue-6804.rs:17:10
|
||||
|
|
||||
LL | [NAN, _] => {},
|
||||
| ^^^
|
||||
|
|
||||
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
|
||||
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
// run-pass
|
||||
|
||||
#![allow(dead_code)]
|
||||
#![allow(illegal_floating_point_literal_pattern)]
|
||||
|
||||
#[repr(u32)]
|
||||
enum Tag {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user