tautological warnings for is_constant_evaluated not emitted in c++23/26 modes

[cor3ntin]

for

int main() {
   if constexpr(std::is_constant_evaluated()) { }
}

We usually warn

'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression [-Wconstant-evaluated]

However this warning is gone in c++23 mode

https://godbolt.org/z/KKPKvveGM

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: cor3ntin (cor3ntin)

for

int main() {
   if constexpr(std::is_constant_evaluated()) { }
}

We usually warn
> 'std::is_constant_evaluated' will always evaluate to 'true' in a manifestly constant-evaluated expression [-Wconstant-evaluated]

However this warning is gone in c++23 mode

https://godbolt.org/z/KKPKvveGM

[localspook]

Looks like the problem is that when compiling as C++23, libstdc++ switches its implementation of is_constant_evaluated to not use the builtin (unlike libc++, which always uses the builtin):
https://github.com/gcc-mirror/gcc/blob/3b3f336af29c6f25b7ded05ae037b5ab57b2ae67/libstdc%2B%2B-v3/include/std/type_traits#L4099-L4107
I'm not familiar enough with clang to know what the proper fix is though. Report an issue against libstdc++? Start matching against not just the builtin, but the std::is_constant_evaluated function itself?

[cor3ntin]

@jwakely

[jwakely]

Report an issue against libstdc++?

What would the issue be? That we use a more efficient implementation than the built-in?

In C++23 libstdc++ defines std::is_constant_evaluated using if consteval { return true; } else { return false; } because it's cheaper for GCC to compile that.

  [[__gnu__::__always_inline__]]
  constexpr bool
  is_constant_evaluated() noexcept
  {
#if __cpp_if_consteval >= 202106L
    if consteval { return true; } else { return false; }
#else
    return __builtin_is_constant_evaluated();
#endif
  }

In theory we could change that to #if __cpp_if_consteval >= 202106L && ! __clang__ but I'd rather not.

[jwakely]

Reduced:

namespace std
{
    [[gnu::always_inline]]
    constexpr bool is_constant_evaluated()
    {
#if __cpp_if_consteval >= 202106L
        if consteval { return true; }
        else { return false; }
#else
        return __builtin_is_constant_evaluated();
#endif
    }
}

int main() {
   if constexpr(std::is_constant_evaluated()) { }
}

https://godbolt.org/z/PPd6vs7TK

[tbaederr]

Those warnings are emitted from

llvm-project/clang/lib/AST/ExprConstant.cpp

Lines 13661 to 13674 in cf444ac

	if (Info.InConstantContext && !Info.CheckingPotentialConstantExpression &&
	(Info.CallStackDepth == 1 ||
	(Info.CallStackDepth == 2 && Callee->isInStdNamespace() &&
	Callee->getIdentifier() &&
	Callee->getIdentifier()->isStr("is_constant_evaluated")))) {
	// FIXME: Find a better way to avoid duplicated diagnostics.
	if (Info.EvalStatus.Diag)
	Info.report((Info.CallStackDepth == 1)
	? E->getExprLoc()
	: Info.CurrentCall->getCallRange().getBegin(),
	diag::warn_is_constant_evaluated_always_true_constexpr)
	<< (Info.CallStackDepth == 1 ? "__builtin_is_constant_evaluated"
	: "std::is_constant_evaluated");
	}

We could of course do a similar check for general calls and check if those calls are to std::is_constant_evaluated(), but that would be even uglier.

[localspook]

In theory we could change that to #if __cpp_if_consteval >= 202106L && ! clang but I'd rather not.

That’s what I had in mind, and it’s a simpler change than fixing it in clang, so I threw the idea out there. I agree that making changes in libstdc++ specifically to accommodate clang isn’t ideal.