On Wed, Mar 26, 2025 at 3:16 PM JJ Marr wrote:
>
> I am actually trying to fix this unclear diagnostic in Clang. `assert` is allowed
> in a constant expression by the spec (so long as the expression is true), and
> the way most libcs fail an assert during constant evaluation is by calling an
> implementation-defined function that is not a constant expression (e.g. `__assert_fail`).
>
> https://github.com/llvm/llvm-project/pull/130458
>
> I'd welcome your input on that PR. I'm overloaded with schoolwork and can't figure out why I broke a bunch of test cases.


I didn't realise that the 'assert' was being evaluated and failing in
a constant-evaluated context.

Not to sound too farcical, but that diagnostic message can be fixed if
you pipe g++ (or clang) into 'sed' at the command line as follows:

    g++ -o prog main.cpp | sed 's/call to
non-\xe2\x80\x98constexpr\xe2\x80\x99 function \xe2\x80\x98void
__assert_fail\x28const char\*, const char\*, unsigned int, const
char\*\x29\xe2\x80\x99/Assertion failed in constant-evaluated
context/g'

This changes the output to the following:

    md5.hpp:244:21: error: Assertion failed in constant-evaluated context
      244 | assert( 0u == (*ptr >> 8u) );

Or internally in your compiler source code, find the function where
diagnostic messages get printed to stdout (or stderr, whatever), and
do something like this:

    #include <cassert> // assert
    #include <cstddef> // size_t
    #include <cstdio> // puts
    #include <cstring> // strcat, strcpy, strlen, strstr

    constexpr char const *replacements[] = {
        "call to non-‘constexpr’ function ‘void __assert_fail(const
char*, const char*, unsigned int, const char*)’",
        "Assertion failed in constant-evaluated context",

        "md5.hpp",
        "aes.hpp",

        "error",
        "Error",
    };

    // Next line makes sure we have even pairs
    static_assert( 0u == ((sizeof replacements / sizeof *replacements) % 2u) );

    void PrintMsg(char *const p) noexcept
    {
        using std::size_t, std::strlen;

        for ( size_t i = 0u; i < (sizeof replacements / sizeof
*replacements); i += 2u )
        {
            if ( char *const needle = const_cast<char*>(std::strstr(p,
replacements[i+0])); nullptr != needle )
            {
                size_t const len_of_original = strlen(replacements[i+0]),
                            len_of_replacement = strlen(replacements[i+1]);

                assert( len_of_original >= len_of_replacement );

                std::memcpy ( needle, replacements[i+1], len_of_replacement );
                std::memmove( needle + len_of_replacement, needle +
len_of_original, strlen(needle + len_of_original) + 1u );
            }
        }

        std::printf("%s", p);
    }


    // ========== Now to test it out

    char output[] =
        "md5.hpp:244:21: error: call to non-‘constexpr’ function ‘void
__assert_fail(const char*, const char*, unsigned int, const char*)’\n"
        " 244 | assert( 0u == (*ptr >> 8u) );"
    ;

    int main(void)
    {
        PrintMsg(output);
    }

Tested and working on GodBolt: https://godbolt.org/z/jcvPoqTqf

If you're not allowed to edit the string passed to PrintMsg, then
either copy it to another buffer, or undo the change before returning.