address feedback

Author: cor3ntin

clang/docs/LanguageExtensions.rst

@@ -1922,10 +1922,12 @@ The ``__builtin_structured_binding_size(T)`` type trait returns
 the *structured binding size* ([dcl.struct.bind]) of type ``T``
 
 This is equivalent to the size of the pack ``p`` in ``auto&& [...p] = declval<T&>();``.
-If the argument cannot be decomposed (ie not a builtin array, builtin SIMD vector,
-builtin complex, *tuple-like* type or destructurable class type),
-``__builtin_structured_binding_size(T)`` is not a valid expression
-(``__builtin_structured_binding_size`` is SFINAE-friendly).
+If the argument cannot be decomposed, ``__builtin_structured_binding_size(T)``
+is not a valid expression (``__builtin_structured_binding_size`` is SFINAE-friendly).
+
+builtin arrays, builtin SIMD vectors,
+builtin complex types, *tuple-like* types, and decomposable class types
+are decomposable types.
 
 A type is considered a valid *tuple-like* if ``std::tuple_size_v<T>`` is a valid expression,
 even if there is no valid ``std::tuple_element`` specialization or suitable

clang/lib/Sema/SemaDeclCXX.cpp

@@ -1479,7 +1479,7 @@ static bool CheckMemberDecompositionFields(Sema &S, SourceLocation Loc,
                                            const CXXRecordDecl *OrigRD,
                                            QualType DecompType,
                                            DeclAccessPair BasePair) {
-  const CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
+  const auto *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
   if (!RD)
     return true;
 
@@ -1527,7 +1527,7 @@ static bool checkMemberDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
   CXXCastPath BasePath;
   DeclAccessPair BasePair =
       findDecomposableBaseClass(S, Src->getLocation(), OrigRD, BasePath);
-  const CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
+  const auto *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
   if (!RD)
     return true;
   QualType BaseType = S.Context.getQualifiedType(S.Context.getRecordType(RD),
@@ -1698,7 +1698,7 @@ std::optional<unsigned> Sema::GetDecompositionElementCount(QualType T,
   CXXCastPath BasePath;
   DeclAccessPair BasePair =
       findDecomposableBaseClass(*this, Loc, OrigRD, BasePath);
-  const CXXRecordDecl *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
+  const auto *RD = cast_or_null<CXXRecordDecl>(BasePair.getDecl());
   if (!RD)
     return std::nullopt;
 

clang/lib/Sema/SemaExpr.cpp

@@ -4685,9 +4685,9 @@ Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
   } else if (ExprKind == UETT_VecStep) {
     isInvalid = CheckVecStepExpr(E);
   } else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
-    Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
-    isInvalid = true;
-  } else if (E->refersToBitField()) { // C99 6.5.3.4p1.
+      Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
+      isInvalid = true;
+  } else if (E->refersToBitField()) {  // C99 6.5.3.4p1.
     Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
     isInvalid = true;
   } else if (ExprKind == UETT_VectorElements) {

clang/lib/Sema/SemaExprCXX.cpp

@@ -5066,7 +5066,7 @@ static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   case UTT_IsInterfaceClass:
     return true;
 
-  // We diagnose incomplete class types later
+  // We diagnose incomplete class types later.
   case UTT_StructuredBindingSize:
     return true;
 

clang/test/SemaCXX/builtin-structured-binding-size.cpp

@@ -6,6 +6,10 @@ struct S0 {};
 struct S1 {int a;};
 struct S2 {int a; int b;};
 struct S3 {double a; int b; int c;};
+struct S4 {int a: 1; int b :2;};
+struct S5 {int : 1; int b :2;};
+struct S6 {union {int a;}; }; // #note-anon-union
+struct S7 {int a[];};
 
 
 
@@ -29,6 +33,20 @@ static_assert(__builtin_structured_binding_size(S1) == 0);
 // expected-error@-1 {{static assertion failed due to requirement '__builtin_structured_binding_size(S1) == 0'}} \
 // expected-note@-1 {{expression evaluates to '1 == 0'}}
 static_assert(__builtin_structured_binding_size(S1) == 1);
+static_assert(__builtin_structured_binding_size(S2) == 2);
+static_assert(__builtin_structured_binding_size(S3) == 3);
+static_assert(__builtin_structured_binding_size(S4) == 2);
+static_assert(__builtin_structured_binding_size(S5) == 2);
+// expected-error@-1 {{static assertion failed due to requirement '__builtin_structured_binding_size(S5) == 2'}} \
+// expected-note@-1 {{expression evaluates to '1 == 2'}}
+static_assert(__builtin_structured_binding_size(S6) == 2);
+// expected-error@-1 {{static assertion failed due to requirement '__builtin_structured_binding_size(S6) == 2'}} \
+// expected-error@-1 {{cannot decompose class type 'S6' because it has an anonymous union member}} \
+// expected-note@-1 {{expression evaluates to '1 == 2'}}
+// expected-note@#note-anon-union {{declared here}}
+static_assert(__builtin_structured_binding_size(S7) == 1);
+
+
 static_assert(__builtin_structured_binding_size(SD) == 1);
 static_assert(__builtin_structured_binding_size(SE1) == 1);
 // expected-error@-1 {{cannot decompose class type 'SE1': both it and its base class 'S1' have non-static data members}} \
@@ -151,6 +169,16 @@ static_assert(!is_destructurable<TSizeError>);
 }
 
 
+struct S {
+  int x;
+  int y;
+  static_assert(__builtin_structured_binding_size(S) == 2);
+  //expected-error@-1 {{incomplete type 'S' where a complete type is required}} \
+  // expected-error@-1 {{type 'S' cannot be decomposed}} \
+  // expected-error@-1 {{static assertion expression is not an integral constant expression}} \
+  // expected-note@-4 {{definition of 'S' is not complete until the closing '}'}}
+};
+
 // Check we can implement std::exec::tag_of_t
 template <typename T>
 struct type_identity {