[Clang] Fix capture of values initialized by bitfields

[cor3ntin]

Summary

This fixes a regression introduced in 127bf44

[aaron.ballman]

clang/test/SemaCXX/lambda-expressions.cpp

680 ↗

(On Diff #450128)

This still should be accepted -- a is an const int & that was materialized from a temporary and lifetime extended, so it's not a bit-field.

[cor3ntin]

Better approach: revert the whole thing.

[ayermolo]

Thanks for reverting this.
Previous commit broke build of projects using fmt library.
https://github.com/fmtlib/fmt/blame/master/include/fmt/format.h

fmt/fmt/include/fmt/format.h:1904:9: error: cannot capture a bit-field by reference
     if (sign) *it++ = detail::sign<Char>(sign);
         ^
 fmt/fmt/include/fmt/format.h:1814:8: note: 'sign' declared here
   auto sign = fspecs.sign;
        ^
 fmt/fmt/include/fmt/core.h:2741:10: note: bit-field is declared here
   sign_t sign : 8;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def ext_ms_anonymous_record : ExtWarn<
   "anonymous %select{structs|unions}0 are a Microsoft extension">,
   InGroup<MicrosoftAnonTag>;
 
 // C++ local classes
 def err_reference_to_local_in_enclosing_context : Error<
   "reference to local %select{variable|binding}1 %0 declared in enclosing "
   "%select{%3|block literal|lambda expression|context}2">;
-def err_bitfield_capture_by_ref : Error<
-  "cannot capture a bit-field by reference">;
 def err_capture_binding_openmp : Error<
   "capturing a structured binding is not yet supported in OpenMP">;
 def ext_capture_binding : ExtWarn<
   "captured structured bindings are a C++20 extension">, InGroup<CXX20>;
 def warn_cxx17_compat_capture_binding : Warning<
   "captured structured bindings are incompatible with "
   "C++ standards before C++20">,
   InGroup<CXXPre20Compat>, DefaultIgnore;

clang/lib/Sema/SemaExpr.cpp

static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var,
                             Sema &S, bool Invalid) {
   // Determine whether we are capturing by reference or by value.
   bool ByRef = false;
   if (IsTopScope && Kind != Sema::TryCapture_Implicit) {
     ByRef = (Kind == Sema::TryCapture_ExplicitByRef);
   } else {
     ByRef = (LSI->ImpCaptureStyle == LambdaScopeInfo::ImpCap_LambdaByref);
   }
-  // C++20 : [expr.prim.lambda.capture]p12
-  // A bit-field or a member of an anonymous union shall
-  // not be captured by reference.
-  MemberExpr *ME = nullptr;
-  BindingDecl *BD = nullptr;
-  if (auto *V = dyn_cast<VarDecl>(Var)) {
-    if (V->getInit())
-      ME = dyn_cast<MemberExpr>(V->getInit()->IgnoreImplicit());
-  } else if ((BD = dyn_cast<BindingDecl>(Var))) {
-    ME = dyn_cast_or_null<MemberExpr>(BD->getBinding());
-  }
-
-  // Capturing a bitfield by reference is not allowed except in OpenMP.
-  if (ByRef && ME &&
-      (isa<BindingDecl>(Var) || !S.LangOpts.OpenMP ||
-       !S.isOpenMPCapturedDecl(Var))) {
-    const auto *FD = dyn_cast_or_null<FieldDecl>(ME->getMemberDecl());
-    if (FD && FD->isBitField()) {
-      if (BuildAndDiagnose) {
-        S.Diag(Loc, diag::err_bitfield_capture_by_ref) << Var;
-        S.Diag(Var->getLocation(), diag::note_entity_declared_at) << Var;
-        S.Diag(FD->getLocation(), diag::note_bitfield_decl) << FD;
-      }
-      Invalid = true;
-    }
-  }
+
+  BindingDecl *BD = dyn_cast<BindingDecl>(Var);
   // FIXME: We should support capturing structured bindings in OpenMP.
   if (!Invalid && BD && S.LangOpts.OpenMP) {
     if (BuildAndDiagnose) {
       S.Diag(Loc, diag::err_capture_binding_openmp) << Var;
       S.Diag(Var->getLocation(), diag::note_entity_declared_at) << Var;
     }
     Invalid = true;
   }

clang/test/SemaCXX/cxx1z-decomposition.cpp

static auto [m] = S(); // expected-note {{'m' declared here}} \
                          // expected-warning {{C++20}}
 
   struct R { int f() { return m; } };
   (void) [&] { return m; };
   (void)[m]{}; // expected-error {{'m' cannot be captured because it does not have automatic storage duration}}
 
   (void)[outerbit1]{}; // expected-error {{'outerbit1' cannot be captured because it does not have automatic storage duration}}
 
-  auto [bit, var] = S2{1, 1}; // expected-note 4{{'bit' declared here}}
+  auto [bit, var] = S2{1, 1}; // expected-note 2{{'bit' declared here}}
 
-  (void)[&bit] { // expected-error {{cannot capture a bit-field by reference}} \
+  (void)[&bit] { // expected-error {{non-const reference cannot bind to bit-field 'a'}} \
                     // expected-warning {{C++20}}
     return bit;
   };
 
   union { // expected-note {{declared here}}
     int u;
   };
 
   (void)[&] { return bit + u; } // expected-error {{unnamed variable cannot be implicitly captured in a lambda expression}} \
-                                // expected-error {{cannot capture a bit-field by reference}} \
+                                // expected-error {{non-const reference cannot bind to bit-field 'a'}} \
                                 // expected-warning {{C++20}}
   ();
 }
 
 void bitfield() {
   struct { int a : 3, : 4, b : 5; } a;
   auto &[x, y] = a;
   auto &[p, q, r] = a; // expected-error-re {{type 'struct (unnamed struct at {{.*}})' decomposes into 2 elements, but 3 names were provided}}