assertions_on_constants

[pacak]

Summary

I have some constants in my code and trying to make sure that some relation between them holds. Using an assert seem like an obvious choice and indeed - when I make a mistake - program fails to compile. Clippy complains that the check will be optimized away. While technically that's correct, compiler first performs the check so assert totally works as expected or even better - a compile time error instead of a runtime one.

Is this a useful lint/behavior? It also comes with some cosmetic issues - I didn't write assert!(false), I wrote something else:

warning: `assert!(false)` should probably be replaced
   --> src/main.rs:191:9
    |
191 |         assert!(1 == (1 + 1));
    |         ^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use `panic!()` or `unreachable!()`
    = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
    = note: `#[warn(clippy::assertions_on_constants)]` on by default

Even assert!(false, "message") can be useful if you want to prevent a certain combination of feature flags from compiling.

A related ticket: #8159

Lint Name

clippy::assertions_on_constants

Reproducer

I tried this code:

const: u32 FOO = 4;
const: u32 BAR = 16;
assert!(BAR % FOO == 0, "make sure BAR is a multiple of FOO");

I saw this happen:

warning: `assert!(true)` will be optimized out by the compiler

I expected to see this happen:

No warning?

Version

cargo clippy --version                                                                                                                                                                                               clippy 0.1.88 (6b00bc3880 2025-06-23)

% rustc -Vv
rustc 1.88.0 (6b00bc388 2025-06-23)
binary: rustc
commit-hash: 6b00bc3880198600130e1cf62b8f8a93494488cc
commit-date: 2025-06-23
host: x86_64-unknown-linux-gnu
release: 1.88.0
LLVM version: 20.1.5

Additional Labels

No response

[ada4a]

Maybe the lint should give an alternative suggestion of putting the assert! in a const itself, so that it can fail at compile-time? With your code, that would look something like this:

const FOO: u32 = 4;
const BAR: u32 = 16;
const _: () = assert!(BAR % FOO == 0, "make sure BAR is a multiple of FOO");

EDIT: apparently, the constified assert would get linted as well: #8159 (comment)

[ada4a]

Oh and the lint seems to just check that the expression can be const-evaluated to true/false, not that it is a literal bool, which is what the lint docs suggest.

So I think it should react to the two cases differently:

• if it's a literal bool, lint as before
• if it's a const-evaluatable expression, suggest putting the assert into a const (and make sure to retain the expr, not its evaluated version)

[ada4a]

Aside:

Even assert!(false, "message") can be useful if you want to prevent a certain combination of feature flags from compiling.

is better achieved with compile_fail!

Maybe the lint could recommend that as well if all the sub-expressions inside the assert are cfg!(...)

[ada4a]

Oh, but I guess one could also have written something like assert!(2 * 2 == 5) as a replacement for assert!(false), and that should probably get linted as well. So the lint condition would need to look something like this:

if expr.can_be_const_evald()
    && !expr.contains_consts()