Clippy lints / Pedantic
Clippy lint · Pedantic · checked with Clippy 0.1.99
clippy::needless_bitwise_bool: use of bitwise operator instead of lazy operator between booleans
What it meansChecks for usage of bitwise and/or operators between booleans, where performance may be improved by using a lazy and. It is in the pedantic group and off by default.
What you see
warning: use of bitwise operator instead of lazy operator between booleans --> main.rs:4:4 | 4 | if x & !y {} // where both x and y are booleans | ^^^^^^ help: try: `x && !y` | = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#needless_bitwise_bool = note: `-W clippy::needless-bitwise-bool` 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?
The bitwise operators do not support short-circuiting, so it may hinder code performance. Additionally, boolean logic “masked” as bitwise logic is not caught by lints like unnecessary_fold
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 (x,y) = (true, false);
if x & !y {} // where both x and y are booleans
Write this instead
let (x,y) = (true, false);
if x && !y {}
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]
needless_bitwise_bool = "warn"In code
#![warn(clippy::needless_bitwise_bool)]One run
cargo clippy -- -W clippy::needless-bitwise-boolThe [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.
Clippy's own documentation
What it does
Checks for usage of bitwise and/or operators between booleans, where performance may be improved by using a lazy and.
Why is this bad?
The bitwise operators do not support short-circuiting, so it may hinder code performance.
Additionally, boolean logic “masked” as bitwise logic is not caught by lints like unnecessary_fold
Known problems
This lint evaluates only when the right side is determined to have no side effects. At this time, that determination is quite conservative.
Example
let (x,y) = (true, false);
if x & !y {} // where both x and y are booleans
Use instead:
let (x,y) = (true, false);
if x && !y {}
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
- mut_mutmultiple successive mutable borrows
- naive_bytecountChecks for naive byte counts
- needless_continueThe lint checks for if-statements appearing in loops that contain a continue statement in either their main blocks or their else-blocks, when omitting the else-block possibly with some rearrangement of code can make the code easier to understand. The lint also checks if the last statement in the loop is a continue
- needless_for_eachneedless use of `for_each`
- needless_pass_by_valuethis argument is passed by value, but not consumed in the function body
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?