Hi Matt, Thanks for the report! (Big fan of godbolt.org)

Note that this reproducer doesn't compile with any combination of Clang, GCC, libstdc++, and libc++. I suspect the bug is in the compiler side of the structured binding implementations.

Strictly speaking, neither const nor & capture is needed to expose the problem

In the case of libc++ it does, because libc++ currently incorrectly rejects the non-const case even though it should be accepted. That's the real libc++ bug here, and that bug is caused by providing an empty definition of the "tuple_size" primary template. I'll fix that bug shortly.

Note that this reproducer doesn't compile with any combination of Clang,
GCC, libstdc++, and libc++. I suspect the bug is in the compiler side of the
structured binding implementations.

I don't think so. Rather, I suspect neither libc++ nor libstdc++ have implemented http://cplusplus.github.io/LWG/lwg-defects.html#2770 yet.

Note that this reproducer doesn't compile with any combination of Clang,
GCC, libstdc++, and libc++. I suspect the bug is in the compiler side of the
structured binding implementations.

I don't think so. Rather, I suspect neither libc++ nor libstdc++ have
implemented http://cplusplus.github.io/LWG/lwg-defects.html#2770 yet.

Libc++ (just) now implements LWG 2770, but this still appears to be a Clang bug. It appears that Clang is checking of tuple_size is incomplete, not if tuple_size<Tp>::value is well formed. So even with LWG 2770 Clang appears incorrect.

Example:

#include
#include

struct S { int x; };

int main() {
S const s{99};
auto [p1] = s; // OK. looks at tuple_size and sees it is incomplete.
auto& [p2] = s; // error {{tuple_size::value is not an integral constant expression}}
}

Re-binning as Clang and re-titling to be more appropriate for Clang.

@​Richard please send this back to libc++ if I'm incorrect.

See wg21.link/p0490r0, GB 20 -- Clang is correct to test for tuple_size being complete. Sending back to libc++ =)

Hmm. Looks like it's actually a bug in the standard. For some reason, LWG 2770 only constrains tuple_size to have no member 'value' if tuple_size::value is not available, rather than making it an incomplete type, as CWG assumed LWG was going to do :(

On the core side, the idea is that if someone tries to specialize tuple_size but gets it wrong (for instance, if ::value is not usable in a constant expression), we want to give a hard error.

@​Richard I implemented a version of LWG 2770 which makes tuple_size incomplete in most situations.

It is up for review as D28222 (https://reviews.llvm.org/D28222).

Fixed in r291019 (v4.0). Unfortunately the fix is entirely non-standard, but the standard is clearly incorrect here. I'll submit a new resolution for LWG 2770 which mirrors what libc++ actually implements shortly.