Since when is the existing always_inline a mere hint? And since when
is it a request that emits a mere warning if the compiler fails to do
what it's told
to do by that attribute? I mean other than for indirect calls.

[[gnu::always_inline]] is treated as an ignorable hint by Clang. See https://godbolt.org/z/exTed6zWY See https://clang.llvm.org/docs/AttributeReference.html#always-inline-force-inline Maybe there is a way to get Clang to issue a warning when [[gnu::always_inline]] is being ignored; it seems like failure is being silently swept under the rug.

GCC issues an error when it fails to inline with [[gnu::always_inline]] applied.

Could we perhaps not reinvent the existing attributes with the same
spelling but with a different meaning?

Making the attributes ignorable hints would be consistent with Clang, so it's standardizing existing practice.

It's also similar to how constinit works (https://eel.is/c++draft/dcl.constinit#2). constinit is stated to make the program ill-formed when dynamic initialization happens, without imposing any change in semantics to initialization (e.g. making things constant-evaluated that otherwise wouldn't be). It's just a means of diagnosing accidental dynamic initialization, just like, say, a standard [[nrvo]] would diagnose an accidental failure to perform NRVO.

Of course, one of these results in an error and the other in a warning, but there's really no reason why we couldn't have had a [[constinit]] attribute in that style, and you could achieve the same effect using -Werror=... after all.