mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

restrict manual_clamp to const case, bring it out of nursery

Browse Source
This commit is contained in:
Jacob Kiesel 2024-03-23 20:59:30 -06:00
parent 95c62ffae9
commit 0cf9d9c440
4 changed files with 574 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
clippy_lints/src/manual_clamp.rs
View File

@ -1,4 +1,5 @@
use clippy_config::msrvs::{self, Msrv}; use clippy_config::msrvs::{self, Msrv};
use clippy_utils::consts::{constant, Constant};
use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then}; use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
use clippy_utils::higher::If; use clippy_utils::higher::If;
use clippy_utils::sugg::Sugg; use clippy_utils::sugg::Sugg;
@ -17,6 +18,7 @@
use rustc_session::impl_lint_pass; use rustc_session::impl_lint_pass;
use rustc_span::symbol::sym; use rustc_span::symbol::sym;
use rustc_span::Span; use rustc_span::Span;
use std::cmp::Ordering;
use std::ops::Deref; use std::ops::Deref;
declare_clippy_lint! { declare_clippy_lint! {
@ -80,7 +82,7 @@
/// ``` /// ```
#[clippy::version = "1.66.0"] #[clippy::version = "1.66.0"]
pub MANUAL_CLAMP, pub MANUAL_CLAMP,
nursery, complexity,
"using a clamp pattern instead of the clamp function" "using a clamp pattern instead of the clamp function"
} }
impl_lint_pass!(ManualClamp => [MANUAL_CLAMP]); impl_lint_pass!(ManualClamp => [MANUAL_CLAMP]);
@ -103,6 +105,24 @@ struct ClampSuggestion<'tcx> {
hir_with_ignore_attr: Option<HirId>, hir_with_ignore_attr: Option<HirId>,
} }
impl<'tcx> ClampSuggestion<'tcx> {
/// This function will return true if and only if you can demonstrate at compile time that min
/// is less than max.
fn min_less_than_max(&self, cx: &LateContext<'tcx>) -> bool {
let max_type = cx.typeck_results().expr_ty(self.params.max);
let min_type = cx.typeck_results().expr_ty(self.params.min);
if max_type != min_type {
return false;
}
let max = constant(cx, cx.typeck_results(), self.params.max);
let min = constant(cx, cx.typeck_results(), self.params.min);
let cmp = max
.zip(min)
.and_then(|(max, min)| Constant::partial_cmp(cx.tcx, max_type, &min, &max));
cmp.is_some_and(|cmp| cmp != Ordering::Greater)
}
}
#[derive(Debug)] #[derive(Debug)]
struct InputMinMax<'tcx> { struct InputMinMax<'tcx> {
input: &'tcx Expr<'tcx>, input: &'tcx Expr<'tcx>,
@ -123,7 +143,9 @@ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
.or_else(|| is_match_pattern(cx, expr)) .or_else(|| is_match_pattern(cx, expr))
.or_else(|| is_if_elseif_pattern(cx, expr)); .or_else(|| is_if_elseif_pattern(cx, expr));
if let Some(suggestion) = suggestion { if let Some(suggestion) = suggestion {
emit_suggestion(cx, &suggestion); if suggestion.min_less_than_max(cx) {
emit_suggestion(cx, &suggestion);
}
} }
} }
} }
@ -133,7 +155,9 @@ fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
return; return;
} }
for suggestion in is_two_if_pattern(cx, block) { for suggestion in is_two_if_pattern(cx, block) {
emit_suggestion(cx, &suggestion); if suggestion.min_less_than_max(cx) {
emit_suggestion(cx, &suggestion);
}
} }
} }
extract_msrv_attr!(LateContext); extract_msrv_attr!(LateContext);

287
tests/ui/manual_clamp.fixed
View File

