[clang + libstdc++] Error when using Clang 19 to compile Catch2's REQUIRE over tuple against libstdc++ in C++23 mode

[horenmar]

I got a bug report in Catch2, that with the specific combination of

• Clang 19.1
• libstdc++ as the stdlib
• C++23 as the language mode

a relatively simple assertion comparing two tuples does not compile.

example

#include <catch2/catch_test_macros.hpp>
#include <tuple>

TEST_CASE("tuples") {
    std::tuple<int, int> bob;
    CHECK(bob == std::make_tuple(4, 2));
}

This code compiles when the language mode is C++20, when using Clang 18 + C++23, when using Clang 19 + libc++, or when using GCC + libstdc++, but not in the specific Clang 19 + libstdc++ + C++23 combination.

[cor3ntin]

It might be related to #54440 - Not entirely sure. It starts failing because libstdc++ implemented P2165
in their c++23 mode
@zyn0217

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Martin Hořeňovský (horenmar)

I got a bug report in Catch2, that with the specific combination of * Clang 19.1 * libstdc++ as the stdlib * C++23 as the language mode

a relatively simple assertion comparing two tuples does not compile.

example

#include <catch2/catch_test_macros.hpp>
#include <tuple>

TEST_CASE("tuples") {
    std::tuple<int, int> bob;
    CHECK(bob == std::make_tuple(4, 2));
}

This code compiles when the language mode is C++20, when using Clang 18 + C++23, when using Clang 19 + libc++, or when using GCC + libstdc++, but not in the specific Clang 19 + libstdc++ + C++23 combination.

[cor3ntin]

A reproducer would be nice but requires a recent libstdc++ - probably trunk
@Endilll

[Endilll]

Confirmed on Clang 10 and newer: https://compiler-explorer.com/z/ca13r74Eq
Bisected to 974c8b7.
Could it be that we're missing a SFINAE trap somewhere around synthesized operators?
Reduced by me and C-Reduce:

template <typename>
struct tuple_size;

template <typename T>
constexpr int tuple_size_v = tuple_size<T>::value;

struct tuple {};

struct Decomposer {
  int operator<=(tuple);
};

template <int>
struct comparison_category {};

template <typename T>
comparison_category<tuple_size_v<T>> operator<=>(tuple, T);

void f() {
  Decomposer{} <= tuple{};
}

Clang 20.0 output:

<source>:5:30: error: implicit instantiation of undefined template 'tuple_size<Decomposer>'
    5 | constexpr int tuple_size_v = tuple_size<T>::value;
      |                              ^
<source>:21:21: note: in instantiation of variable template specialization 'tuple_size_v<Decomposer>' requested here
   21 | comparison_category<tuple_size_v<T>> operator<=>(tuple, T);
      |                     ^
<source>:25:16: note: while substituting deduced template arguments into function template 'operator<=>' [with T = Decomposer]
   25 |   Decomposer{} <= tuple{};
      |                ^
<source>:2:8: note: template is declared here
    2 | struct tuple_size;
      |        ^
<source>:25:16: warning: relational comparison result unused [-Wunused-comparison]
   25 |   Decomposer{} <= tuple{};
      |   ~~~~~~~~~~~~~^~~~~~~~~~

[llvmbot]

@llvm/issue-subscribers-c-20

Author: Martin Hořeňovský (horenmar)

I got a bug report in Catch2, that with the specific combination of * Clang 19.1 * libstdc++ as the stdlib * C++23 as the language mode

a relatively simple assertion comparing two tuples does not compile.

example

#include <catch2/catch_test_macros.hpp>
#include <tuple>

TEST_CASE("tuples") {
    std::tuple<int, int> bob;
    CHECK(bob == std::make_tuple(4, 2));
}

This code compiles when the language mode is C++20, when using Clang 18 + C++23, when using Clang 19 + libc++, or when using GCC + libstdc++, but not in the specific Clang 19 + libstdc++ + C++23 combination.