I've floated a similar idea a while ago, which is to make an "if provable" statement like

if provable (x == 0)

Such a statement would not be evaluated at runtime, and only be true when the compiler knows that x == 0 is true, similar to [[assume]]. In clang, this can be emulated already like

if (__builtin_constant_p(x == 0) && x == 0)

The problem here is x == 0 is not a constant expression, and it cannot be. The idea of "if provable" or your equivalent is to leverage optimizer knowledge, or knowledge during constant evaluation, but this cannot translate back into the type system so that you could use x as an array size or something.

My idea also received some negative feedback due to ODR concerns. Another approach would be to have "constexpr parameters", which I'm pretty sure has been proposed before, like

This would implicitly turn f into a function template. However, this solution is still kinda bad because it can only make use of x being a true constant expression; it doesn't benefit from the optimizer figuring out the value of x after optimization passes. The mylog example should still be optimized even if the base is not a constant expression, but it's revealed after optimization passes that the base is known to the optimizer.

Unfortunately, it is incredibly difficult to approach this design space. I think constexpr function parameters would be a good start, but ideally, you would have some way to write "optimizer scripts" to make this feature much more powerful.