@ -17,48 +17,171 @@ const CONST_F64_MIN: f64 = 4.0;
fn main() { fn main() {
let (input, min, max) = (0, -2, 3); let (input, min, max) = (0, -2, 3);
// Lint // Min and max are not const, so this shouldn't trigger the lint.
let x0 = input.clamp(min, max); let x0 = if max < input {
max
} else if min > input {
min
} else {
input
};
let x1 = input.clamp(min, max); let x1 = if input > max {
max
} else if input < min {
min
} else {
input
};
let x2 = input.clamp(min, max); let x2 = if input < min {
min
} else if input > max {
max
} else {
input
};
let x3 = input.clamp(min, max); let x3 = if min > input {
min
} else if max < input {
max
} else {
input
};
let x4 = input.clamp(min, max); let x4 = input.max(min).min(max);
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
let x5 = input.clamp(min, max); let x5 = input.min(max).max(min);
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
let x6 = input.clamp(min, max); let x6 = match input {
x if x > max => max,
x if x < min => min,
x => x,
};
let x7 = input.clamp(min, max); let x7 = match input {
x if x < min => min,
x if x > max => max,
x => x,
};
let x8 = input.clamp(min, max); let x8 = match input {
x if max < x => max,
x if min > x => min,
x => x,
};
let mut x9 = input; let mut x9 = input;
x9 = x9.clamp(min, max); if x9 < min {
x9 = min;
}
if x9 > max {
x9 = max;
}
let x10 = input.clamp(min, max); let x10 = match input {
x if min > x => min,
x if max < x => max,
x => x,
};
let mut x11 = input; let mut x11 = input;
let _ = 1; let _ = 1;
x11 = x11.clamp(min, max); if x11 > max {
x11 = max;
}
if x11 < min {
x11 = min;
}
let mut x12 = input; let mut x12 = input;
x12 = x12.clamp(min, max); if min > x12 {
x12 = min;
}
if max < x12 {
x12 = max;
}
let mut x13 = input; let mut x13 = input;
x13 = x13.clamp(min, max); if max < x13 {
x13 = max;
}
if min > x13 {
x13 = min;
}
{
let (input, min, max) = (0.0f64, -2.0, 3.0);
let x14 = if input > max {
max
} else if input < min {
min
} else {
input
};
}
let mut x15 = input;
if x15 < min {
x15 = min;
} else if x15 > max {
x15 = max;
}
// It's important this be the last set of statements
let mut x16 = input;
if max < x16 {
x16 = max;
}
if min > x16 {
x16 = min;
}
}
fn const_main() {
let input = 0;
// Min and max are const, so this should trigger the lint.
let x0 = input.clamp(CONST_MIN, CONST_MAX);
let x1 = input.clamp(CONST_MIN, CONST_MAX);
let x2 = input.clamp(CONST_MIN, CONST_MAX);
let x3 = input.clamp(CONST_MIN, CONST_MAX);
let x4 = input.clamp(CONST_MIN, CONST_MAX);
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
let x5 = input.clamp(CONST_MIN, CONST_MAX);
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
let x6 = input.clamp(CONST_MIN, CONST_MAX);
let x7 = input.clamp(CONST_MIN, CONST_MAX);
let x8 = input.clamp(CONST_MIN, CONST_MAX);
let mut x9 = input;
x9 = x9.clamp(CONST_MIN, CONST_MAX);
let x10 = input.clamp(CONST_MIN, CONST_MAX);
let mut x11 = input;
let _ = 1;
x11 = x11.clamp(CONST_MIN, CONST_MAX);
let mut x12 = input;
x12 = x12.clamp(CONST_MIN, CONST_MAX);
let mut x13 = input;
x13 = x13.clamp(CONST_MIN, CONST_MAX);
let x14 = input.clamp(CONST_MIN, CONST_MAX); let x14 = input.clamp(CONST_MIN, CONST_MAX);
{ {
let (input, min, max) = (0.0f64, -2.0, 3.0); let input = 0.0f64;
let x15 = input.clamp(min, max); let x15 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
} }
{ {
let input: i32 = cmp_min_max(1); let input: i32 = cmp_min_max(1);
@ -114,108 +237,128 @@ fn main() {
//~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan() //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
} }
let mut x32 = input; let mut x32 = input;
x32 = x32.clamp(min, max); x32 = x32.clamp(CONST_MIN, CONST_MAX);
// Flip the script, swap the places of min and max. Make sure this doesn't
// trigger when clamp would be guaranteed to panic.
let mut x33 = input;
if x33 < CONST_MAX {
x33 = CONST_MAX;
} else if x33 > CONST_MIN {
x33 = CONST_MIN;
}
// Do it again for NaN
#[allow(invalid_nan_comparisons)]
{
let mut x34 = input as f64;
if x34 < f64::NAN {
x34 = f64::NAN;
} else if x34 > CONST_F64_MAX {
x34 = CONST_F64_MAX;
}
}
// It's important this be the last set of statements // It's important this be the last set of statements
let mut x33 = input; let mut x35 = input;
x33 = x33.clamp(min, max); x35 = x35.clamp(CONST_MIN, CONST_MAX);
} }
// This code intentionally nonsense. // This code intentionally nonsense.
fn no_lint() { fn no_lint() {
let (input, min, max) = (0, -2, 3); let input = 0;
let x0 = if max < input { let x0 = if CONST_MAX < input {
max CONST_MAX
} else if min > input { } else if CONST_MIN > input {
max CONST_MAX
} else { } else {
min CONST_MIN
}; };
let x1 = if input > max { let x1 = if input > CONST_MAX {
max CONST_MAX
} else if input > min { } else if input > CONST_MIN {
min CONST_MIN
} else { } else {
max CONST_MAX
}; };
let x2 = if max < min { let x2 = if CONST_MAX < CONST_MIN {
min CONST_MIN
} else if input > max { } else if input > CONST_MAX {
input input
} else { } else {
input input
}; };
let x3 = if min > input { let x3 = if CONST_MIN > input {
input input
} else if max < input { } else if CONST_MAX < input {
max CONST_MAX
} else { } else {
max CONST_MAX
}; };
let x6 = match input { let x6 = match input {
x if x < max => x, x if x < CONST_MAX => x,
x if x < min => x, x if x < CONST_MIN => x,
x => x, x => x,
}; };
let x7 = match input { let x7 = match input {
x if x < min => max, x if x < CONST_MIN => CONST_MAX,
x if x > max => min, x if x > CONST_MAX => CONST_MIN,
x => x, x => x,
}; };
let x8 = match input { let x8 = match input {
x if max > x => max, x if CONST_MAX > x => CONST_MAX,
x if min > x => min, x if CONST_MIN > x => CONST_MIN,
x => x, x => x,
}; };
let mut x9 = input; let mut x9 = input;
if x9 > min { if x9 > CONST_MIN {
x9 = min; x9 = CONST_MIN;
} }
if x9 > max { if x9 > CONST_MAX {
x9 = max; x9 = CONST_MAX;
} }
let x10 = match input { let x10 = match input {
x if min > x => min, x if CONST_MIN > x => CONST_MIN,
x if max < x => max, x if CONST_MAX < x => CONST_MAX,
x => min, x => CONST_MIN,
}; };
let mut x11 = input; let mut x11 = input;
if x11 > max { if x11 > CONST_MAX {
x11 = min; x11 = CONST_MIN;
} }
if x11 < min { if x11 < CONST_MIN {
x11 = max; x11 = CONST_MAX;
} }
let mut x12 = input; let mut x12 = input;
if min > x12 { if CONST_MIN > x12 {
x12 = max * 3; x12 = CONST_MAX * 3;
} }
if max < x12 { if CONST_MAX < x12 {
x12 = min; x12 = CONST_MIN;
} }
let mut x13 = input; let mut x13 = input;
if max < x13 { if CONST_MAX < x13 {
let x13 = max; let x13 = CONST_MAX;
} }
if min > x13 { if CONST_MIN > x13 {
x13 = min; x13 = CONST_MIN;
} }
let mut x14 = input; let mut x14 = input;
if x14 < min { if x14 < CONST_MIN {
x14 = 3; x14 = 3;
} else if x14 > max { } else if x14 > CONST_MAX {
x14 = max; x14 = CONST_MAX;
} }
{ {
let input: i32 = cmp_min_max(1); let input: i32 = cmp_min_max(1);
@ -272,8 +415,8 @@ fn msrv_1_49() {
#[clippy::msrv = "1.50"] #[clippy::msrv = "1.50"]
fn msrv_1_50() { fn msrv_1_50() {
let (input, min, max) = (0, -1, 2); let input = 0;
let _ = input.clamp(min, max); let _ = input.clamp(CONST_MIN, CONST_MAX);
} }
const fn _const() { const fn _const() {

333
tests/ui/manual_clamp.rs
View File

@ -17,10 +17,8 @@
fn main() { fn main() {
let (input, min, max) = (0, -2, 3); let (input, min, max) = (0, -2, 3);
// Lint // Min and max are not const, so this shouldn't trigger the lint.
let x0 = if max < input { let x0 = if max < input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
max max
} else if min > input { } else if min > input {
min min
@ -29,8 +27,6 @@ fn main() {
}; };
let x1 = if input > max { let x1 = if input > max {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
max max
} else if input < min { } else if input < min {
min min
@ -39,8 +35,6 @@ fn main() {
}; };
let x2 = if input < min { let x2 = if input < min {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
min min
} else if input > max { } else if input > max {
max max
@ -49,8 +43,6 @@ fn main() {
}; };
let x3 = if min > input { let x3 = if min > input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
min min
} else if max < input { } else if max < input {
max max
@ -59,32 +51,22 @@ fn main() {
}; };
let x4 = input.max(min).min(max); let x4 = input.max(min).min(max);
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
let x5 = input.min(max).max(min); let x5 = input.min(max).max(min);
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
let x6 = match input { let x6 = match input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x if x > max => max, x if x > max => max,
x if x < min => min, x if x < min => min,
x => x, x => x,
}; };
let x7 = match input { let x7 = match input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x if x < min => min, x if x < min => min,
x if x > max => max, x if x > max => max,
x => x, x => x,
}; };
let x8 = match input { let x8 = match input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x if max < x => max, x if max < x => max,
x if min > x => min, x if min > x => min,
x => x, x => x,
@ -92,8 +74,6 @@ fn main() {
let mut x9 = input; let mut x9 = input;
if x9 < min { if x9 < min {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x9 = min; x9 = min;
} }
if x9 > max { if x9 > max {
@ -101,8 +81,6 @@ fn main() {
} }
let x10 = match input { let x10 = match input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x if min > x => min, x if min > x => min,
x if max < x => max, x if max < x => max,
x => x, x => x,
@ -111,8 +89,6 @@ fn main() {
let mut x11 = input; let mut x11 = input;
let _ = 1; let _ = 1;
if x11 > max { if x11 > max {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x11 = max; x11 = max;
} }
if x11 < min { if x11 < min {
@ -121,8 +97,6 @@ fn main() {
let mut x12 = input; let mut x12 = input;
if min > x12 { if min > x12 {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x12 = min; x12 = min;
} }
if max < x12 { if max < x12 {
@ -131,14 +105,163 @@ fn main() {
let mut x13 = input; let mut x13 = input;
if max < x13 { if max < x13 {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x13 = max; x13 = max;
} }
if min > x13 { if min > x13 {
x13 = min; x13 = min;
} }
{
let (input, min, max) = (0.0f64, -2.0, 3.0);
let x14 = if input > max {
max
} else if input < min {
min
} else {
input
};
}
let mut x15 = input;
if x15 < min {
x15 = min;
} else if x15 > max {
x15 = max;
}
// It's important this be the last set of statements
let mut x16 = input;
if max < x16 {
x16 = max;
}
if min > x16 {
x16 = min;
}
}
fn const_main() {
let input = 0;
// Min and max are const, so this should trigger the lint.
let x0 = if CONST_MAX < input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
CONST_MAX
} else if CONST_MIN > input {
CONST_MIN
} else {
input
};
let x1 = if input > CONST_MAX {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
CONST_MAX
} else if input < CONST_MIN {
CONST_MIN
} else {
input
};
let x2 = if input < CONST_MIN {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
CONST_MIN
} else if input > CONST_MAX {
CONST_MAX
} else {
input
};
let x3 = if CONST_MIN > input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
CONST_MIN
} else if CONST_MAX < input {
CONST_MAX
} else {
input
};
let x4 = input.max(CONST_MIN).min(CONST_MAX);
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
let x5 = input.min(CONST_MAX).max(CONST_MIN);
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
let x6 = match input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x if x > CONST_MAX => CONST_MAX,
x if x < CONST_MIN => CONST_MIN,
x => x,
};
let x7 = match input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x if x < CONST_MIN => CONST_MIN,
x if x > CONST_MAX => CONST_MAX,
x => x,
};
let x8 = match input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x if CONST_MAX < x => CONST_MAX,
x if CONST_MIN > x => CONST_MIN,
x => x,
};
let mut x9 = input;
if x9 < CONST_MIN {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x9 = CONST_MIN;
}
if x9 > CONST_MAX {
x9 = CONST_MAX;
}
let x10 = match input {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x if CONST_MIN > x => CONST_MIN,
x if CONST_MAX < x => CONST_MAX,
x => x,
};
let mut x11 = input;
let _ = 1;
if x11 > CONST_MAX {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x11 = CONST_MAX;
}
if x11 < CONST_MIN {
x11 = CONST_MIN;
}
let mut x12 = input;
if CONST_MIN > x12 {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x12 = CONST_MIN;
}
if CONST_MAX < x12 {
x12 = CONST_MAX;
}
let mut x13 = input;
if CONST_MAX < x13 {
//~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min
x13 = CONST_MAX;
}
if CONST_MIN > x13 {
x13 = CONST_MIN;
}
let x14 = if input > CONST_MAX { let x14 = if input > CONST_MAX {
//~^ ERROR: clamp-like pattern without using clamp function //~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min //~| NOTE: clamp will panic if max < min
@ -149,13 +272,13 @@ fn main() {
input input
}; };
{ {
let (input, min, max) = (0.0f64, -2.0, 3.0); let input = 0.0f64;
let x15 = if input > max { let x15 = if input > CONST_F64_MAX {
//~^ ERROR: clamp-like pattern without using clamp function //~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan() //~| NOTE: clamp will panic if max < min
max CONST_F64_MAX
} else if input < min { } else if input < CONST_F64_MIN {
min CONST_F64_MIN
} else { } else {
input input
}; };
@ -214,121 +337,141 @@ fn main() {
//~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan() //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
} }
let mut x32 = input; let mut x32 = input;
if x32 < min { if x32 < CONST_MIN {
//~^ ERROR: clamp-like pattern without using clamp function //~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min //~| NOTE: clamp will panic if max < min
x32 = min; x32 = CONST_MIN;
} else if x32 > max { } else if x32 > CONST_MAX {
x32 = max; x32 = CONST_MAX;
}
// Flip the script, swap the places of min and max. Make sure this doesn't
// trigger when clamp would be guaranteed to panic.
let mut x33 = input;
if x33 < CONST_MAX {
x33 = CONST_MAX;
} else if x33 > CONST_MIN {
x33 = CONST_MIN;
}
// Do it again for NaN
#[allow(invalid_nan_comparisons)]
{
let mut x34 = input as f64;
if x34 < f64::NAN {
x34 = f64::NAN;
} else if x34 > CONST_F64_MAX {
x34 = CONST_F64_MAX;
}
} }
// It's important this be the last set of statements // It's important this be the last set of statements
let mut x33 = input; let mut x35 = input;
if max < x33 { if CONST_MAX < x35 {
//~^ ERROR: clamp-like pattern without using clamp function //~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min //~| NOTE: clamp will panic if max < min
x33 = max; x35 = CONST_MAX;
} }
if min > x33 { if CONST_MIN > x35 {
x33 = min; x35 = CONST_MIN;
} }
} }
// This code intentionally nonsense. // This code intentionally nonsense.
fn no_lint() { fn no_lint() {
let (input, min, max) = (0, -2, 3); let input = 0;
let x0 = if max < input { let x0 = if CONST_MAX < input {
max CONST_MAX
} else if min > input { } else if CONST_MIN > input {
max CONST_MAX
} else { } else {
min CONST_MIN
}; };
let x1 = if input > max { let x1 = if input > CONST_MAX {
max CONST_MAX
} else if input > min { } else if input > CONST_MIN {
min CONST_MIN
} else { } else {
max CONST_MAX
}; };
let x2 = if max < min { let x2 = if CONST_MAX < CONST_MIN {
min CONST_MIN
} else if input > max { } else if input > CONST_MAX {
input input
} else { } else {
input input
}; };
let x3 = if min > input { let x3 = if CONST_MIN > input {
input input
} else if max < input { } else if CONST_MAX < input {
max CONST_MAX
} else { } else {
max CONST_MAX
}; };
let x6 = match input { let x6 = match input {
x if x < max => x, x if x < CONST_MAX => x,
x if x < min => x, x if x < CONST_MIN => x,
x => x, x => x,
}; };
let x7 = match input { let x7 = match input {
x if x < min => max, x if x < CONST_MIN => CONST_MAX,
x if x > max => min, x if x > CONST_MAX => CONST_MIN,
x => x, x => x,
}; };
let x8 = match input { let x8 = match input {
x if max > x => max, x if CONST_MAX > x => CONST_MAX,
x if min > x => min, x if CONST_MIN > x => CONST_MIN,
x => x, x => x,
}; };
let mut x9 = input; let mut x9 = input;
if x9 > min { if x9 > CONST_MIN {
x9 = min; x9 = CONST_MIN;
} }
if x9 > max { if x9 > CONST_MAX {
x9 = max; x9 = CONST_MAX;
} }
let x10 = match input { let x10 = match input {
x if min > x => min, x if CONST_MIN > x => CONST_MIN,
x if max < x => max, x if CONST_MAX < x => CONST_MAX,
x => min, x => CONST_MIN,
}; };
let mut x11 = input; let mut x11 = input;
if x11 > max { if x11 > CONST_MAX {
x11 = min; x11 = CONST_MIN;
} }
if x11 < min { if x11 < CONST_MIN {
x11 = max; x11 = CONST_MAX;
} }
let mut x12 = input; let mut x12 = input;
if min > x12 { if CONST_MIN > x12 {
x12 = max * 3; x12 = CONST_MAX * 3;
} }
if max < x12 { if CONST_MAX < x12 {
x12 = min; x12 = CONST_MIN;
} }
let mut x13 = input; let mut x13 = input;
if max < x13 { if CONST_MAX < x13 {
let x13 = max; let x13 = CONST_MAX;
} }
if min > x13 { if CONST_MIN > x13 {
x13 = min; x13 = CONST_MIN;
} }
let mut x14 = input; let mut x14 = input;
if x14 < min { if x14 < CONST_MIN {
x14 = 3; x14 = 3;
} else if x14 > max { } else if x14 > CONST_MAX {
x14 = max; x14 = CONST_MAX;
} }
{ {
let input: i32 = cmp_min_max(1); let input: i32 = cmp_min_max(1);
@ -385,13 +528,13 @@ fn msrv_1_49() {
#[clippy::msrv = "1.50"] #[clippy::msrv = "1.50"]
fn msrv_1_50() { fn msrv_1_50() {
let (input, min, max) = (0, -1, 2); let input = 0;
let _ = if input < min { let _ = if input > CONST_MAX {
//~^ ERROR: clamp-like pattern without using clamp function //~^ ERROR: clamp-like pattern without using clamp function
//~| NOTE: clamp will panic if max < min //~| NOTE: clamp will panic if max < min
min CONST_MAX
} else if input > max { } else if input < CONST_MIN {
max CONST_MIN
} else { } else {
input input
}; };

188
tests/ui/manual_clamp.stderr
View File

@ -1,213 +1,213 @@
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:94:5 --> tests/ui/manual_clamp.rs:217:5
| |
LL | / if x9 < min { LL | / if x9 < CONST_MIN {
LL | | LL | |
LL | | LL | |
LL | | x9 = min; LL | | x9 = CONST_MIN;
... | ... |
LL | | x9 = max; LL | | x9 = CONST_MAX;
LL | | } LL | | }
| |_____^ help: replace with clamp: `x9 = x9.clamp(min, max);` | |_____^ help: replace with clamp: `x9 = x9.clamp(CONST_MIN, CONST_MAX);`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
= note: `-D clippy::manual-clamp` implied by `-D warnings` = note: `-D clippy::manual-clamp` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::manual_clamp)]` = help: to override `-D warnings` add `#[allow(clippy::manual_clamp)]`
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:113:5 --> tests/ui/manual_clamp.rs:236:5
| |
LL | / if x11 > max { LL | / if x11 > CONST_MAX {
LL | | LL | |
LL | | LL | |
LL | | x11 = max; LL | | x11 = CONST_MAX;
... | ... |
LL | | x11 = min; LL | | x11 = CONST_MIN;
LL | | } LL | | }
| |_____^ help: replace with clamp: `x11 = x11.clamp(min, max);` | |_____^ help: replace with clamp: `x11 = x11.clamp(CONST_MIN, CONST_MAX);`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:123:5 --> tests/ui/manual_clamp.rs:246:5
| |
LL | / if min > x12 { LL | / if CONST_MIN > x12 {
LL | | LL | |
LL | | LL | |
LL | | x12 = min; LL | | x12 = CONST_MIN;
... | ... |
LL | | x12 = max; LL | | x12 = CONST_MAX;
LL | | } LL | | }
| |_____^ help: replace with clamp: `x12 = x12.clamp(min, max);` | |_____^ help: replace with clamp: `x12 = x12.clamp(CONST_MIN, CONST_MAX);`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:133:5 --> tests/ui/manual_clamp.rs:256:5
| |
LL | / if max < x13 { LL | / if CONST_MAX < x13 {
LL | | LL | |
LL | | LL | |
LL | | x13 = max; LL | | x13 = CONST_MAX;
... | ... |
LL | | x13 = min; LL | | x13 = CONST_MIN;
LL | | } LL | | }
| |_____^ help: replace with clamp: `x13 = x13.clamp(min, max);` | |_____^ help: replace with clamp: `x13 = x13.clamp(CONST_MIN, CONST_MAX);`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:227:5 --> tests/ui/manual_clamp.rs:370:5
| |
LL | / if max < x33 { LL | / if CONST_MAX < x35 {
LL | | LL | |
LL | | LL | |
LL | | x33 = max; LL | | x35 = CONST_MAX;
... | ... |
LL | | x33 = min; LL | | x35 = CONST_MIN;
LL | | } LL | | }
| |_____^ help: replace with clamp: `x33 = x33.clamp(min, max);` | |_____^ help: replace with clamp: `x35 = x35.clamp(CONST_MIN, CONST_MAX);`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:21:14 --> tests/ui/manual_clamp.rs:144:14
| |
LL | let x0 = if max < input { LL | let x0 = if CONST_MAX < input {
| ______________^ | ______________^
LL | | LL | |
LL | | LL | |
LL | | max LL | | CONST_MAX
... | ... |
LL | | input LL | | input
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:31:14 --> tests/ui/manual_clamp.rs:154:14
| |
LL | let x1 = if input > max { LL | let x1 = if input > CONST_MAX {
| ______________^ | ______________^
LL | | LL | |
LL | | LL | |
LL | | max LL | | CONST_MAX
... | ... |
LL | | input LL | | input
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:41:14 --> tests/ui/manual_clamp.rs:164:14
| |
LL | let x2 = if input < min { LL | let x2 = if input < CONST_MIN {
| ______________^ | ______________^
LL | | LL | |
LL | | LL | |
LL | | min LL | | CONST_MIN
... | ... |
LL | | input LL | | input
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:51:14 --> tests/ui/manual_clamp.rs:174:14
| |
LL | let x3 = if min > input { LL | let x3 = if CONST_MIN > input {
| ______________^ | ______________^
LL | | LL | |
LL | | LL | |
LL | | min LL | | CONST_MIN
... | ... |
LL | | input LL | | input
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:61:14 --> tests/ui/manual_clamp.rs:184:14
| |
LL | let x4 = input.max(min).min(max); LL | let x4 = input.max(CONST_MIN).min(CONST_MAX);
| ^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(min, max)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:65:14 --> tests/ui/manual_clamp.rs:188:14
| |
LL | let x5 = input.min(max).max(min); LL | let x5 = input.min(CONST_MAX).max(CONST_MIN);
| ^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(min, max)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:69:14 --> tests/ui/manual_clamp.rs:192:14
| |
LL | let x6 = match input { LL | let x6 = match input {
| ______________^ | ______________^
LL | | LL | |
LL | | LL | |
LL | | x if x > max => max, LL | | x if x > CONST_MAX => CONST_MAX,
LL | | x if x < min => min, LL | | x if x < CONST_MIN => CONST_MIN,
LL | | x => x, LL | | x => x,
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:77:14 --> tests/ui/manual_clamp.rs:200:14
| |
LL | let x7 = match input { LL | let x7 = match input {
| ______________^ | ______________^
LL | | LL | |
LL | | LL | |
LL | | x if x < min => min, LL | | x if x < CONST_MIN => CONST_MIN,
LL | | x if x > max => max, LL | | x if x > CONST_MAX => CONST_MAX,
LL | | x => x, LL | | x => x,
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:85:14 --> tests/ui/manual_clamp.rs:208:14
| |
LL | let x8 = match input { LL | let x8 = match input {
| ______________^ | ______________^
LL | | LL | |
LL | | LL | |
LL | | x if max < x => max, LL | | x if CONST_MAX < x => CONST_MAX,
LL | | x if min > x => min, LL | | x if CONST_MIN > x => CONST_MIN,
LL | | x => x, LL | | x => x,
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:103:15 --> tests/ui/manual_clamp.rs:226:15
| |
LL | let x10 = match input { LL | let x10 = match input {
| _______________^ | _______________^
LL | | LL | |
LL | | LL | |
LL | | x if min > x => min, LL | | x if CONST_MIN > x => CONST_MIN,
LL | | x if max < x => max, LL | | x if CONST_MAX < x => CONST_MAX,
LL | | x => x, LL | | x => x,
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:142:15 --> tests/ui/manual_clamp.rs:265:15
| |
LL | let x14 = if input > CONST_MAX { LL | let x14 = if input > CONST_MAX {
| _______________^ | _______________^
@ -222,23 +222,23 @@ LL | | };
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:153:19 --> tests/ui/manual_clamp.rs:276:19
| |
LL | let x15 = if input > max { LL | let x15 = if input > CONST_F64_MAX {
| ___________________^ | ___________________^
LL | | LL | |
LL | | LL | |
LL | | max LL | | CONST_F64_MAX
... | ... |
LL | | input LL | | input
LL | | }; LL | | };
| |_________^ help: replace with clamp: `input.clamp(min, max)` | |_________^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
| |
= note: clamp will panic if max < min, min.is_nan(), or max.is_nan() = note: clamp will panic if max < min, min.is_nan(), or max.is_nan()
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:166:19 --> tests/ui/manual_clamp.rs:289:19
| |
LL | let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN); LL | let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@ -246,7 +246,7 @@ LL | let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:169:19 --> tests/ui/manual_clamp.rs:292:19
| |
LL | let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX); LL | let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@ -254,7 +254,7 @@ LL | let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:172:19 --> tests/ui/manual_clamp.rs:295:19
| |
LL | let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX)); LL | let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@ -262,7 +262,7 @@ LL | let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:175:19 --> tests/ui/manual_clamp.rs:298:19
| |
LL | let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN)); LL | let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@ -270,7 +270,7 @@ LL | let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:178:19 --> tests/ui/manual_clamp.rs:301:19
| |
LL | let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN); LL | let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@ -278,7 +278,7 @@ LL | let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:181:19 --> tests/ui/manual_clamp.rs:304:19
| |
LL | let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX); LL | let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@ -286,7 +286,7 @@ LL | let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:184:19 --> tests/ui/manual_clamp.rs:307:19
| |
LL | let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input)); LL | let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@ -294,7 +294,7 @@ LL | let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:187:19 --> tests/ui/manual_clamp.rs:310:19
| |
LL | let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input)); LL | let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@ -302,7 +302,7 @@ LL | let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:191:19 --> tests/ui/manual_clamp.rs:314:19
| |
LL | let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN); LL | let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@ -311,7 +311,7 @@ LL | let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:194:19 --> tests/ui/manual_clamp.rs:317:19
| |
LL | let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX); LL | let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@ -320,7 +320,7 @@ LL | let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:197:19 --> tests/ui/manual_clamp.rs:320:19
| |
LL | let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX)); LL | let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@ -329,7 +329,7 @@ LL | let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:200:19 --> tests/ui/manual_clamp.rs:323:19
| |
LL | let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN)); LL | let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@ -338,7 +338,7 @@ LL | let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:203:19 --> tests/ui/manual_clamp.rs:326:19
| |
LL | let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN); LL | let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@ -347,7 +347,7 @@ LL | let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:206:19 --> tests/ui/manual_clamp.rs:329:19
| |
LL | let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX); LL | let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@ -356,7 +356,7 @@ LL | let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:209:19 --> tests/ui/manual_clamp.rs:332:19
| |
LL | let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input)); LL | let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@ -365,7 +365,7 @@ LL | let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:212:19 --> tests/ui/manual_clamp.rs:335:19
| |
LL | let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input)); LL | let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@ -374,31 +374,31 @@ LL | let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
= note: clamp returns NaN if the input is NaN = note: clamp returns NaN if the input is NaN
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:217:5 --> tests/ui/manual_clamp.rs:340:5
| |
LL | / if x32 < min { LL | / if x32 < CONST_MIN {
LL | | LL | |
LL | | LL | |
LL | | x32 = min; LL | | x32 = CONST_MIN;
LL | | } else if x32 > max { LL | | } else if x32 > CONST_MAX {
LL | | x32 = max; LL | | x32 = CONST_MAX;
LL | | } LL | | }
| |_____^ help: replace with clamp: `x32 = x32.clamp(min, max);` | |_____^ help: replace with clamp: `x32 = x32.clamp(CONST_MIN, CONST_MAX);`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min
error: clamp-like pattern without using clamp function error: clamp-like pattern without using clamp function
--> tests/ui/manual_clamp.rs:389:13 --> tests/ui/manual_clamp.rs:532:13
| |
LL | let _ = if input < min { LL | let _ = if input > CONST_MAX {
| _____________^ | _____________^
LL | | LL | |
LL | | LL | |
LL | | min LL | | CONST_MAX
... | ... |
LL | | input LL | | input
LL | | }; LL | | };
| |_____^ help: replace with clamp: `input.clamp(min, max)` | |_____^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
| |
= note: clamp will panic if max < min = note: clamp will panic if max < min