Non-constant tuple_size in structured binding is accepted

[halbi2]

#include <tuple>
struct A {
  template<int> friend int get(A);
};
struct Conv {
  constexpr operator int() { return 2; }
};
template<> struct std::tuple_size<A> {
  static Conv& value; // no definition
};
template<int N> struct std::tuple_element<N, A> {
  using type = int;
};
auto [a,b] = A();

I think this TU is invalid, because tuple_size<A>::value is not an integral constant expression.
clang++ -std=c++20 -c rejects.
clang++ -std=c++23 -c accepts.
Is this intended for P2280? But other compilers support P2280 too, and they all reject this tuple_size code.

I think #132463 could relate.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (halbi2)

``` #include <tuple> struct A { template<int> friend int get(A); }; struct Conv { constexpr operator int() { return 2; } }; template<> struct std::tuple_size<A> { static Conv& value; // no definition }; template<int N> struct std::tuple_element<N, A> { using type = int; }; auto [a,b] = A(); ```

I think this TU is invalid, because tuple_size<A>::value is not an integral constant expression.
clang++ -std=c++20 -c rejects.
clang++ -std=c++23 -c accepts.
Is this intended for P2280? But other compilers support P2280 too, and they all reject this tuple_size code.

I think #132463 could relate.

[frederick-vs-ja]

Is this intended for P2280?

Possibly it is, but for Clang only, I believe.

But other compilers support P2280 too,

This seems to be wrong. Currently only GCC and Clang has implemented P2280. MSVC rejects this due to not implementing P2280R4.

I think GCC is correct, while MSVC and Clang are wrong here.

Consider this example which doesn't involve unknown reference Godbolt link:

#include <tuple>
struct A {
  template<int> friend int get(A);
};

struct Conv {
  constexpr operator int() const { return 2; }
};

template<> struct std::tuple_size<A> {
  static constexpr Conv my_conv{};
  static constexpr const Conv& value = my_conv;
};

template<int N> struct std::tuple_element<N, A> {
  using type = int;
};
auto [a,b] = A();

Per [dcl.struct.bind]/7, it is required when tuple case is used, tuple_size<E>::value shall be a well-formed integral constant expression. Also per [expr.const]/19, the expression must be of integer or unscoped enumeration type before lvalue-to-rvalue conversion (if any).

As a Conv or const Conv lvalue can't be an integral constant expression, the tuple_size<A>::value should be considered invalid in structured binding.

[llvmbot]

@llvm/issue-subscribers-c-17

Author: None (halbi2)

``` #include <tuple> struct A { template<int> friend int get(A); }; struct Conv { constexpr operator int() { return 2; } }; template<> struct std::tuple_size<A> { static Conv& value; // no definition }; template<int N> struct std::tuple_element<N, A> { using type = int; }; auto [a,b] = A(); ```

I think this TU is invalid, because tuple_size<A>::value is not an integral constant expression.
clang++ -std=c++20 -c rejects.
clang++ -std=c++23 -c accepts.
Is this intended for P2280? But other compilers support P2280 too, and they all reject this tuple_size code.

I think #132463 could relate.