[clang] Rejects-valid enum comparison that bypasses rewritten candidate `<=>`

[Eisenwave]

https://godbolt.org/z/vhxbYPq3j

#include <utility>

enum class e { a, b };

inline std::strong_ordering operator<=>(e, e) {
    return std::strong_ordering::less;
}

constexpr bool hoo(e lhs, e rhs) {
    if (lhs < rhs) {
        return true;
    }
    if (rhs >= lhs) {
        return false;
    }
    return false;
}

static_assert(hoo(e::a, e::b), "");

This code fails to compile:

<source>:19:15: error: static assertion expression is not an integral constant expression
   19 | static_assert(hoo(e::a, e::b), "");
      |               ^~~~~~~~~~~~~~~
<source>:10:13: note: non-constexpr function 'operator<=>' cannot be used in a constant expression
   10 |     if (lhs < rhs) {
      |             ^
<source>:19:15: note: in call to 'hoo(0, 1)'
   19 | static_assert(hoo(e::a, e::b), "");
      |               ^~~~~~~~~~~~~~~
<source>:5:29: note: declared here
    5 | inline std::strong_ordering operator<=>(e, e) {
      |                             ^

This error is incorrect. GCC accepts.

https://eel.is/c++draft/over.match.best.general#2.8 states that a function is a better candidate if it is rewritten and the other is not, and there exists a built-in candidate for < (https://eel.is/c++draft/over.match.oper#3.3, https://eel.is/c++draft/over.built) which would thus be better than the rewritten candidate which uses (lhs <=> rhs) < 0.

[cor3ntin]

Poking at the code, this is related to https://lists.isocpp.org/core/2019/10/7407.php (which was never turned into a CWG issue)

@zygoloid

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Jan Schultke (Eisenwave)

https://godbolt.org/z/vhxbYPq3j ```cpp #include <utility>

enum class e { a, b };

inline std::strong_ordering operator<=>(e, e) {
return std::strong_ordering::less;
}

constexpr bool hoo(e lhs, e rhs) {
if (lhs < rhs) {
return true;
}
if (rhs >= lhs) {
return false;
}
return false;
}

static_assert(hoo(e::a, e::b), "");

This code fails to compile:
```cpp
<source>:19:15: error: static assertion expression is not an integral constant expression
   19 | static_assert(hoo(e::a, e::b), "");
      |               ^~~~~~~~~~~~~~~
<source>:10:13: note: non-constexpr function 'operator<=>' cannot be used in a constant expression
   10 |     if (lhs < rhs) {
      |             ^
<source>:19:15: note: in call to 'hoo(0, 1)'
   19 | static_assert(hoo(e::a, e::b), "");
      |               ^~~~~~~~~~~~~~~
<source>:5:29: note: declared here
    5 | inline std::strong_ordering operator<=>(e, e) {
      |                             ^

This error is incorrect. GCC accepts.

https://eel.is/c++draft/over.match.best.general#2.8 states that a function is a better candidate if it is rewritten and the other is not, and there exists a built-in candidate for < (https://eel.is/c++draft/over.match.oper#3.3, https://eel.is/c++draft/over.built) which would thus be better than the rewritten candidate which uses (lhs <=> rhs) < 0.

[llvmbot]

@llvm/issue-subscribers-c-20

Author: Jan Schultke (Eisenwave)

https://godbolt.org/z/vhxbYPq3j ```cpp #include <utility>

enum class e { a, b };

inline std::strong_ordering operator<=>(e, e) {
return std::strong_ordering::less;
}

constexpr bool hoo(e lhs, e rhs) {
if (lhs < rhs) {
return true;
}
if (rhs >= lhs) {
return false;
}
return false;
}

static_assert(hoo(e::a, e::b), "");

This code fails to compile:
```cpp
<source>:19:15: error: static assertion expression is not an integral constant expression
   19 | static_assert(hoo(e::a, e::b), "");
      |               ^~~~~~~~~~~~~~~
<source>:10:13: note: non-constexpr function 'operator<=>' cannot be used in a constant expression
   10 |     if (lhs < rhs) {
      |             ^
<source>:19:15: note: in call to 'hoo(0, 1)'
   19 | static_assert(hoo(e::a, e::b), "");
      |               ^~~~~~~~~~~~~~~
<source>:5:29: note: declared here
    5 | inline std::strong_ordering operator<=>(e, e) {
      |                             ^

This error is incorrect. GCC accepts.

https://eel.is/c++draft/over.match.best.general#2.8 states that a function is a better candidate if it is rewritten and the other is not, and there exists a built-in candidate for < (https://eel.is/c++draft/over.match.oper#3.3, https://eel.is/c++draft/over.built) which would thus be better than the rewritten candidate which uses (lhs <=> rhs) < 0.