Clippy lints / Pedantic
Clippy lint · Pedantic · checked with Clippy 0.1.99
clippy::manual_is_power_of_two: manually reimplementing `is_power_of_two`
What it meansChecks for expressions like x.count_ones() == 1 or x & (x - 1) == 0, with x and unsigned integer, which may be manual reimplementations of x.is_power_of_two(). It is in the pedantic group and off by default.
What you see
warning: manually reimplementing `is_power_of_two` --> main.rs:4:14 | 4 | let result = a.count_ones() == 1; | ^^^^^^^^^^^^^^^^^^^ help: consider using `.is_power_of_two()`: `a.is_power_of_two()` | = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#manual_is_power_of_two = note: `-W clippy::manual-is-power-of-two` implied by `-W clippy::pedantic`
Real output of Clippy 0.1.99 (Rust 1.99) on the example below. Names and line numbers in yours will differ.
Does it matter?
Manual reimplementations of is_power_of_two increase code complexity for little benefit.
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 a: u32 = 4;
let result = a.count_ones() == 1;
Write this instead
let a: u32 = 4;
let result = a.is_power_of_two();
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_is_power_of_two = "warn"In code
#![warn(clippy::manual_is_power_of_two)]One run
cargo clippy -- -W clippy::manual-is-power-of-twoThe [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 expressions like x.count_ones() == 1 or x & (x - 1) == 0, with x and unsigned integer, which may be manual
reimplementations of x.is_power_of_two().
Why is this bad?
Manual reimplementations of is_power_of_two increase code complexity for little benefit.
Example
let a: u32 = 4;
let result = a.count_ones() == 1;
Use instead:
let a: u32 = 4;
let result = a.is_power_of_two();
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_bit_widthmanual implementation of `bit_width`
- manual_ilog2manually reimplementing `ilog2`
- manual_instant_elapsedmanual implementation of `Instant::elapsed`
- 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_midpointChecks for manual implementation of midpoint
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?