Obviously I expect any program with if true { /* then_expr */ } else { /* else_expr */ } to be optimized by the compiler to /* then_expr */ and if false { /* then_expr */ } else { /* else_expr */ } to /* else_expr */.
However, to handle the case with optimizations turned completely off or even just to alleviate the job of the compiler, it seems that the definition using a double #[cfg(...)] is strictly better than the current if cfg!(...) definition.
The point of debug_assert! is writing conditionally compiled code; and the point of conditionally compiled code is that when the condition is not met, the code is not compiled and may thus not even be parsed.
There may even be a problem if, for instance, one were to define a conditionally compiled function / method / property only used in debug_asserts, and find out that since the current one always compiles the (unreachable) debug assert expression that his code does not compile.
Playground example (you may toggle comment/uncomment my own debug_assert overrides and toggle debug/release to test both cfg cases).
As a practical example, some monomorphized functions / methods called only in debug_assert! expressions could be stripped out of the resulting binary since they are unreachable and thus unused code.
Turning them off at compile time is potentially good for correctness, but you can also rely on the optimizer stripping them out automatically. (If you're really concerned about binary size, you should be running a stripper on your produced binary anyway to catch things LLVM didn't.)