Clippy lints / Pedantic
Clippy lint · Pedantic · checked with Clippy 0.1.99
clippy::manual_midpoint: Checks for manual implementation of midpoint
What it meansChecks for manual implementation of midpoint. It is in the pedantic group and off by default.
Does it matter?
Using (x + y) / 2 or (x + y) >> 1 on integer types might cause an overflow on the intermediate addition result. The latter will only warn for unsigned integer types. Similar for floating-point (x + y) / 2.0 and (x + y) * 0.5.
Stricter lints with some false positives. Off by default; opt in with clippy::pedantic.
How to fix it
Clippy can fix this one for you: run cargo clippy --fix (add --allow-dirty if you have uncommitted changes). Review the diff before you commit.
Flagged
let c = (a + 10) / 2;
let d = (a + 10) >> 1;
let b: f32 = 0.0;
let e = (b + 10.0) / 2.0;
let f = (b + 10.0) * 0.5;
Write this instead
let c = u32::midpoint(a, 10);
let d = u32::midpoint(a, 10);
let b: f32 = 0.0;
let e = f32::midpoint(b, 10.0);
let f = f32::midpoint(b, 10.0);
Turn it off, or on
It is off by default. To use it, set it to warn or deny:
Whole crate (Cargo.toml)
[lints.clippy]
manual_midpoint = "warn"In code
#![warn(clippy::manual_midpoint)]One run
cargo clippy -- -W clippy::manual-midpointThe [lints] table needs Rust 1.74 or newer. In a workspace, put it under [workspace.lints.clippy] and add [lints] workspace = true to each member.
Settings in clippy.toml
msrv: The minimum rust version that the project supports. Defaults to the rust-version field in Cargo.toml
Clippy's own documentation
What it does
Checks for manual implementation of midpoint.
Why is this bad?
Using (x + y) / 2 or (x + y) >> 1 on integer types might cause an overflow on the
intermediate addition result. The latter will only warn for unsigned integer types.
Similar for floating-point (x + y) / 2.0 and (x + y) * 0.5.
Example
let c = (a + 10) / 2;
let d = (a + 10) >> 1;
let b: f32 = 0.0;
let e = (b + 10.0) / 2.0;
let f = (b + 10.0) * 0.5;
Use instead:
let c = u32::midpoint(a, 10);
let d = u32::midpoint(a, 10);
let b: f32 = 0.0;
let e = f32::midpoint(b, 10.0);
let f = f32::midpoint(b, 10.0);
Configuration
-
msrv: The minimum rust version that the project supports. Defaults to therust-versionfield inCargo.toml(default:
current version)
From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.
Related lints
- too_many_linesChecks for functions with a large amount of lines
- missing_errors_docChecks the doc comments of publicly visible functions that return a Result type and warns if there is no # Errors section
- must_use_candidateChecks for public functions that have no #[must_use] attribute, but return something not already marked must-use, have no mutable arg and mutate no statics
- manual_is_power_of_twomanually reimplementing `is_power_of_two`
- manual_is_variant_andChecks for usage of option.map(f).unwrap_or_default() and result.map(f).unwrap_or_default() where f is a function or closure that returns the bool type. Also checks for equality comparisons like option.map(f) == Some(true) and result.map(f) == Ok(true), as well as result.ok().is_some_and(f)
- manual_let_elseWarn of cases where let...else could be used
- manual_string_newempty String is being created manually
- many_single_char_names7 bindings with single-character names in scope
- map_unwrap_orChecks for usage of option.map(_).unwrap_or(_) or option.map(_).unwrap_or_else(_) or result.map(_).unwrap_or_else(_)
All 847 Clippy lints · Rust compiler errors · Cargo.toml checker
Up next
Related lintclippy::too_many_linesChecks for functions with a large amount of linesRead it next →Did this answer your question?