[Sema] Implement DR2386 for C++17 structured binding

[rnk]

Summary

Allow implementations to provide complete definitions of
std::tuple_size<T>, but to omit the 'value' member to signal that T is
not tuple-like. The Microsoft standard library implements
std::tuple_size<const T> this way.

If the value member exists, clang still validates that it is an ICE, but
if it does not, then the type is considered to not be tuple-like.

Fixes PR33236

[rsmith]

Looks good. Can you add a test to test/CXX/drs/dr23xx.cpp with a suitable dr2386: 10 comment to track that we've implemented DR2386 in Clang 10, please?

[Jeroen]

In the reproduction of https://bugs.llvm.org/show_bug.cgi?id=33236 there is explicit mentioning of const T. It would be nice if the test cases for this fix would also have coverage for that.

clang/test/CXX/dcl.decl/dcl.decomp/p3.cpp

15 ↗

(On Diff #214483)

In the reproduction of https://bugs.llvm.org/show_bug.cgi?id=33236 there is explicit mentioning of const T. It would be nice if the test cases for this fix would also have coverage for that.

[thakis]

rnk, what's the status here?

[rnk]

In D66040#1631658, @thakis wrote:

rnk, what's the status here?

I think I can get this in today, things just got busy here and I forgot about this. I have to add that test.

clang/test/CXX/dcl.decl/dcl.decomp/p3.cpp

15 ↗

(On Diff #214483)

I'll work it into the dr2386 test case.

[rnk]

• add DR test case

[rsmith]

LGTM with minor adjustments to the test.

clang/test/CXX/drs/dr23xx.cpp

43–57 ↗

(On Diff #215442)

Please add a comment

// dr2386: 9

so that the script that generates cxx_dr_status.html knows to mark that issue as done.

It'd be good to also move as much of this test into a namespace dr2386 as possible. (Clearly some parts of it need to be in namespace std, but I'd prefer that those parts be kept as small as possible to isolate this test from others in the same file.)

cfe/trunk/lib/Sema/SemaDeclCXX.cpp

static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T,
 
   DeclarationName Value = S.PP.getIdentifierInfo("value");
   LookupResult R(S, Value, Loc, Sema::LookupOrdinaryName);
 
   // Form template argument list for tuple_size<T>.
   TemplateArgumentListInfo Args(Loc, Loc);
   Args.addArgument(getTrivialTypeTemplateArgument(S, Loc, T));
 
-  // If there's no tuple_size specialization, it's not tuple-like.
-  if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/0))
+  // If there's no tuple_size specialization or the lookup of 'value' is empty,
+  // it's not tuple-like.
+  if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/ 0) ||
+      R.empty())
     return IsTupleLike::NotTupleLike;
 
   // If we get this far, we've committed to the tuple interpretation, but
   // we can still fail if there actually isn't a usable ::value.
 
   struct ICEDiagnoser : Sema::VerifyICEDiagnoser {
     LookupResult &R;
     TemplateArgumentListInfo &Args;
     ICEDiagnoser(LookupResult &R, TemplateArgumentListInfo &Args)
         : R(R), Args(Args) {}
     void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) {
       S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
           << printTemplateArgs(S.Context.getPrintingPolicy(), Args);
     }
   } Diagnoser(R, Args);
 
-  if (R.empty()) {
-    Diagnoser.diagnoseNotICE(S, Loc, SourceRange());
-    return IsTupleLike::Error;
-  }
-
   ExprResult E =
       S.BuildDeclarationNameExpr(CXXScopeSpec(), R, /*NeedsADL*/false);
   if (E.isInvalid())
     return IsTupleLike::Error;
 
   E = S.VerifyIntegerConstantExpression(E.get(), &Size, Diagnoser, false);
   if (E.isInvalid())
     return IsTupleLike::Error;

cfe/trunk/test/CXX/dcl.decl/dcl.decomp/p3.cpp

 // RUN: %clang_cc1 -std=c++1z -verify %s
 
 using size_t = decltype(sizeof(0));
 
 struct A { int x, y; };
 struct B { int x, y; };
 
 void no_tuple_size_1() { auto [x, y] = A(); } // ok, decompose elementwise
 
 namespace std { template<typename T> struct tuple_size; }
 void no_tuple_size_2() { auto [x, y] = A(); } // ok, decompose elementwise
 
 struct Bad1 { int a, b; };
 template<> struct std::tuple_size<Bad1> {};
-void no_tuple_size_3() { auto [x, y] = Bad1(); } // expected-error {{cannot decompose this type; 'std::tuple_size<Bad1>::value' is not a valid integral constant expression}}
+void no_tuple_size_3() { auto [x, y] = Bad1(); } // ok, omitting value is valid after DR2386
 
 struct Bad2 {};
 template<> struct std::tuple_size<Bad2> { const int value = 5; };
 void no_tuple_size_4() { auto [x, y] = Bad2(); } // expected-error {{cannot decompose this type; 'std::tuple_size<Bad2>::value' is not a valid integral constant expression}}
 
 template<> struct std::tuple_size<A> { static const int value = 3; };
 template<> struct std::tuple_size<B> { enum { value = 3 }; };
 

cfe/trunk/test/CXX/drs/dr23xx.cpp

#pragma clang __debug dump not_use
   int not_use_2(X *x) {
     // CHECK: MemberExpr {{.*}} ->n {{.*}} non_odr_use_constant
     // CHECK: DeclRefExpr {{.*}} 'x'
     return x->n;
   }
 #pragma clang __debug dump not_use_2
 }
 
+#if __cplusplus >= 201707L
+// Otherwise, if the qualified-id std::tuple_size<E> names a complete class
+// type **with a member value**, the expression std::tuple_size<E>::value shall
+// be a well-formed integral constant expression
+namespace dr2386 { // dr2386: 9
+struct Bad1 { int a, b; };
+struct Bad2 { int a, b; };
+} // namespace dr2386
+namespace std {
+template <typename T> struct tuple_size;
+template <> struct std::tuple_size<dr2386::Bad1> {};
+template <> struct std::tuple_size<dr2386::Bad2> {
+  static const int value = 42;
+};
+} // namespace std
+namespace dr2386 {
+void no_value() { auto [x, y] = Bad1(); }
+void wrong_value() { auto [x, y] = Bad2(); } // expected-error {{decomposes into 42 elements}}
+} // namespace dr2386
+#endif
+
 namespace dr2387 { // dr2387: 9
 #if __cplusplus >= 201402L
   template<int> int a = 0;
   extern template int a<0>; // ok
 
   template<int> static int b = 0;
   extern template int b<0>; // expected-error {{internal linkage}}
 
   template<int> const int c = 0;
   extern template const int c<0>; // ok, has external linkage despite 'const'
 
   template<typename T> T d = 0;
   extern template int d<int>;
   extern template const int d<const int>;
 #endif
 }