This raises an issue when code performs a bitwise AND operation with the literal value 0, as the result is always 0 regardless of the other operand.

Why is this an issue?

A bitwise AND operation combines two values bit by bit. When one of the operands is 0, every bit in the result will be 0 because 0 AND anything is always 0. This makes the operation meaningless and any subsequent comparison trivial.

For example, an expression that checks whether the result of ANDing a value with 0 equals 0 will always evaluate to true, and an expression checking whether that result differs from 0 will always evaluate to false, regardless of what the value contains.

This pattern almost always indicates a programming error. Common mistakes include:

• Wrong constant: The developer intended to use a bitmask (like hexadecimal values representing specific bit positions) but accidentally used 0 instead.
• Wrong operation: The developer meant to use a different operator, such as equality comparison, modulo division, or a different bitwise operation.
• Copy-paste error: The code was copied from another location and not properly updated.

Since the operation produces a predictable result that doesn’t depend on the actual value being tested, it serves no useful purpose and should be corrected.

What is the potential impact?

This bug can lead to incorrect program behavior because conditions that should vary based on runtime values become constant:

• Logic errors: Conditions that should sometimes be true and sometimes false will always have the same outcome, causing the program to take incorrect code paths.
• Security vulnerabilities: If the check was meant to verify permissions, validate input, or check security flags, the constant result means these checks are ineffective.
• Unreachable code: Code branches that depend on the result being different may never execute or may always execute, making parts of the program effectively dead code.

How to fix it

The appropriate fix depends on the root cause:

• Wrong constant: Replace 0 with the intended bitmask value. For example, use a hexadecimal constant like 0x01 or a named constant that represents the bit positions you meant to test.
• Wrong operator: Replace the & operator with the operator you actually intended, such as == for equality comparison, % for modulo, or | for bitwise OR.
• Copy-paste error: Review the duplicated expression and correct it to reference the intended variable or constant.

Code examples

Noncompliant code example

int flags = getFlags();
if ((flags & 0) == 0) { // Noncompliant
    // This block always executes
    doSomething();
}

Compliant solution

int flags = getFlags();
if ((flags & 0x01) == 0) {
    // Now this checks if the least significant bit is not set
    doSomething();
}

Resources

Documentation

• Java Documentation - Bitwise and Bit Shift Operators
• Wikipedia - Bitwise operation

Related rules

• {rule:java:S7438} - Bitwise AND with zero (Rust)