[Clang][C++20] Support capturing structured bindings in lambdas

[cor3ntin]

Summary

This completes the implementation of P1091R3 and P1381R1.

This patch allow the capture of structured bindings
both for C++20+ and C++17, with extension/compat warning.

In addition, capturing an anonymous union member,
a bitfield, or a structured binding thereof now has a
better diagnostic.

We only support structured bindings - as opposed to other kinds
of structured statements/blocks. We still emit an error for those.

In addition, support for structured bindings capture is entirely disabled in
OpenMP mode as this needs more investigation - a specific diagnostic indicate the feature is not yet supported there.

Note that the rest of P1091R3 (static/thread_local structured bindings) was already implemented.

at the request of @shafik, i can confirm the correct behavior of lldb wit this change.

Fixes https://github.com/llvm/llvm-project/issues/54300
Fixes https://github.com/llvm/llvm-project/issues/54300
Fixes https://github.com/llvm/llvm-project/issues/52720

[cor3ntin]

This is not quite mature.
I think it needs a few more tests, notably codegen tests which I'm not sure how to write properly.

[cor3ntin]

Remote commented-out code

[cor3ntin]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

9060

I'm not sure we currently prohibit capturing a structured binding in openmp, i should fix that

[cor3ntin]

Fix tests?

[cor3ntin]

• formatting
• add more tests

[cor3ntin]

Fix typo in test, fix captureInLambda (was crashing in release and not debug)

[cor3ntin]

Add a diagnostic in openmp mode.

Supporting structured bindings in OpenMP mode requires OpenMP expertise,
so we emit a diagnostic in -fopenmp mode informing that feature is not supported
yet.
My idea is that whether and how openmp should handle this feature should not
delay support of the c++20 features for people who do not depend on OpenMP.

[cor3ntin]

Try to rerun the build

[cor3ntin]

• Add codegen test
• Fixed a typo that caused openmp test failures
• Cleanups & formatting

[cor3ntin]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

9060

I disabled the feature in OpenMP mode, as this needs more investigation

[cor3ntin]

Rebase

[cor3ntin]

Better codegen test

[cor3ntin]

Fix several conflicrs with the recently committed change to lambda captures
(D119136).

Also add to rewrite the code gen test. I'm not sure what, if anything
changed there, and the generated IR *seems* fine?

[cor3ntin]

• Rebase
• Cleanup codegen test

[cor3ntin]

clang/tools/libclang/CIndex.cpp

3353–3356

Note to self: typo

[shafik]

I think I need to do another sweep of this PR but mostly minor comments.

You should add tests for structured bindings binding to array and tuple-like types b/c the AST under the BindingDecl will be different for each of those cases and it would be worth verifying it works for all the cases. Although I don't see anything that looks like it would not.

[cor3ntin]

• fix typo
• add decompositions tests for the array and tuuple cases

[shafik]

Thank you for this work. This looks mostly good to me but I am not confident on all the code. I feel like there are some assumptions that maybe could use comments e.g. places where we know it can only be a VarDecl e.g. b/c it is an init capture.

clang/lib/CodeGen/CGExpr.cpp

2909

Why the assert? In the previous use of LambdaCaptureFields.lookup(...) we are not doing that.

clang/lib/Sema/SemaExpr.cpp

17856–17858

What are we checking here? Why does it only apply to VarDecls?

17927

This block does not follow the pattern of the blocks above, where they do if (Diagnose) and always return false. Your else if branch diagnoses but does not return false.

clang/lib/Sema/SemaInit.cpp

7792

I see we are doing this kind of check to see if we have a VarDecl and then check if it is an init capture and I wish there was a way not to repeat this but I don't see it.

clang/lib/Sema/SemaLambda.cpp

1213

We also do a hasLocalStorage() check in getParentOfCapturingContextOrNull(...) but only look for the VarDecl case there.

[cor3ntin]

• Rename diagnoseUncapturableValueReferenceOr => diagnoseUncapturableValueReferenceOrBinding
• Remove superfluous assert
• Check for unsupported binding decl in isVariableCapturable instead of BuildDeclarationNameExpr, which is cleaner and more consistent. Then getParentOfCapturingContextOrNull can check all non-captured variables and bindings.

[cor3ntin]

@shafik Thanks for the review. I was able to reorganize the things you pointed out to be more consistent such that the checks for structured bindings and regular vars are made in the same place.
I think it's much better that way. It took me a while to find the correct way to do that, which was somewhat useful in hindsight.

clang/lib/Sema/SemaInit.cpp

7792

I considered having a function In ValueDecl, what do you think?

[cor3ntin]

clang/test/CodeGenCXX/cxx20-decomposition.cpp

1 ↗

(On Diff #444283)

@erichkeane This is my first time writing a code gen test, and I'm not exactly sure what I'm doing. Mind taking a look?
Thanks!

[erichkeane]

Just about all of the '%' variables in LLVM are unstable names, so you need to use wildcards. Additionally, it seems like you're checking EVERY line of the llvm function, which is likely a mistake, it ends up being incredibly unstable as a result. I'd suggest just checking the individual lines (and the bare minimum on them!) that you need to prove that the 'right thing' is being emitted.

clang/test/CodeGenCXX/cxx20-decomposition.cpp

17 ↗

(On Diff #444283)

Are all of these lines necessary to prove what you want to prove? This seems like a lot of extra check lines.

19 ↗

(On Diff #444283)

Names of LLVM variables are NOT stable, and in fact, some configs of the compiler remove them. You typically want to use filecheck 'wildcards' for them.

[cor3ntin]

Simplify codegen test

[cor3ntin]

In D122768#3648545, @erichkeane wrote:

Just about all of the '%' variables in LLVM are unstable names, so you need to use wildcards. Additionally, it seems like you're checking EVERY line of the llvm function, which is likely a mistake, it ends up being incredibly unstable as a result. I'd suggest just checking the individual lines (and the bare minimum on them!) that you need to prove that the 'right thing' is being emitted.

Thanks. I tried to simplify as much as possible. I *think* i did not remove anything of importance

[erichkeane]

clang/test/CodeGenCXX/cxx20-decomposition.cpp

26 ↗

(On Diff #444330)

Which is the important lines here? You might want to use the [[NAME:.whatever]] (then on the 'other' side: [[NAME]])syntax in here to make sure that the check-lines don't find something else.

You also likely want to use .+ to make sure there is actually a character in there.

[cor3ntin]

clang/test/CodeGenCXX/cxx20-decomposition.cpp

26 ↗

(On Diff #444330)

I'm trying to show i is captured by value and j isn't

[cor3ntin]

clang/lib/CodeGen/CGExpr.cpp

2909

It can be ( and was) removed!

clang/lib/Sema/SemaExpr.cpp

17856–17858

You are right, we should check for Both kids of value. And we *did* but the check was split
in multiple locations, which was not great, changed that. Great point.

FYI, diagnoseUncapturableValueReferenceOrBinding is used both to diagnose bindings in modes they can't be captured and references to not captured variables.
I took the liberty to rename so the name is more explicit.

17927

It still somewhat not completely consistent as we only emit a warning in the C++ case, but the check for captured bindings is now done there

[cor3ntin]

@shafik I just realized i forgot to submit a bunch of replies i had to your comments, sorry about that

[shafik]

clang/lib/AST/StmtPrinter.cpp

2074

I wonder if it is worth commenting that only a VarDecl can be an init capture and therefore we can unconditionally cast to VarDecl?

clang/lib/Sema/SemaInit.cpp

7792

I thought about that but when I looked at ValueDecl it seemed pretty lightweight.

@aaron.ballman wdyt is ValueDecl the right place or is this code repetition ok?

[cor3ntin]

@aaron.ballman @shafik I'm perfectly happy to add isInitCapture in ValueDecl if that allows us to make progress on this. Let me know what you think!

[aaron.ballman]

clang/include/clang/AST/Stmt.h

61–63

We usually keep these alphabetical.

clang/lib/AST/ExprCXX.cpp

1210–1212

I think early returns help make this a bit more clear.

clang/lib/AST/StmtPrinter.cpp

2075

clang/lib/Analysis/AnalysisDeclContext.cpp

173

This looks dangerous -- isSelfDecl() uses the pointer variable in ways that would be Bad News for null pointers.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

9060

Ping @jdoerfert -- do you happen to know what's up here?

clang/lib/Sema/ScopeInfo.cpp

223–225

This also has a bad code smell for isa<> followed by cast<>, but I'm not certain if the rewrite is actually better or not.

clang/lib/Sema/SemaExpr.cpp

16044

Is cast<> safe here?

17872

18086

I'm assuming, given that the function didn't used to accept nullptr for Var and the else if is using dyn_cast<>.

18090

Can this return nullptr?

18093–18094

18098

Can this return nullptr?

18110

18295–18303

18296–18302

clang/lib/Sema/SemaInit.cpp

7792

I think it makes sense to sink this into ValueDecl given how often it's come up. We really try to discourage people from doing isa<> followed by a cast<> as that's a bad code smell for dyn_cast<>.

clang/lib/Sema/SemaLambda.cpp

1169–1172

1208–1209

Does getDecomposedDecl() ever actually return nullptr?

1716–1717

clang/lib/Sema/TreeTransform.h

12884

13068

I'll stop commenting on these -- you should take a pass over your changes and use const auto * or auto * anywhere the type is spelled on the RHS via cast<>, dyn_cast<>`, or similar.

clang/www/cxx_status.html

1147

[erichkeane]

clang/lib/AST/ExprCXX.cpp

1210–1212

I might suggest making that:

if (const auto *VD = dyn_cast<VarDecl(C->getCapturedVar())
   return VD->...
return false;

But otherwise agree with the suggestion.

clang/lib/Analysis/AnalysisDeclContext.cpp

173

Yep, isSelfDecl seems to do:

return isa<ImplicitParamDecl>(VD) && VD->getName() == "self";

isa isn't nullptr safe, we have isa_and_nonnull for that (if we want to update isSelfDecl).

clang/lib/Sema/SemaDecl.cpp

14337–14342

[cor3ntin]

Address most comments, except for lifting isInitCapture into ValueDecl,
which I will do separately.

[cor3ntin]

Put isInitCapture in ValueDecl.

This allows a few code simplification in the resst of the patch.

[cor3ntin]

Add comments

[cor3ntin]

Rebase.

[cor3ntin]

clang/lib/Analysis/AnalysisDeclContext.cpp

173

Using isa_and_nonnull looks like the best solution here

clang/lib/Sema/SemaDecl.cpp

14337–14342

I'm not sure I understood your suggestion.
The reason there is a local ValueDecl in addition of the VarDecl is because we use it Line 14660 just below.
But that was reworked when lifting isInitCapture in ValueDecl anyway.

clang/lib/Sema/SemaExpr.cpp

16044

Yes, I added a comment to make that clear

17872

Fancy. The parentheses are still needed though, because C macros are amazing like that :)

18090

I think so

/// Get the expression to which this declaration is bound. This may be null
/// in two different cases: while parsing the initializer for the
/// decomposition declaration, and when the initializer is type-dependent.
Expr *getBinding() const { return Binding; }

The initializer could be type dependant here, and so it could be null

18098

Yes, same thing as above

clang/lib/Sema/SemaLambda.cpp

1208–1209

I don't think that's necessary indeed, nice catch

[erichkeane]

CodeGen tests is still not testing what we intend I believe (sorry if I missed the response to this!), plus I would like a quick explanation as to what is going on in 1 place, otherwise I think this is about right. Hopefully Aaron/Shafik can take a quick look through to confirm as well.

clang/lib/AST/ExprCXX.cpp

1210–1212

FWIW, this seems nicer now without the casts. I'm OK with this form, it is exactly what there was before minus some strange formatting/parens.

clang/lib/Sema/SemaExpr.cpp

17930

first, why are we checking for !CPlusPlus... aren't BindingDecl's C++ only? Or is there some ObjC thing for them?

second, can you clarify what the two diagnostic cases are doing? it isn't completely clear to me the purpose of the first call here.

clang/test/CodeGenCXX/cxx20-decomposition.cpp

26 ↗

(On Diff #444330)

Hmm... I don't think it is testing what you think you're testing, particularly with so many unnamed checks. If you send me the IR that this produces and highlight which are the 'important' lines, I can help write this for you.

[cor3ntin]

clang/lib/Sema/SemaExpr.cpp

17930

The first diagnostic is where we diagnose usages outside of C++ lambdas.
And below are just the C++ extension warnings

clang/test/CodeGenCXX/cxx20-decomposition.cpp

26 ↗

(On Diff #444330)

To be perfectly honest, I'm neither confident about which lines are important, nor whether the test case is as meaningful as it can be.
I'm happy to mail you the IR if you have time to look at it :)

[erichkeane]

clang/test/CodeGenCXX/cxx20-decomposition.cpp

26 ↗

(On Diff #444330)

Yep, feel free, I'll take a look when I get a chance.

[cor3ntin]

Fix codegen test (Thanks Erich!)

[cor3ntin]

Fix formatting

[aaron.ballman]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

9060

Ping @mikerice or @ABataev in case @jdoerfert is on vacation.

(Note, I don't think an answer to this question is needed to accept this review.)

[ABataev]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

9060

Need to support capturing of structured bindings in OpenMP regions, some people asked for it long time ago.

[aaron.ballman]

I mostly only have minor nits, but otherwise this LGTM!

clang/docs/ReleaseNotes.rst

194–195

You should probably mention some of the issues that it fixes as well, since it handles a bunch of them.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

9060

Thank you for confirming @ABataev -- I had missed that https://github.com/llvm/llvm-project/issues/33025 was already filed. Nothing to do here for this review, what's happening is an improvement.

clang/lib/Sema/SemaExpr.cpp

17862

clang/lib/Sema/SemaLambda.cpp

1207–1211

[cor3ntin]

Missed a comment (s/ValueDecl/auto/ on the LHS of a cast)

[cor3ntin]

Add fixed issues to the release notes + address aaron comments.

[cor3ntin]

Thanks @aaron.ballman!
I'm gonna wait a bit before merging in case @erichkeane want to do another pass.

[erichkeane]

Last scroll-through looked fine to me, so don't worry about waiting for me.

[cor3ntin]

Fix self-build

• The way we tested for unions was broken
• It was also redundant, as we do that before in the same function (isVariableCapturable).

[aeubanks]

in the commit message

In addition, capturing an anonymous union member,
a bitfield, or a structured binding thereof now has a
better diagnostic.

"better diagnostic" implies there was already a diagnostic, but we're seeing new errors pop up. is this just a not precise commit message or are new errors related to capturing bitfields by reference unintentional?

[cor3ntin]

In D122768#3700451, @aeubanks wrote:

in the commit message

In addition, capturing an anonymous union member,
a bitfield, or a structured binding thereof now has a
better diagnostic.

"better diagnostic" implies there was already a diagnostic, but we're seeing new errors pop up. is this just a not precise commit message or are new errors related to capturing bitfields by reference unintentional?

New errors when capturing bit fields are probably*not* intentional. You have some of the problematic code i could look at? (not that the patch was reverted and then re-landed to fix a bug there)
And... the commit message is a bit inaccurate as the change that was supposedly improving diagnostics for reference to bit fields was remove (and i forgot to update the commit message accordingly)

[fhahn]

In D122768#3700486, @cor3ntin wrote:

In D122768#3700451, @aeubanks wrote:

in the commit message

In addition, capturing an anonymous union member,
a bitfield, or a structured binding thereof now has a
better diagnostic.

"better diagnostic" implies there was already a diagnostic, but we're seeing new errors pop up. is this just a not precise commit message or are new errors related to capturing bitfields by reference unintentional?

New errors when capturing bit fields are probably*not* intentional. You have some of the problematic code i could look at? (not that the patch was reverted and then re-landed to fix a bug there)
And... the commit message is a bit inaccurate as the change that was supposedly improving diagnostics for reference to bit fields was remove (and i forgot to update the commit message accordingly)

It looks like this may cause https://github.com/llvm/llvm-project/issues/56909. It would eb great if you could take a look

[aeubanks]

In D122768#3700486, @cor3ntin wrote:

In D122768#3700451, @aeubanks wrote:

in the commit message

In addition, capturing an anonymous union member,
a bitfield, or a structured binding thereof now has a
better diagnostic.

"better diagnostic" implies there was already a diagnostic, but we're seeing new errors pop up. is this just a not precise commit message or are new errors related to capturing bitfields by reference unintentional?

New errors when capturing bit fields are probably*not* intentional. You have some of the problematic code i could look at? (not that the patch was reverted and then re-landed to fix a bug there)
And... the commit message is a bit inaccurate as the change that was supposedly improving diagnostics for reference to bit fields was remove (and i forgot to update the commit message accordingly)

reduced, this does seem wrong

$ cat /tmp/a.cc
struct S {
        int s : 4;
};

void f() {
        S s;
        int l = s.s;
        auto a = [&]() {
                l;
        };
}
$ clang++ -fsyntax-only /tmp/a.cc
/tmp/a.cc:10:3: error: cannot capture a bit-field by reference
                l;
                ^
/tmp/a.cc:8:6: note: 'l' declared here
        int l = s.s;
            ^
/tmp/a.cc:3:6: note: bit-field is declared here
        int s : 4;
            ^
1 error generated.

[cor3ntin]

In D122768#3700738, @aeubanks wrote:

In D122768#3700486, @cor3ntin wrote:

In D122768#3700451, @aeubanks wrote:

in the commit message

In addition, capturing an anonymous union member,
a bitfield, or a structured binding thereof now has a
better diagnostic.

"better diagnostic" implies there was already a diagnostic, but we're seeing new errors pop up. is this just a not precise commit message or are new errors related to capturing bitfields by reference unintentional?

New errors when capturing bit fields are probably*not* intentional. You have some of the problematic code i could look at? (not that the patch was reverted and then re-landed to fix a bug there)
And... the commit message is a bit inaccurate as the change that was supposedly improving diagnostics for reference to bit fields was remove (and i forgot to update the commit message accordingly)

reduced, this does seem wrong

$ cat /tmp/a.cc
struct S {
        int s : 4;
};

void f() {
        S s;
        int l = s.s;
        auto a = [&]() {
                l;
        };
}
$ clang++ -fsyntax-only /tmp/a.cc
/tmp/a.cc:10:3: error: cannot capture a bit-field by reference
                l;
                ^
/tmp/a.cc:8:6: note: 'l' declared here
        int l = s.s;
            ^
/tmp/a.cc:3:6: note: bit-field is declared here
        int s : 4;
            ^
1 error generated.

Thanks a lot for that, I confirmed the issue.
I will land a fix shortly

[cor3ntin]

I landed https://github.com/llvm/llvm-project/commit/a1a71b7dc97b35133425a31ede90c40529f1be9e - which reverts entierely the bitfields related changes. It should fix the build issue you are encountering.
There are still pre-existing issues with the capture of bit fields and unions that needs more investigation.

clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp

 ///     };
 ///     f(elem);
 ///   }
 /// \endcode
 bool ForLoopIndexUseVisitor::TraverseLambdaCapture(LambdaExpr *LE,
                                                    const LambdaCapture *C,
                                                    Expr *Init) {
   if (C->capturesVariable()) {
-    const VarDecl *VDecl = C->getCapturedVar();
-    if (areSameVariable(IndexVar, cast<ValueDecl>(VDecl))) {
+    const ValueDecl *VDecl = C->getCapturedVar();
+    if (areSameVariable(IndexVar, VDecl)) {
       // FIXME: if the index is captured, it will count as an usage and the
       // alias (if any) won't work, because it is only used in case of having
       // exactly one usage.
       addUsage(Usage(nullptr,
                      C->getCaptureKind() == LCK_ByCopy ? Usage::UK_CaptureByCopy
                                                        : Usage::UK_CaptureByRef,
                      C->getLocation()));
     }

clang/docs/ReleaseNotes.rst

 -----------------------------
 
 - ...
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 - Diagnose consteval and constexpr issues that happen at namespace scope. This
   partially addresses `Issue 51593 <https://github.com/llvm/llvm-project/issues/51593>`_.
+- Support capturing structured bindings in lambdas (`P1091R3 <https://wg21.link/p1091r3>`_ and `P1381R1 <https://wg21.link/P1381R1>`)
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Implemented `P2128R6: Multidimensional subscript operator <https://wg21.link/P2128R6>`_.
 - Implemented `P0849R8: auto(x): decay-copy in the language <https://wg21.link/P0849R8>`_.
 - Implemented `P2242R3: Non-literal variables (and labels and gotos) in constexpr functions <https://wg21.link/P2242R3>`_.
 
 CUDA Language Changes in Clang
 ------------------------------
 

clang/include/clang/AST/DeclCXX.h

public:
   /// \param Captures Will be populated with the mapping from captured
   /// variables to the corresponding fields.
   ///
   /// \param ThisCapture Will be set to the field declaration for the
   /// \c this capture.
   ///
   /// \note No entries will be added for init-captures, as they do not capture
   /// variables.
-  void getCaptureFields(llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
+  void getCaptureFields(llvm::DenseMap<const ValueDecl *, FieldDecl *> &Captures,
                         FieldDecl *&ThisCapture) const;
 
   using capture_const_iterator = const LambdaCapture *;
   using capture_const_range = llvm::iterator_range<capture_const_iterator>;
 
   capture_const_range captures() const {
     return capture_const_range(captures_begin(), captures_end());
   }

clang/include/clang/AST/LambdaCapture.h

public:
   ///
   /// \param Var The local variable being captured, or null if capturing
   /// \c this.
   ///
   /// \param EllipsisLoc The location of the ellipsis (...) for a
   /// capture that is a pack expansion, or an invalid source
   /// location to indicate that this is not a pack expansion.
   LambdaCapture(SourceLocation Loc, bool Implicit, LambdaCaptureKind Kind,
-                VarDecl *Var = nullptr,
+                ValueDecl *Var = nullptr,
                 SourceLocation EllipsisLoc = SourceLocation());
 
   /// Determine the kind of capture.
   LambdaCaptureKind getCaptureKind() const;
 
   /// Determine whether this capture handles the C++ \c this
   /// pointer.
   bool capturesThis() const {
     return DeclAndBits.getPointer() == nullptr &&
           (DeclAndBits.getInt() & Capture_This);
   }
 
   /// Determine whether this capture handles a variable.
   bool capturesVariable() const {
-    return isa_and_nonnull<VarDecl>(DeclAndBits.getPointer());
+    return isa_and_nonnull<ValueDecl>(DeclAndBits.getPointer());
   }
 
   /// Determine whether this captures a variable length array bound
   /// expression.
   bool capturesVLAType() const {
     return DeclAndBits.getPointer() == nullptr &&
            !(DeclAndBits.getInt() & Capture_This);
   }
 
   /// Retrieve the declaration of the local variable being
   /// captured.
   ///
   /// This operation is only valid if this capture is a variable capture
   /// (other than a capture of \c this).
-  VarDecl *getCapturedVar() const {
+  ValueDecl *getCapturedVar() const {
     assert(capturesVariable() && "No variable available for capture");
-    return static_cast<VarDecl *>(DeclAndBits.getPointer());
+    return static_cast<ValueDecl *>(DeclAndBits.getPointer());
   }
 
   /// Determine whether this was an implicit capture (not
   /// written between the square brackets introducing the lambda).
   bool isImplicit() const {
     return DeclAndBits.getInt() & Capture_Implicit;
   }
 

clang/include/clang/AST/Stmt.h

 class LabelDecl;
 class ODRHash;
 class PrinterHelper;
 struct PrintingPolicy;
 class RecordDecl;
 class SourceManager;
 class StringLiteral;
 class Token;
 class VarDecl;
+class ValueDecl;
 
 //===----------------------------------------------------------------------===//
 // AST classes for statements.
 //===----------------------------------------------------------------------===//
 
 /// Stmt - This represents one statement.
 ///
 class alignas(void *) Stmt {
 public:
public:
 
   /// Set the record declaration for captured variables.
   void setCapturedRecordDecl(RecordDecl *D) {
     assert(D && "null RecordDecl");
     TheRecordDecl = D;
   }
 
   /// True if this variable has been captured.
-  bool capturesVariable(const VarDecl *Var) const;
+  bool capturesVariable(const ValueDecl *Var) const;
 
   /// An iterator that walks over the captures.
   using capture_iterator = Capture *;
   using const_capture_iterator = const Capture *;
   using capture_range = llvm::iterator_range<capture_iterator>;
   using capture_const_range = llvm::iterator_range<const_capture_iterator>;
 
   capture_range captures() {

clang/include/clang/ASTMatchers/ASTMatchers.h

 ///     int x;
 ///     auto f = [x](){};
 ///     auto g = [x = 1](){};
 ///   }
 /// \endcode
 /// In the matcher
 /// lambdaExpr(hasAnyCapture(lambdaCapture(capturesVar(hasName("x")))),
 /// capturesVar(hasName("x")) matches `x` and `x = 1`.
-AST_MATCHER_P(LambdaCapture, capturesVar, internal::Matcher<VarDecl>,
+AST_MATCHER_P(LambdaCapture, capturesVar, internal::Matcher<ValueDecl>,
               InnerMatcher) {
   auto *capturedVar = Node.getCapturedVar();
   return capturedVar && InnerMatcher.matches(*capturedVar, Finder, Builder);
 }
 
 /// Matches a `LambdaCapture` that refers to 'this'.
 ///
 /// Given

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 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;
 
 def err_static_data_member_not_allowed_in_local_class : Error<
   "static data member %0 not allowed in local %sub{select_tag_type_kind}2 %1">;
 
 // C++ derived classes
 def err_base_clause_on_union : Error<"unions cannot have base classes">;
 def err_base_must_be_class : Error<"base specifier must name a class">;
 def err_union_as_base_class : Error<"unions cannot be base classes">;

clang/include/clang/Sema/ScopeInfo.h

enum CaptureKind {
     Cap_ByCopy, Cap_ByRef, Cap_Block, Cap_VLA
   };
 
   union {
     /// If Kind == Cap_VLA, the captured type.
     const VariableArrayType *CapturedVLA;
 
     /// Otherwise, the captured variable (if any).
-    VarDecl *CapturedVar;
+    ValueDecl *CapturedVar;
   };
 
   /// The source location at which the first capture occurred.
   SourceLocation Loc;
 
   /// The location of the ellipsis that expands a parameter pack.
   SourceLocation EllipsisLoc;
 
class Capture {
   /// the lambda.
   unsigned NonODRUsed : 1;
 
   /// Whether the capture is invalid (a capture was required but the entity is
   /// non-capturable).
   unsigned Invalid : 1;
 
 public:
-  Capture(VarDecl *Var, bool Block, bool ByRef, bool IsNested,
+  Capture(ValueDecl *Var, bool Block, bool ByRef, bool IsNested,
           SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType,
           bool Invalid)
       : CapturedVar(Var), Loc(Loc), EllipsisLoc(EllipsisLoc),
         CaptureType(CaptureType),
         Kind(Block ? Cap_Block : ByRef ? Cap_ByRef : Cap_ByCopy),
         Nested(IsNested), CapturesThis(false), ODRUsed(false),
         NonODRUsed(false), Invalid(Invalid) {}
 
public:
   bool isNonODRUsed() const { return NonODRUsed; }
   void markUsed(bool IsODRUse) {
     if (IsODRUse)
       ODRUsed = true;
     else
       NonODRUsed = true;
   }
 
-  VarDecl *getVariable() const {
+  ValueDecl *getVariable() const {
     assert(isVariableCapture());
     return CapturedVar;
   }
 
   const VariableArrayType *getCapturedVLAType() const {
     assert(isVLATypeCapture());
     return CapturedVLA;
   }
public:
   };
 
   ImplicitCaptureStyle ImpCaptureStyle;
 
   CapturingScopeInfo(DiagnosticsEngine &Diag, ImplicitCaptureStyle Style)
       : FunctionScopeInfo(Diag), ImpCaptureStyle(Style) {}
 
   /// CaptureMap - A map of captured variables to (index+1) into Captures.
-  llvm::DenseMap<VarDecl*, unsigned> CaptureMap;
+  llvm::DenseMap<ValueDecl*, unsigned> CaptureMap;
 
   /// CXXThisCaptureIndex - The (index+1) of the capture of 'this';
   /// zero if 'this' is not captured.
   unsigned CXXThisCaptureIndex = 0;
 
   /// Captures - The captures.
   SmallVector<Capture, 4> Captures;
 
   /// - Whether the target type of return statements in this context
   /// is deduced (e.g. a lambda or block with omitted return type).
   bool HasImplicitReturnType = false;
 
   /// ReturnType - The target type of return statements in this context,
   /// or null if unknown.
   QualType ReturnType;
 
-  void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested,
+  void addCapture(ValueDecl *Var, bool isBlock, bool isByref, bool isNested,
                   SourceLocation Loc, SourceLocation EllipsisLoc,
                   QualType CaptureType, bool Invalid) {
     Captures.push_back(Capture(Var, isBlock, isByref, isNested, Loc,
                                EllipsisLoc, CaptureType, Invalid));
     CaptureMap[Var] = Captures.size();
   }
 
   void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType,
public:
 
   /// Retrieve the capture of C++ 'this', if it has been captured.
   Capture &getCXXThisCapture() {
     assert(isCXXThisCaptured() && "this has not been captured");
     return Captures[CXXThisCaptureIndex - 1];
   }
 
   /// Determine whether the given variable has been captured.
-  bool isCaptured(VarDecl *Var) const {
+  bool isCaptured(ValueDecl *Var) const {
     return CaptureMap.count(Var);
   }
 
   /// Determine whether the given variable-array type has been captured.
   bool isVLATypeCaptured(const VariableArrayType *VAT) const;
 
   /// Retrieve the capture of the given variable, if it has been
   /// captured already.
-  Capture &getCapture(VarDecl *Var) {
+  Capture &getCapture(ValueDecl *Var) {
     assert(isCaptured(Var) && "Variable has not been captured");
     return Captures[CaptureMap[Var] - 1];
   }
 
-  const Capture &getCapture(VarDecl *Var) const {
-    llvm::DenseMap<VarDecl*, unsigned>::const_iterator Known
+  const Capture &getCapture(ValueDecl *Var) const {
+    llvm::DenseMap<ValueDecl*, unsigned>::const_iterator Known
       = CaptureMap.find(Var);
     assert(Known != CaptureMap.end() && "Variable has not been captured");
     return Captures[Known->second - 1];
   }
 
   static bool classof(const FunctionScopeInfo *FSI) {
     return FSI->Kind == SK_Block || FSI->Kind == SK_Lambda
                                  || FSI->Kind == SK_CapturedRegion;

clang/include/clang/Sema/Sema.h

public:
   /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
   /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
   /// This is useful when enclosing lambdas must speculatively capture
   /// variables that may or may not be used in certain specializations of
   /// a nested generic lambda.
   ///
   /// \returns true if an error occurred (i.e., the variable cannot be
   /// captured) and false if the capture succeeded.
-  bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
+  bool tryCaptureVariable(ValueDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
                           SourceLocation EllipsisLoc, bool BuildAndDiagnose,
                           QualType &CaptureType,
                           QualType &DeclRefType,
                           const unsigned *const FunctionScopeIndexToStopAt);
 
   /// Try to capture the given variable.
-  bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
+  bool tryCaptureVariable(ValueDecl *Var, SourceLocation Loc,
                           TryCaptureKind Kind = TryCapture_Implicit,
                           SourceLocation EllipsisLoc = SourceLocation());
 
   /// Checks if the variable must be captured.
-  bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);
+  bool NeedToCaptureVariable(ValueDecl *Var, SourceLocation Loc);
 
   /// Given a variable, determine the type that a reference to that
   /// variable will have in the given scope.
-  QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);
+  QualType getCapturedDeclRefType(ValueDecl *Var, SourceLocation Loc);
 
   /// Mark all of the declarations referenced within a particular AST node as
   /// referenced. Used when template instantiation instantiates a non-dependent
   /// type -- entities referenced by the type are now referenced.
   void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);
   void MarkDeclarationsReferencedInExpr(Expr *E,
                                         bool SkipLocalVariables = false,
                                         ArrayRef<const Expr *> StopAt = None);

clang/lib/AST/ASTImporter.cpp

ASTNodeImporter::import(const Designator &D) {
   assert(D.isArrayRangeDesignator());
   return Designator(
       D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
       *ToRBracketLocOrErr);
 }
 
 template <>
 Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
-  VarDecl *Var = nullptr;
+  ValueDecl *Var = nullptr;
   if (From.capturesVariable()) {
     if (auto VarOrErr = import(From.getCapturedVar()))
       Var = *VarOrErr;
     else
       return VarOrErr.takeError();
   }
 
   auto LocationOrErr = import(From.getLocation());

clang/lib/AST/DeclCXX.cpp

for (NamedDecl *ND : Invoker) {
     if (FTy->getCallConv() == CC)
       return getInvokerAsMethod(ND);
   }
 
   return nullptr;
 }
 
 void CXXRecordDecl::getCaptureFields(
-       llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
+       llvm::DenseMap<const ValueDecl *, FieldDecl *> &Captures,
        FieldDecl *&ThisCapture) const {
   Captures.clear();
   ThisCapture = nullptr;
 
   LambdaDefinitionData &Lambda = getLambdaData();
   RecordDecl::field_iterator Field = field_begin();
   for (const LambdaCapture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures;
        C != CEnd; ++C, ++Field) {

clang/lib/AST/ExprCXX.cpp

CXXConstructExpr::CXXConstructExpr(
   setDependence(computeDependence(this));
 }
 
 CXXConstructExpr::CXXConstructExpr(StmtClass SC, EmptyShell Empty,
                                    unsigned NumArgs)
     : Expr(SC, Empty), NumArgs(NumArgs) {}
 
 LambdaCapture::LambdaCapture(SourceLocation Loc, bool Implicit,
-                             LambdaCaptureKind Kind, VarDecl *Var,
+                             LambdaCaptureKind Kind, ValueDecl *Var,
                              SourceLocation EllipsisLoc)
     : DeclAndBits(Var, 0), Loc(Loc), EllipsisLoc(EllipsisLoc) {
   unsigned Bits = 0;
   if (Implicit)
     Bits |= Capture_Implicit;
 
   switch (Kind) {
   case LCK_StarThis:

 const CompoundStmt *LambdaExpr::getCompoundStmtBody() const {
   Stmt *Body = getBody();
   if (const auto *CoroBody = dyn_cast<CoroutineBodyStmt>(Body))
     return cast<CompoundStmt>(CoroBody->getBody());
   return cast<CompoundStmt>(Body);
 }
 
 bool LambdaExpr::isInitCapture(const LambdaCapture *C) const {
-  return (C->capturesVariable() && C->getCapturedVar()->isInitCapture() &&
+  return (C->capturesVariable()
+          && isa<VarDecl>(C->getCapturedVar()) && cast<VarDecl>(C->getCapturedVar())->isInitCapture() &&
           (getCallOperator() == C->getCapturedVar()->getDeclContext()));
 }
 
 LambdaExpr::capture_iterator LambdaExpr::capture_begin() const {
   return getLambdaClass()->getLambdaData().Captures;
 }
 
 LambdaExpr::capture_iterator LambdaExpr::capture_end() const {
   return capture_begin() + capture_size();

clang/lib/AST/ExprConstant.cpp

public:
     // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
     // on the overall stack usage of deeply-recursing constexpr evaluations.
     // (We should cache this map rather than recomputing it repeatedly.)
     // But let's try this and see how it goes; we can look into caching the map
     // as a later change.
 
     /// LambdaCaptureFields - Mapping from captured variables/this to
     /// corresponding data members in the closure class.
-    llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
+    llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
     FieldDecl *LambdaThisCaptureField;
 
     CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
                    const FunctionDecl *Callee, const LValue *This,
                    CallRef Arguments);
     ~CallStackFrame();
 
     // Return the temporary for Key whose version number is Version.

clang/lib/AST/Stmt.cpp

CapturedRegionKind CapturedStmt::getCapturedRegionKind() const {
   return CapDeclAndKind.getInt();
 }
 
 /// Set the captured region kind.
 void CapturedStmt::setCapturedRegionKind(CapturedRegionKind Kind) {
   CapDeclAndKind.setInt(Kind);
 }
 
-bool CapturedStmt::capturesVariable(const VarDecl *Var) const {
+bool CapturedStmt::capturesVariable(const ValueDecl *Var) const {
   for (const auto &I : captures()) {
     if (!I.capturesVariable() && !I.capturesVariableByCopy())
       continue;
     if (I.getCapturedVar()->getCanonicalDecl() == Var->getCanonicalDecl())
       return true;
   }
 
   return false;
 }

clang/lib/AST/StmtPrinter.cpp

for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
 
     case LCK_VLAType:
       llvm_unreachable("VLA type in explicit captures.");
     }
 
     if (C->isPackExpansion())
       OS << "...";
 
     if (Node->isInitCapture(C)) {
-      VarDecl *D = C->getCapturedVar();
+      VarDecl *D = cast<VarDecl>(C->getCapturedVar());
 
       llvm::StringRef Pre;
       llvm::StringRef Post;
       if (D->getInitStyle() == VarDecl::CallInit &&
           !isa<ParenListExpr>(D->getInit())) {
         Pre = "(";
         Post = ")";
       } else if (D->getInitStyle() == VarDecl::CInit) {

clang/lib/Analysis/AnalysisDeclContext.cpp

const ImplicitParamDecl *AnalysisDeclContext::getSelfDecl() const {
   const CXXRecordDecl *parent = CXXMethod->getParent();
   if (!parent->isLambda())
     return nullptr;
 
   for (const auto &LC : parent->captures()) {
     if (!LC.capturesVariable())
       continue;
 
-    VarDecl *VD = LC.getCapturedVar();
-    if (isSelfDecl(VD))
+    ValueDecl *VD = LC.getCapturedVar();
+    if (isSelfDecl(dyn_cast<VarDecl>(VD)))
       return dyn_cast<ImplicitParamDecl>(VD);
   }
 
   return nullptr;
 }
 
 void AnalysisDeclContext::registerForcedBlockExpression(const Stmt *stmt) {
   if (!forcedBlkExprs)

clang/lib/CodeGen/CGDebugInfo.cpp

void CGDebugInfo::CollectRecordLambdaFields(
   unsigned fieldno = 0;
   for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(),
                                              E = CXXDecl->captures_end();
        I != E; ++I, ++Field, ++fieldno) {
     const LambdaCapture &C = *I;
     if (C.capturesVariable()) {
       SourceLocation Loc = C.getLocation();
       assert(!Field->isBitField() && "lambdas don't have bitfield members!");
-      VarDecl *V = C.getCapturedVar();
+      ValueDecl *V = C.getCapturedVar();
       StringRef VName = V->getName();
       llvm::DIFile *VUnit = getOrCreateFile(Loc);
       auto Align = getDeclAlignIfRequired(V, CGM.getContext());
       llvm::DIType *FieldType = createFieldType(
           VName, Field->getType(), Loc, Field->getAccess(),
           layout.getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
       elements.push_back(FieldType);
     } else if (C.capturesThis()) {

clang/lib/CodeGen/CGExpr.cpp

if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {
     }
 
     return LV;
   }
 
   // FIXME: While we're emitting a binding from an enclosing scope, all other
   // DeclRefExprs we see should be implicitly treated as if they also refer to
   // an enclosing scope.
-  if (const auto *BD = dyn_cast<BindingDecl>(ND))
+  if (const auto *BD = dyn_cast<BindingDecl>(ND)) {
+      if (E->refersToEnclosingVariableOrCapture()) {
+          auto *FD = LambdaCaptureFields.lookup(BD);
+          assert(FD);
+          return EmitCapturedFieldLValue(*this, FD, CXXABIThisValue);
+      }
       return EmitLValue(BD->getBinding());
+  }
 
   // We can form DeclRefExprs naming GUID declarations when reconstituting
   // non-type template parameters into expressions.
   if (const auto *GD = dyn_cast<MSGuidDecl>(ND))
     return MakeAddrLValue(CGM.GetAddrOfMSGuidDecl(GD), T,
                           AlignmentSource::Decl);
 
   if (const auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND))

clang/lib/CodeGen/CGOpenMPRuntime.cpp

 private:
   /// Private scope to capture global variables.
   CodeGenFunction::OMPPrivateScope PrivScope;
 };
 
 /// RAII for emitting code of OpenMP constructs.
 class InlinedOpenMPRegionRAII {
   CodeGenFunction &CGF;
-  llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
+  llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
   FieldDecl *LambdaThisCaptureField = nullptr;
   const CodeGen::CGBlockInfo *BlockInfo = nullptr;
   bool NoInheritance = false;
 
 public:
   /// Constructs region for combined constructs.
   /// \param CodeGen Code generation sequence for combined directives. Includes
   /// a list of functions used for code generation of implicitly inlined
void generateInfoForLambdaCaptures(
       llvm::DenseMap<llvm::Value *, llvm::Value *> &LambdaPointers) const {
     QualType VDType = VD->getType().getCanonicalType().getNonReferenceType();
     const auto *RD = VDType->getAsCXXRecordDecl();
     if (!RD || !RD->isLambda())
       return;
     Address VDAddr(Arg, CGF.ConvertTypeForMem(VDType),
                    CGF.getContext().getDeclAlign(VD));
     LValue VDLVal = CGF.MakeAddrLValue(VDAddr, VDType);
-    llvm::DenseMap<const VarDecl *, FieldDecl *> Captures;
+    llvm::DenseMap<const ValueDecl *, FieldDecl *> Captures;
     FieldDecl *ThisCapture = nullptr;
     RD->getCaptureFields(Captures, ThisCapture);
     if (ThisCapture) {
       LValue ThisLVal =
           CGF.EmitLValueForFieldInitialization(VDLVal, ThisCapture);
       LValue ThisLValVal = CGF.EmitLValueForField(VDLVal, ThisCapture);
       LambdaPointers.try_emplace(ThisLVal.getPointer(CGF),
                                  VDLVal.getPointer(CGF));
       CombinedInfo.Exprs.push_back(VD);
       CombinedInfo.BasePointers.push_back(ThisLVal.getPointer(CGF));
       CombinedInfo.Pointers.push_back(ThisLValVal.getPointer(CGF));
       CombinedInfo.Sizes.push_back(
           CGF.Builder.CreateIntCast(CGF.getTypeSize(CGF.getContext().VoidPtrTy),
                                     CGF.Int64Ty, /*isSigned=*/true));
       CombinedInfo.Types.push_back(OMP_MAP_PTR_AND_OBJ | OMP_MAP_LITERAL |
                                    OMP_MAP_MEMBER_OF | OMP_MAP_IMPLICIT);
       CombinedInfo.Mappers.push_back(nullptr);
     }
     for (const LambdaCapture &LC : RD->captures()) {
       if (!LC.capturesVariable())
         continue;
-      const VarDecl *VD = LC.getCapturedVar();
+      const VarDecl *VD = cast<VarDecl>(LC.getCapturedVar());
       if (LC.getCaptureKind() != LCK_ByRef && !VD->getType()->isPointerType())
         continue;
       auto It = Captures.find(VD);
       assert(It != Captures.end() && "Found lambda capture without field.");
       LValue VarLVal = CGF.EmitLValueForFieldInitialization(VDLVal, It->second);
       if (LC.getCaptureKind() == LCK_ByRef) {
         LValue VarLValVal = CGF.EmitLValueForField(VDLVal, It->second);
         LambdaPointers.try_emplace(VarLVal.getPointer(CGF),

clang/lib/CodeGen/CGOpenMPRuntimeGPU.cpp

if (!RD || !RD->isLambda())
       continue;
     Address VDAddr = CGF.GetAddrOfLocalVar(VD);
     LValue VDLVal;
     if (VD->getType().getCanonicalType()->isReferenceType())
       VDLVal = CGF.EmitLoadOfReferenceLValue(VDAddr, VD->getType());
     else
       VDLVal = CGF.MakeAddrLValue(
           VDAddr, VD->getType().getCanonicalType().getNonReferenceType());
-    llvm::DenseMap<const VarDecl *, FieldDecl *> Captures;
+    llvm::DenseMap<const ValueDecl *, FieldDecl *> Captures;
     FieldDecl *ThisCapture = nullptr;
     RD->getCaptureFields(Captures, ThisCapture);
     if (ThisCapture && CGF.CapturedStmtInfo->isCXXThisExprCaptured()) {
       LValue ThisLVal =
           CGF.EmitLValueForFieldInitialization(VDLVal, ThisCapture);
       llvm::Value *CXXThis = CGF.LoadCXXThis();
       CGF.EmitStoreOfScalar(CXXThis, ThisLVal);
     }
     for (const LambdaCapture &LC : RD->captures()) {
       if (LC.getCaptureKind() != LCK_ByRef)
         continue;
-      const VarDecl *VD = LC.getCapturedVar();
+      const VarDecl *VD = cast<VarDecl>(C.getCapturedVar());
       if (!CS->capturesVariable(VD))
         continue;
       auto It = Captures.find(VD);
       assert(It != Captures.end() && "Found lambda capture without field.");
       LValue VarLVal = CGF.EmitLValueForFieldInitialization(VDLVal, It->second);
       Address VDAddr = CGF.GetAddrOfLocalVar(VD);
       if (VD->getType().getCanonicalType()->isReferenceType())
         VDAddr = CGF.EmitLoadOfReferenceLValue(VDAddr,

clang/lib/CodeGen/CodeGenFunction.h

bool checkIfLoopMustProgress(bool HasConstantCond) {
 
     // Loops with non-constant conditions must make progress in C11 and later.
     return getLangOpts().C11;
   }
 
   const CodeGen::CGBlockInfo *BlockInfo = nullptr;
   llvm::Value *BlockPointer = nullptr;
 
-  llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
+  llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
   FieldDecl *LambdaThisCaptureField = nullptr;
 
   /// A mapping from NRVO variables to the flags used to indicate
   /// when the NRVO has been applied to this variable.
   llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags;
 
   EHScopeStack EHStack;
   llvm::SmallVector<char, 256> LifetimeExtendedCleanupStack;

clang/lib/Sema/ScopeInfo.cpp

if (ThisUse == Uses->second.rend())
     return;
 
   ThisUse->markSafe();
 }
 
 bool Capture::isInitCapture() const {
   // Note that a nested capture of an init-capture is not itself an
   // init-capture.
-  return !isNested() && isVariableCapture() && getVariable()->isInitCapture();
+  return !isNested() && isVariableCapture() && isa<VarDecl>(getVariable()) &&
+         cast<VarDecl>(getVariable())->isInitCapture();
 }
 
 bool CapturingScopeInfo::isVLATypeCaptured(const VariableArrayType *VAT) const {
   for (auto &Cap : Captures)
     if (Cap.isVLATypeCapture() && Cap.getCapturedVLAType() == VAT)
       return true;
   return false;
 }
 

clang/lib/Sema/SemaDecl.cpp

static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
   LSI->IntroducerRange = DNI.getCXXOperatorNameRange();
   LSI->Mutable = !CallOperator->isConst();
 
   // Add the captures to the LSI so they can be noted as already
   // captured within tryCaptureVar.
   auto I = LambdaClass->field_begin();
   for (const auto &C : LambdaClass->captures()) {
     if (C.capturesVariable()) {
-      VarDecl *VD = C.getCapturedVar();
-      if (VD->isInitCapture())
+      ValueDecl *VD = C.getCapturedVar();
+      if (VarDecl* Var = dyn_cast<VarDecl>(VD)) {
+          if(Var->isInitCapture())
               S.CurrentInstantiationScope->InstantiatedLocal(VD, VD);
+      }
       const bool ByRef = C.getCaptureKind() == LCK_ByRef;
       LSI->addCapture(VD, /*IsBlock*/false, ByRef,
           /*RefersToEnclosingVariableOrCapture*/true, C.getLocation(),
           /*EllipsisLoc*/C.isPackExpansion()
                          ? C.getEllipsisLoc() : SourceLocation(),
           I->getType(), /*Invalid*/false);
 
     } else if (C.capturesThis()) {
       LSI->addThisCapture(/*Nested*/ false, C.getLocation(), I->getType(),

clang/lib/Sema/SemaExpr.cpp

 /// declaration that does not require a closure capture.
 DeclRefExpr *
 Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                        const DeclarationNameInfo &NameInfo,
                        NestedNameSpecifierLoc NNS, NamedDecl *FoundD,
                        SourceLocation TemplateKWLoc,
                        const TemplateArgumentListInfo *TemplateArgs) {
   bool RefersToCapturedVariable =
-      isa<VarDecl>(D) &&
-      NeedToCaptureVariable(cast<VarDecl>(D), NameInfo.getLoc());
+      isa<VarDecl, BindingDecl>(D) &&
+      NeedToCaptureVariable(D, NameInfo.getLoc());
 
   DeclRefExpr *E = DeclRefExpr::Create(
       Context, NNS, TemplateKWLoc, D, RefersToCapturedVariable, NameInfo, Ty,
       VK, FoundD, TemplateArgs, getNonOdrUseReasonInCurrentContext(D));
   MarkDeclRefReferenced(E);
 
   // C++ [except.spec]p17:
   //   An exception-specification is considered to be needed when:
case Decl::ParmVar: {
 
     break;
   }
 
   case Decl::Binding: {
     // These are always lvalues.
     valueKind = VK_LValue;
     type = type.getNonReferenceType();
-    // FIXME: Support lambda-capture of BindingDecls, once CWG actually
-    // decides how that's supposed to work.
     auto *BD = cast<BindingDecl>(VD);
-    if (BD->getDeclContext() != CurContext) {
-      auto *DD = dyn_cast_or_null<VarDecl>(BD->getDecomposedDecl());
-      if (DD && DD->hasLocalStorage())
-        diagnoseUncapturableValueReference(*this, Loc, BD);
+    if (DD && DD->hasLocalStorage()) {
+        if ((!LangOpts.CPlusPlus  || !isLambdaCallOperator(CurContext)) && BD->getDeclContext() != CurContext) {
+            diagnoseUncapturableValueReference(*this, Loc, VD);
+        }
     }
     break;
   }
 
   case Decl::Function: {
     if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
       if (!Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
         type = Context.BuiltinFnTy;
ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
   PopDeclContext();
 
   // Set the captured variables on the block.
   SmallVector<BlockDecl::Capture, 4> Captures;
   for (Capture &Cap : BSI->Captures) {
     if (Cap.isInvalid() || Cap.isThisCapture())
       continue;
 
-    VarDecl *Var = Cap.getVariable();
+    VarDecl *Var = cast<VarDecl>(Cap.getVariable());
     Expr *CopyExpr = nullptr;
     if (getLangOpts().CPlusPlus && Cap.isCopyCapture()) {
       if (const RecordType *Record =
               Cap.getCaptureType()->getAs<RecordType>()) {
         // The capture logic needs the destructor, so make sure we mark it.
         // Usually this is unnecessary because most local variables have
         // their destructors marked at declaration time, but parameters are
         // an exception because it's technically only the call site that

 }
 
 void Sema::MarkCaptureUsedInEnclosingContext(VarDecl *Capture,
                                              SourceLocation Loc,
                                              unsigned CapturingScopeIndex) {
   MarkVarDeclODRUsed(Capture, Loc, *this, &CapturingScopeIndex);
 }
 
-static void diagnoseUncapturableValueReference(Sema &S, SourceLocation loc,
+void diagnoseUncapturableValueReference(Sema &S, SourceLocation loc,
                                                ValueDecl *var) {
   DeclContext *VarDC = var->getDeclContext();
 
   //  If the parameter still belongs to the translation unit, then
   //  we're actually just using one parameter in the declaration of
   //  the next.
   if (isa<ParmVarDecl>(var) &&
       isa<TranslationUnitDecl>(VarDC))
void diagnoseUncapturableValueReference(Sema &S, SourceLocation loc,
   S.Diag(var->getLocation(), diag::note_entity_declared_at)
       << var;
 
   // FIXME: Add additional diagnostic info about class etc. which prevents
   // capture.
 }
 
 
-static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI, VarDecl *Var,
+static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI, ValueDecl *Var,
                                       bool &SubCapturesAreNested,
                                       QualType &CaptureType,
                                       QualType &DeclRefType) {
    // Check whether we've already captured it.
   if (CSI->CaptureMap.count(Var)) {
     // If we found a capture, any subcaptures are nested.
     SubCapturesAreNested = true;
 
if (Cap.isCopyCapture() &&
       DeclRefType.addConst();
     return true;
   }
   return false;
 }
 
 // Only block literals, captured statements, and lambda expressions can
 // capture; other scopes don't work.
-static DeclContext *getParentOfCapturingContextOrNull(DeclContext *DC, VarDecl *Var,
+static DeclContext *getParentOfCapturingContextOrNull(DeclContext *DC, ValueDecl *Var,
                                  SourceLocation Loc,
                                  const bool Diagnose, Sema &S) {
   if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC) || isLambdaCallOperator(DC))
     return getLambdaAwareParentOfDeclContext(DC);
-  else if (Var->hasLocalStorage()) {
-    if (Diagnose)
-       diagnoseUncapturableValueReference(S, Loc, Var);
+  else if (VarDecl* VD = dyn_cast<VarDecl>(Var)){
+    if (VD->hasLocalStorage() && Diagnose)
+      diagnoseUncapturableValueReference(S, Loc, VD);
   }
   return nullptr;
 }
 
 // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
 // certain types of variables (unnamed, variably modified types etc.)
 // so check for eligibility.
-static bool isVariableCapturable(CapturingScopeInfo *CSI, VarDecl *Var,
+static bool isVariableCapturable(CapturingScopeInfo *CSI, ValueDecl *Var,
                                  SourceLocation Loc,
                                  const bool Diagnose, Sema &S) {
 
+  assert((isa<VarDecl>(Var) || isa<BindingDecl>(Var)) && "Only variables and structured bindings can be captured");
+
   bool IsBlock = isa<BlockScopeInfo>(CSI);
   bool IsLambda = isa<LambdaScopeInfo>(CSI);
 
   // Lambdas are not allowed to capture unnamed variables
   // (e.g. anonymous unions).
   // FIXME: The C++11 rule don't actually state this explicitly, but I'm
   // assuming that's the intent.
   if (IsLambda && !Var->getDeclName()) {
     if (Diagnose) {
static bool isVariableCapturable(CapturingScopeInfo *CSI, ValueDecl *Var,
   // OpenCL v2.0 s6.12.5: Blocks cannot reference/capture other blocks
   if (S.getLangOpts().OpenCL && IsBlock &&
       Var->getType()->isBlockPointerType()) {
     if (Diagnose)
       S.Diag(Loc, diag::err_opencl_block_ref_block);
     return false;
   }
 
+  if (isa<BindingDecl>(Var)) {
+      if(!IsLambda || !S.getLangOpts().CPlusPlus) {
+          //if(Diagnose) {
+          //    S.Diag(Loc, diag::err_reference_to_local_in_enclosing_context)
+          //            << Var << /*binding << /*block|context(IsBlock ? 1 : 3);
+          //    S.Diag(Var->getLocation(), diag::note_entity_declared_at)
+          //            << Var;
+          //}
+          return false;
+      }
+      else if(Diagnose && S.getLangOpts().CPlusPlus) {
+          S.Diag(Loc, S.LangOpts.CPlusPlus20?
+                                   diag::warn_cxx17_compat_capture_binding:
+                                   diag::ext_capture_binding)
+                  << Var;
+          S.Diag(Var->getLocation(), diag::note_entity_declared_at)
+                  << Var;
+      }
+  }
+
   return true;
 }
 
 // Returns true if the capture by block was successful.
-static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *Var,
+static bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var,
                                  SourceLocation Loc,
                                  const bool BuildAndDiagnose,
                                  QualType &CaptureType,
                                  QualType &DeclRefType,
                                  const bool Nested,
                                  Sema &S, bool Invalid) {
   bool ByRef = false;
 
BSI->addCapture(Var, HasBlocksAttr, ByRef, Nested, Loc, SourceLocation(),
                     CaptureType, Invalid);
 
   return !Invalid;
 }
 
 
 /// Capture the given variable in the captured region.
 static bool captureInCapturedRegion(
-    CapturedRegionScopeInfo *RSI, VarDecl *Var, SourceLocation Loc,
+    CapturedRegionScopeInfo *RSI, ValueDecl *Var, SourceLocation Loc,
     const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType,
     const bool RefersToCapturedVariable, Sema::TryCaptureKind Kind,
     bool IsTopScope, Sema &S, bool Invalid) {
   // By default, capture variables by reference.
   bool ByRef = true;
   if (IsTopScope && Kind != Sema::TryCapture_Implicit) {
     ByRef = (Kind == Sema::TryCapture_ExplicitByRef);
   } else if (S.getLangOpts().OpenMP && RSI->CapRegionKind == CR_OpenMP) {
if (BuildAndDiagnose)
     RSI->addCapture(Var, /*isBlock*/ false, ByRef, RefersToCapturedVariable,
                     Loc, SourceLocation(), CaptureType, Invalid);
 
   return !Invalid;
 }
 
 /// Capture the given variable in the lambda.
 static bool captureInLambda(LambdaScopeInfo *LSI,
-                            VarDecl *Var,
+                            ValueDecl *Var,
                             SourceLocation Loc,
                             const bool BuildAndDiagnose,
                             QualType &CaptureType,
                             QualType &DeclRefType,
                             const bool RefersToCapturedVariable,
                             const Sema::TryCaptureKind Kind,
                             SourceLocation EllipsisLoc,
                             const bool IsTopScope,
                             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);
   }
 
+  if (ByRef && BuildAndDiagnose && (!S.LangOpts.OpenMP || !S.isOpenMPCapturedDecl(Var))) {
+      // 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;
+      if(VarDecl* V = dyn_cast_or_null<VarDecl>(Var)) {
+          ME = dyn_cast_or_null<MemberExpr>(V->getInit()->IgnoreImplicit());
+      }
+      else if(BindingDecl* BD = dyn_cast<BindingDecl>(Var)) {
+          ME = llvm::dyn_cast_or_null<MemberExpr>(BD->getBinding());
+      }
+      if(ME) {
+          FieldDecl* FD = dyn_cast_or_null<FieldDecl>(ME->getMemberDecl());
+          if(FD && (FD->isBitField() || (FD->getParent()->isAnonymousStructOrUnion() && FD->getParent()->isUnion()))) {
+                  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;
+              }
+          }
+      }
+
     // Compute the type of the field that will capture this variable.
-  if (ByRef) {
+    if(ByRef) {
     // C++11 [expr.prim.lambda]p15:
     //   An entity is captured by reference if it is implicitly or
     //   explicitly captured but not captured by copy. It is
     //   unspecified whether additional unnamed non-static data
     //   members are declared in the closure type for entities
     //   captured by reference.
     //
     // FIXME: It is not clear whether we want to build an lvalue reference
     // to the DeclRefType or to CaptureType.getNonReferenceType(). GCC appears
     // to do the former, while EDG does the latter. Core issue 1249 will
static bool captureInLambda(LambdaScopeInfo *LSI,
   // Add the capture.
   if (BuildAndDiagnose)
     LSI->addCapture(Var, /*isBlock=*/false, ByRef, RefersToCapturedVariable,
                     Loc, EllipsisLoc, CaptureType, Invalid);
 
   return !Invalid;
 }
 
-static bool canCaptureVariableByCopy(VarDecl *Var, const ASTContext &Context) {
+static bool canCaptureVariableByCopy(ValueDecl *Var, const ASTContext &Context) {
   // Offer a Copy fix even if the type is dependent.
   if (Var->getType()->isDependentType())
     return true;
   QualType T = Var->getType().getNonReferenceType();
   if (T.isTriviallyCopyableType(Context))
     return true;
   if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
 
static bool canCaptureVariableByCopy(ValueDecl *Var, const ASTContext &Context) {
   return false;
 }
 
 /// Create up to 4 fix-its for explicit reference and value capture of \p Var or
 /// default capture. Fixes may be omitted if they aren't allowed by the
 /// standard, for example we can't emit a default copy capture fix-it if we
 /// already explicitly copy capture capture another variable.
 static void buildLambdaCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI,
-                                    VarDecl *Var) {
+                                    ValueDecl *Var) {
   assert(LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None);
   // Don't offer Capture by copy of default capture by copy fixes if Var is
   // known not to be copy constructible.
   bool ShouldOfferCopyFix = canCaptureVariableByCopy(Var, Sema.getASTContext());
 
   SmallString<32> FixBuffer;
   StringRef Separator = LSI->NumExplicitCaptures > 0 ? ", " : "";
   if (Var->getDeclName().isIdentifier() && !Var->getName().empty()) {
if (llvm::none_of(LSI->Captures, [](Capture &C) {
     FixBuffer.assign({"&", Separator});
     Sema.Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
         << /*reference*/ 1
         << FixItHint::CreateInsertion(DefaultInsertLoc, FixBuffer);
   }
 }
 
 bool Sema::tryCaptureVariable(
-    VarDecl *Var, SourceLocation ExprLoc, TryCaptureKind Kind,
+    ValueDecl *Var, SourceLocation ExprLoc, TryCaptureKind Kind,
     SourceLocation EllipsisLoc, bool BuildAndDiagnose, QualType &CaptureType,
     QualType &DeclRefType, const unsigned *const FunctionScopeIndexToStopAt) {
   // An init-capture is notionally from the context surrounding its
   // declaration, but its parent DC is the lambda class.
   DeclContext *VarDC = Var->getDeclContext();
-  if (Var->isInitCapture())
+  VarDecl* VD = dyn_cast<VarDecl>(Var);
+  if(VD) {
+      if (VD && VD->isInitCapture())
           VarDC = VarDC->getParent();
+  }
+  else {
+    VD = dyn_cast<DecompositionDecl>(cast<BindingDecl>(Var)->getDecomposedDecl());
+  }
+  assert(VD && "Cannot capture a null variable");
 
   DeclContext *DC = CurContext;
   const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
       ? *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
   // We need to sync up the Declaration Context with the
   // FunctionScopeIndexToStopAt
   if (FunctionScopeIndexToStopAt) {
     unsigned FSIndex = FunctionScopes.size() - 1;
     while (FSIndex != MaxFunctionScopesIndex) {
       DC = getLambdaAwareParentOfDeclContext(DC);
       --FSIndex;
     }
   }
 
 
   // If the variable is declared in the current context, there is no need to
   // capture it.
   if (VarDC == DC) return true;
 
   // Capture global variables if it is required to use private copy of this
   // variable.
-  bool IsGlobal = !Var->hasLocalStorage();
+  bool IsGlobal = !VD->hasLocalStorage();
   if (IsGlobal &&
       !(LangOpts.OpenMP && isOpenMPCapturedDecl(Var, /*CheckScopeInfo=*/true,
                                                 MaxFunctionScopesIndex)))
     return true;
-  Var = Var->getCanonicalDecl();
+
+  if (isa<VarDecl>(Var))
+      Var = cast<VarDecl>(Var->getCanonicalDecl());
 
   // Walk up the stack to determine whether we can capture the variable,
   // performing the "simple" checks that don't depend on type. We stop when
   // we've either hit the declared scope of the variable or find an existing
   // capture of that variable.  We start from the innermost capturing-entity
   // (the DC) and ensure that all intervening capturing-entities
   // (blocks/lambdas etc.) between the innermost capturer and the variable`s
   // declcontext can either capture the variable or have already captured
for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
     }
 
     if (Invalid && !BuildAndDiagnose)
       return true;
   }
   return Invalid;
 }
 
-bool Sema::tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
+bool Sema::tryCaptureVariable(ValueDecl *Var, SourceLocation Loc,
                               TryCaptureKind Kind, SourceLocation EllipsisLoc) {
   QualType CaptureType;
   QualType DeclRefType;
   return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc,
                             /*BuildAndDiagnose=*/true, CaptureType,
                             DeclRefType, nullptr);
 }
 
-bool Sema::NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc) {
+bool Sema::NeedToCaptureVariable(ValueDecl *Var, SourceLocation Loc) {
   QualType CaptureType;
   QualType DeclRefType;
   return !tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(),
                              /*BuildAndDiagnose=*/false, CaptureType,
                              DeclRefType, nullptr);
 }
 
-QualType Sema::getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc) {
+QualType Sema::getCapturedDeclRefType(ValueDecl *Var, SourceLocation Loc) {
   QualType CaptureType;
   QualType DeclRefType;
 
   // Determine whether we can capture this variable.
   if (tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(),
                          /*BuildAndDiagnose=*/false, CaptureType,
                          DeclRefType, nullptr))
     return QualType();
if (RefersToEnclosingScope) {
             !Var->isUsableInConstantExpressions(SemaRef.Context))
           LSI->addPotentialCapture(E->IgnoreParens());
       }
     }
     break;
   }
 }
 
+static void DoMarkBindingDeclReferenced(
+    Sema &SemaRef, SourceLocation Loc, BindingDecl *BD) {
+  BD->setReferenced();
+
+  if (BD->isInvalidDecl())
+    return;
+
+  OdrUseContext OdrUse = isOdrUseContext(SemaRef);
+  if(OdrUse == OdrUseContext::Used) {
+      QualType CaptureType, DeclRefType;
+      SemaRef.tryCaptureVariable(BD, Loc, Sema::TryCapture_Implicit,
+        /*EllipsisLoc*/ SourceLocation(),
+        /*BuildAndDiagnose*/ true,
+        CaptureType, DeclRefType,
+        /*FunctionScopeIndexToStopAt*/ nullptr);
+  }
+}
+
+
 /// Mark a variable referenced, and check whether it is odr-used
 /// (C++ [basic.def.odr]p2, C99 6.9p3).  Note that this should not be
 /// used directly for normal expressions referring to VarDecl.
 void Sema::MarkVariableReferenced(SourceLocation Loc, VarDecl *Var) {
   DoMarkVarDeclReferenced(*this, Loc, Var, nullptr, RefsMinusAssignments);
 }
 
 static void
 MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E,
                    bool MightBeOdrUse,
                    llvm::DenseMap<const VarDecl *, int> &RefsMinusAssignments) {
   if (SemaRef.isInOpenMPDeclareTargetContext())
     SemaRef.checkDeclIsAllowedInOpenMPTarget(E, D);
 
   if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
     DoMarkVarDeclReferenced(SemaRef, Loc, Var, E, RefsMinusAssignments);
     return;
   }
 
+  if(BindingDecl* Decl = dyn_cast<BindingDecl>(D)) {
+    DoMarkBindingDeclReferenced(SemaRef, Loc, Decl);
+    return;
+  }
+
+
   SemaRef.MarkAnyDeclReferenced(Loc, D, MightBeOdrUse);
 
   // If this is a call to a method via a cast, also mark the method in the
   // derived class used in case codegen can devirtualize the call.
   const MemberExpr *ME = dyn_cast<MemberExpr>(E);
   if (!ME)
     return;
   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl());

clang/lib/Sema/SemaInit.cpp

for (unsigned I = 0; I != Path.size(); ++I) {
         break;
       }
 
       case IndirectLocalPathEntry::LambdaCaptureInit:
         if (!Elem.Capture->capturesVariable())
           break;
         // FIXME: We can't easily tell apart an init-capture from a nested
         // capture of an init-capture.
-        const VarDecl *VD = Elem.Capture->getCapturedVar();
+        const ValueDecl *VD = Elem.Capture->getCapturedVar();
+        bool InitCapture = isa<VarDecl>(VD) && cast<VarDecl>(VD)->isInitCapture();
         Diag(Elem.Capture->getLocation(), diag::note_lambda_capture_initializer)
-            << VD << VD->isInitCapture() << Elem.Capture->isExplicit()
+            << VD << InitCapture << Elem.Capture->isExplicit()
             << (Elem.Capture->getCaptureKind() == LCK_ByRef) << VD
             << nextPathEntryRange(Path, I + 1, L);
         break;
       }
     }
 
     // We didn't lifetime-extend, so don't go any further; we don't need more
     // warnings or errors on inner temporaries within this one's initializer.

clang/lib/Sema/SemaLambda.cpp

if (C->Kind == LCK_This || C->Kind == LCK_StarThis) {
       continue;
     }
 
     assert(C->Id && "missing identifier for capture");
 
     if (C->Init.isInvalid())
       continue;
 
-    VarDecl *Var = nullptr;
+    ValueDecl *Var = nullptr;
     if (C->Init.isUsable()) {
       Diag(C->Loc, getLangOpts().CPlusPlus14
                        ? diag::warn_cxx11_compat_init_capture
                        : diag::ext_init_capture);
 
       // If the initializer expression is usable, but the InitCaptureType
       // is not, then an error has occurred - so ignore the capture for now.
       // for e.g., [n{0}] { }; <-- if no <initializer_list> is included.
if (C->Init.isUsable()) {
       if (R.empty()) {
         // FIXME: Disable corrections that would add qualification?
         CXXScopeSpec ScopeSpec;
         DeclFilterCCC<VarDecl> Validator{};
         if (DiagnoseEmptyLookup(CurScope, ScopeSpec, R, Validator))
           continue;
       }
 
+      if(auto BD = R.getAsSingle<BindingDecl>())
+          Var = BD;
+      else
           Var = R.getAsSingle<VarDecl>();
       if (Var && DiagnoseUseOfDecl(Var, C->Loc))
         continue;
     }
 
     // C++11 [expr.prim.lambda]p8:
     //   An identifier or this shall not appear more than once in a
     //   lambda-capture.
     if (!CaptureNames.insert(C->Id).second) {
if (!Var) {
       Diag(C->Loc, diag::err_capture_does_not_name_variable) << C->Id;
       continue;
     }
 
     // Ignore invalid decls; they'll just confuse the code later.
     if (Var->isInvalidDecl())
       continue;
 
-    if (!Var->hasLocalStorage()) {
+    VarDecl* Underlying;
+    if(isa<BindingDecl>(Var)) {
+        Underlying = dyn_cast_or_null<VarDecl>(cast<BindingDecl>(Var)->getDecomposedDecl());
+    }
+    else
+        Underlying = cast<VarDecl>(Var);
+
+    if (!Underlying->hasLocalStorage()) {
       Diag(C->Loc, diag::err_capture_non_automatic_variable) << C->Id;
       Diag(Var->getLocation(), diag::note_previous_decl) << C->Id;
       continue;
     }
 
     // C++11 [expr.prim.lambda]p23:
     //   A capture followed by an ellipsis is a pack expansion (14.5.3).
     SourceLocation EllipsisLoc;
     if (C->EllipsisLoc.isValid()) {
       if (Var->isParameterPack()) {
         EllipsisLoc = C->EllipsisLoc;
       } else {
         Diag(C->EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
             << (C->Init.isUsable() ? C->Init.get()->getSourceRange()
                                    : SourceRange(C->Loc));
 
         // Just ignore the ellipsis.
       }
     } else if (Var->isParameterPack()) {
       ContainsUnexpandedParameterPack = true;
     }
 
     if (C->Init.isUsable()) {
-      addInitCapture(LSI, Var);
+      addInitCapture(LSI, cast<VarDecl>(Var));
     } else {
       TryCaptureKind Kind = C->Kind == LCK_ByRef ? TryCapture_ExplicitByRef :
                                                    TryCapture_ExplicitByVal;
       tryCaptureVariable(Var, C->Loc, Kind, EllipsisLoc);
     }
     if (!LSI->Captures.empty())
       LSI->ExplicitCaptureRanges[LSI->Captures.size() - 1] = C->ExplicitRange;
   }
ExprResult Sema::BuildCaptureInit(const Capture &Cap,
                                   SourceLocation ImplicitCaptureLoc,
                                   bool IsOpenMPMapping) {
   // VLA captures don't have a stored initialization expression.
   if (Cap.isVLATypeCapture())
     return ExprResult();
 
   // An init-capture is initialized directly from its stored initializer.
   if (Cap.isInitCapture())
-    return Cap.getVariable()->getInit();
+    return cast<VarDecl>(Cap.getVariable())->getInit();
 
   // For anything else, build an initialization expression. For an implicit
   // capture, the capture notionally happens at the capture-default, so use
   // that location here.
   SourceLocation Loc =
       ImplicitCaptureLoc.isValid() ? ImplicitCaptureLoc : Cap.getLocation();
 
   // C++11 [expr.prim.lambda]p21:
if (Cap.isThisCapture()) {
     QualType ThisTy = getCurrentThisType();
     Expr *This = BuildCXXThisExpr(Loc, ThisTy, ImplicitCaptureLoc.isValid());
     if (Cap.isCopyCapture())
       Init = CreateBuiltinUnaryOp(Loc, UO_Deref, This);
     else
       Init = This;
   } else {
     assert(Cap.isVariableCapture() && "unknown kind of capture");
-    VarDecl *Var = Cap.getVariable();
+    ValueDecl *Var = Cap.getVariable();
     Name = Var->getIdentifier();
     Init = BuildDeclarationNameExpr(
       CXXScopeSpec(), DeclarationNameInfo(Var->getDeclName(), Loc), Var);
   }
 
   // In OpenMP, the capture kind doesn't actually describe how to capture:
   // variables are "mapped" onto the device in a process that does not formally
   // make a copy, even for a "copy capture".
mapImplicitCaptureStyle(CapturingScopeInfo::ImplicitCaptureStyle ICS) {
   case CapturingScopeInfo::ImpCap_Block:
     llvm_unreachable("block capture in lambda");
   }
   llvm_unreachable("Unknown implicit capture style");
 }
 
 bool Sema::CaptureHasSideEffects(const Capture &From) {
   if (From.isInitCapture()) {
-    Expr *Init = From.getVariable()->getInit();
+    Expr *Init = cast<VarDecl>(From.getVariable())->getInit();
     if (Init && Init->HasSideEffects(Context))
       return true;
   }
 
   if (!From.isCopyCapture())
     return false;
 
   const QualType T = From.isThisCapture()

 /// Create a field within the lambda class or captured statement record for the
 /// given capture.
 FieldDecl *Sema::BuildCaptureField(RecordDecl *RD,
                                    const sema::Capture &Capture) {
   SourceLocation Loc = Capture.getLocation();
   QualType FieldType = Capture.getCaptureType();
 
   TypeSourceInfo *TSI = nullptr;
-  if (Capture.isVariableCapture()) {
-    auto *Var = Capture.getVariable();
-    if (Var->isInitCapture())
-      TSI = Capture.getVariable()->getTypeSourceInfo();
+  if (Capture.isInitCapture()) {
+    TSI = cast<VarDecl>(Capture.getVariable())->getTypeSourceInfo();
   }
 
   // FIXME: Should we really be doing this? A null TypeSourceInfo seems more
   // appropriate, at least for an implicit capture.
   if (!TSI)
     TSI = Context.getTrivialTypeSourceInfo(FieldType, Loc);
 
   // Build the non-static data member.
for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I) {
                        getLocForEndOfToken(CaptureDefaultLoc), ", this");
           }
           return LambdaCapture(From.getLocation(), IsImplicit,
                                From.isCopyCapture() ? LCK_StarThis : LCK_This);
         } else if (From.isVLATypeCapture()) {
           return LambdaCapture(From.getLocation(), IsImplicit, LCK_VLAType);
         } else {
           assert(From.isVariableCapture() && "unknown kind of capture");
-          VarDecl *Var = From.getVariable();
+          ValueDecl *Var = From.getVariable();
           LambdaCaptureKind Kind =
               From.isCopyCapture() ? LCK_ByCopy : LCK_ByRef;
           return LambdaCapture(From.getLocation(), IsImplicit, Kind, Var,
                                From.getEllipsisLoc());
         }
       }();
 
       // Form the initializer for the capture field.

clang/lib/Sema/SemaOpenMP.cpp

if (!CurContext->isDependentContext() &&
     if (const auto *RD = Type.getCanonicalType()
                              .getNonReferenceType()
                              ->getAsCXXRecordDecl()) {
       bool SavedForceCaptureByReferenceInTargetExecutable =
           DSAStack->isForceCaptureByReferenceInTargetExecutable();
       DSAStack->setForceCaptureByReferenceInTargetExecutable(
           /*V=*/true);
       if (RD->isLambda()) {
-        llvm::DenseMap<const VarDecl *, FieldDecl *> Captures;
+        llvm::DenseMap<const ValueDecl *, FieldDecl *> Captures;
         FieldDecl *ThisCapture;
         RD->getCaptureFields(Captures, ThisCapture);
         for (const LambdaCapture &LC : RD->captures()) {
           if (LC.getCaptureKind() == LCK_ByRef) {
-            VarDecl *VD = LC.getCapturedVar();
+            VarDecl *VD = cast<VarDecl>(LC.getCapturedVar());
             DeclContext *VDC = VD->getDeclContext();
             if (!VDC->Encloses(CurContext))
               continue;
             MarkVariableReferenced(LC.getLocation(), VD);
           } else if (LC.getCaptureKind() == LCK_This) {
             QualType ThisTy = getCurrentThisType();
             if (!ThisTy.isNull() &&
                 Context.typesAreCompatible(ThisTy, ThisCapture->getType()))

clang/lib/Sema/SemaStmt.cpp

if (Cap.isThisCapture()) {
 
       if (S.getLangOpts().OpenMP && RSI->CapRegionKind == CR_OpenMP)
         S.setOpenMPCaptureKind(Field, Cap.getVariable(), RSI->OpenMPLevel);
 
       Captures.push_back(CapturedStmt::Capture(Cap.getLocation(),
                                                Cap.isReferenceCapture()
                                                    ? CapturedStmt::VCK_ByRef
                                                    : CapturedStmt::VCK_ByCopy,
-                                               Cap.getVariable()));
+                                               cast<VarDecl>(Cap.getVariable())));
     }
     CaptureInits.push_back(Init.get());
   }
   return false;
 }
 
 void Sema::ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
                                     CapturedRegionKind Kind,

clang/lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
   InitCaptures.resize(E->explicit_capture_end() - E->explicit_capture_begin());
   for (LambdaExpr::capture_iterator C = E->capture_begin(),
                                     CEnd = E->capture_end();
        C != CEnd; ++C) {
     if (!E->isInitCapture(C))
       continue;
 
     TransformedInitCapture &Result = InitCaptures[C - E->capture_begin()];
-    VarDecl *OldVD = C->getCapturedVar();
+    VarDecl *OldVD = cast<VarDecl>(C->getCapturedVar());
 
     auto SubstInitCapture = [&](SourceLocation EllipsisLoc,
                                 Optional<unsigned> NumExpansions) {
       ExprResult NewExprInitResult = getDerived().TransformInitializer(
           OldVD->getInit(), OldVD->getInitStyle() == VarDecl::CallInit);
 
       if (NewExprInitResult.isInvalid()) {
         Result.Expansions.push_back(InitCaptureInfoTy(ExprError(), QualType()));
         return;
       }
       Expr *NewExprInit = NewExprInitResult.get();
 
       QualType NewInitCaptureType =
           getSema().buildLambdaInitCaptureInitialization(
               C->getLocation(), OldVD->getType()->isReferenceType(),
               EllipsisLoc, NumExpansions, OldVD->getIdentifier(),
-              C->getCapturedVar()->getInitStyle() != VarDecl::CInit,
+              cast<VarDecl>(C->getCapturedVar())->getInitStyle() != VarDecl::CInit,
               NewExprInit);
       Result.Expansions.push_back(
           InitCaptureInfoTy(NewExprInit, NewInitCaptureType));
     };
 
     // If this is an init-capture pack, consider expanding the pack now.
     if (OldVD->isParameterPack()) {
       PackExpansionTypeLoc ExpansionTL = OldVD->getTypeSourceInfo()
for (LambdaExpr::capture_iterator C = E->capture_begin(),
     // rebuilding.
     if (C->capturesVLAType())
       continue;
 
     // Rebuild init-captures, including the implied field declaration.
     if (E->isInitCapture(C)) {
       TransformedInitCapture &NewC = InitCaptures[C - E->capture_begin()];
 
-      VarDecl *OldVD = C->getCapturedVar();
+      VarDecl *OldVD = cast<VarDecl>(C->getCapturedVar());
       llvm::SmallVector<Decl*, 4> NewVDs;
 
       for (InitCaptureInfoTy &Info : NewC.Expansions) {
         ExprResult Init = Info.first;
         QualType InitQualType = Info.second;
         if (Init.isInvalid() || InitQualType.isNull()) {
           Invalid = true;
           break;
if (C->isPackExpansion()) {
         Invalid = true;
         continue;
       }
 
       if (ShouldExpand) {
         // The transform has determined that we should perform an expansion;
         // transform and capture each of the arguments.
         // expansion of the pattern. Do so.
-        VarDecl *Pack = C->getCapturedVar();
+        VarDecl *Pack = cast<VarDecl>(C->getCapturedVar());
         for (unsigned I = 0; I != *NumExpansions; ++I) {
           Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), I);
           VarDecl *CapturedVar
             = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
                                                                Pack));
           if (!CapturedVar) {
             Invalid = true;
             continue;

clang/lib/Serialization/ASTWriter.cpp

for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
       Record->push_back(Capture.getCaptureKind());
       switch (Capture.getCaptureKind()) {
       case LCK_StarThis:
       case LCK_This:
       case LCK_VLAType:
         break;
       case LCK_ByCopy:
       case LCK_ByRef:
-        VarDecl *Var =
+        ValueDecl *Var =
             Capture.capturesVariable() ? Capture.getCapturedVar() : nullptr;
         AddDeclRef(Var);
         AddSourceLocation(Capture.isPackExpansion() ? Capture.getEllipsisLoc()
                                                     : SourceLocation());
         break;
       }
     }
   }

clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp

void operator()(const Stmt *S) {
     if (const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E))
       if (const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl()))
         Escaped.insert(VD);
   }
 
   // Treat local variables captured by reference in C++ lambdas as escaped.
   void findLambdaReferenceCaptures(const LambdaExpr *LE)  {
     const CXXRecordDecl *LambdaClass = LE->getLambdaClass();
-    llvm::DenseMap<const VarDecl *, FieldDecl *> CaptureFields;
+    llvm::DenseMap<const ValueDecl *, FieldDecl *> CaptureFields;
     FieldDecl *ThisCaptureField;
     LambdaClass->getCaptureFields(CaptureFields, ThisCaptureField);
 
     for (const LambdaCapture &C : LE->captures()) {
       if (!C.capturesVariable())
         continue;
 
-      VarDecl *VD = C.getCapturedVar();
+      ValueDecl *VD = C.getCapturedVar();
       const FieldDecl *FD = CaptureFields[VD];
-      if (!FD)
+      if (!FD || !isa<VarDecl>(VD))
         continue;
 
       // If the capture field is a reference type, it is capture-by-reference.
       if (FD->getType()->isReferenceType())
-        Escaped.insert(VD);
+        Escaped.insert(cast<VarDecl>(VD));
     }
   }
 };
 } // end anonymous namespace
 
 
 //===----------------------------------------------------------------------===//
 // DeadStoresChecker

clang/lib/StaticAnalyzer/Checkers/WebKit/UncountedLambdaCapturesChecker.cpp

void checkASTDecl(const TranslationUnitDecl *TUD, AnalysisManager &MGR,
 
     LocalVisitor visitor(this);
     visitor.TraverseDecl(const_cast<TranslationUnitDecl *>(TUD));
   }
 
   void visitLambdaExpr(LambdaExpr *L) const {
     for (const LambdaCapture &C : L->captures()) {
       if (C.capturesVariable()) {
-        VarDecl *CapturedVar = C.getCapturedVar();
+        ValueDecl *CapturedVar = C.getCapturedVar();
         if (auto *CapturedVarType = CapturedVar->getType().getTypePtrOrNull()) {
           Optional<bool> IsUncountedPtr = isUncountedPtr(CapturedVarType);
           if (IsUncountedPtr && *IsUncountedPtr) {
             reportBug(C, CapturedVar, CapturedVarType);
           }
         }
       }
     }
   }
 
-  void reportBug(const LambdaCapture &Capture, VarDecl *CapturedVar,
+  void reportBug(const LambdaCapture &Capture, ValueDecl *CapturedVar,
                  const Type *T) const {
     assert(CapturedVar);
 
     SmallString<100> Buf;
     llvm::raw_svector_ostream Os(Buf);
 
     if (Capture.isExplicit()) {
       Os << "Captured ";

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

if (const auto *VD = dyn_cast<VarDecl>(D)) {
     const auto *DeclRefEx = dyn_cast<DeclRefExpr>(Ex);
     Optional<std::pair<SVal, QualType>> VInfo;
 
     if (AMgr.options.ShouldInlineLambdas && DeclRefEx &&
         DeclRefEx->refersToEnclosingVariableOrCapture() && MD &&
         MD->getParent()->isLambda()) {
       // Lookup the field of the lambda.
       const CXXRecordDecl *CXXRec = MD->getParent();
-      llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
+      llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
       FieldDecl *LambdaThisCaptureField;
       CXXRec->getCaptureFields(LambdaCaptureFields, LambdaThisCaptureField);
 
       // Sema follows a sequence of complex rules to determine whether the
       // variable should be captured.
       if (const FieldDecl *FD = LambdaCaptureFields[VD]) {
         Loc CXXThis =
             svalBuilder.getCXXThis(MD, LocCtxt->getStackFrame());

clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp

static bool isCapturedByReference(ExplodedNode *N, const DeclRefExpr *DR) {
   const LocationContext *LocCtxt = N->getLocationContext();
   const Decl *D = LocCtxt->getDecl();
   const auto *MD = cast<CXXMethodDecl>(D);
   assert(MD && MD->getParent()->isLambda() &&
          "Captured variable should only be seen while evaluating a lambda");
   const CXXRecordDecl *LambdaCXXRec = MD->getParent();
 
   // Lookup the fields of the lambda
-  llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
+  llvm::DenseMap<const ValueDecl *, FieldDecl *> LambdaCaptureFields;
   FieldDecl *LambdaThisCaptureField;
   LambdaCXXRec->getCaptureFields(LambdaCaptureFields, LambdaThisCaptureField);
 
   // Check if the counter is captured by reference
   const VarDecl *VD = cast<VarDecl>(DR->getDecl()->getCanonicalDecl());
   assert(VD);
   const FieldDecl *FD = LambdaCaptureFields[VD];
   assert(FD && "Captured variable without a corresponding field");

clang/test/SemaCXX/cxx1z-decomposition.cpp

-// RUN: %clang_cc1 -std=c++17 -verify %s
+// RUN: %clang_cc1 -std=c++17 -Wc++20-extensions -verify=expected %s
+// RUN: %clang_cc1 -std=c++20 -Wpre-c++20-compat -verify=expected %s
 
 void use_from_own_init() {
   auto [a] = a; // expected-error {{binding 'a' cannot appear in the initializer of its own decomposition declaration}}
 }
 
 void num_elems() {
   struct A0 {} a0;
   int a1[1], a2[2];

 
 struct S { int a, b; };
 constexpr int f(S s) {
   auto &[a, b] = s;
   return a * 10 + b;
 }
 static_assert(f({1, 2}) == 12);
 
-constexpr bool g(S &&s) { 
+constexpr bool g(S &&s) {
   auto &[a, b] = s;
   return &a == &s.a && &b == &s.b && &a != &b;
 }
 static_assert(g({1, 2}));
 
-auto [outer1, outer2] = S{1, 2};
+struct S1 {
+  int a, b;
+};
+struct S2 {
+  int a : 1; // expected-note 2{{bit-field is declared here}}
+  int b;
+};
+
+
+auto [outer1, outer2] = S1{1, 2};
+auto [outerbit1, outerbit2] = S1{1, 2}; // expected-note {{declared here}}
+
 void enclosing() {
   struct S { int a = outer1; };
-  auto [n] = S(); // expected-note 2{{'n' declared here}}
+  auto [n] = S(); // expected-note 3{{'n' declared here}}
+
+  struct Q { int f() { return n; } }; // expected-error {{reference to local binding 'n' declared in enclosing function 'enclosing'}}
 
-  struct Q { int f() { return n; } }; // expected-error {{reference to local binding 'n' declared in enclosing function}}
-  (void) [&] { return n; }; // expected-error {{reference to local binding 'n' declared in enclosing function}}
-  (void) [n] {}; // expected-error {{'n' in capture list does not name a variable}}
+  (void) [&] { return n; };  // expected-warning {{C++20}}
+  (void) [n] {return n;};   //expected-warning {{C++20}}
+
+  static auto [m] = S(); // expected-note {{'m' declared here}} \
+                         // expected-warning {{C++20}}
 
-  static auto [m] = S(); // expected-warning {{extension}}
   struct R { int f() { return m; } };
   (void) [&] { return m; };
-  (void) [m] {}; // expected-error {{'m' in capture list does not name a variable}}
+  (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}}
+
+  (void) [&bit] {   // expected-error {{cannot capture a bit-field by reference}} \
+                    // 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-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}}
 }
 
 void for_range() {
   int x = 1;

 // PR32172
 template <class T> void dependent_foreach(T t) {
   for (auto [a,b,c] : t)
     a,b,c;
 }
 
 struct PR37352 {
   int n;
-  void f() { static auto [a] = *this; } // expected-warning {{C++20 extension}}
+  void f() { static auto [a] = *this; } // expected-warning {{C++20}}
 };
 
 namespace instantiate_template {
 
 template <typename T1, typename T2>
 struct pair {
   T1 a;
   T2 b;

clang/test/SemaCXX/decomposition-blocks.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify %s -fblocks
+
+struct S {
+    int i : 1;
+    int j;
+};
+
+void run(void (^)());
+void test() {
+auto [i, j] = S{1, 42}; // expected-note {{'i' declared here}}
+run(^{ (void) i; }); // expected-error {{reference to local binding 'i' declared in enclosing function 'test'}}
+}

clang/tools/libclang/CIndex.cpp

while (!WL.empty()) {
     case VisitorJob::LambdaExprPartsKind: {
       // Visit non-init captures.
       const LambdaExpr *E = cast<LambdaExprParts>(&LI)->get();
       for (LambdaExpr::capture_iterator C = E->explicit_capture_begin(),
                                         CEnd = E->explicit_capture_end();
            C != CEnd; ++C) {
         if (!C->capturesVariable())
           continue;
-
-        if (Visit(MakeCursorVariableRef(C->getCapturedVar(), C->getLocation(),
-                                        TU)))
+        // TODO: hamdle structured bindings here ?
+        if (!isa<VarDecl>(C->getCapturedVar()))
+            continue;
+        if(Visit(MakeCursorVariableRef(cast<VarDecl>(C->getCapturedVar()), C->getLocation(), TU)))
           return true;
       }
       // Visit init captures
       for (auto InitExpr : E->capture_inits()) {
         if (InitExpr && Visit(InitExpr))
           return true;
       }
 

clang/www/cxx_status.html

<tr>
       <td>Nested inline namespaces</td>
       <td><a href="https://wg21.link/p1094r2">P1094R2</a></td>
       <td class="full" align="center">Clang 8</td>
     </tr>
     <!-- Kona 2019 papers -->
     <tr>
       <td rowspan="2">Structured binding extensions</td>
       <td><a href="https://wg21.link/p1091r3">P1091R3</a></td>
-      <td rowspan="2" class="partial" align="center">Partial</td>
+      <td rowspan="2" class="unreleased" align="center">Clang 15</td>
     </tr>
       <tr>
         <td><a href="https://wg21.link/p1381r1">P1381R1</a></td>
       </tr>
     <tr>
       <td rowspan="2">Stronger Unicode requirements</td>
       <td><a href="https://wg21.link/p1041r4">P1041R4</a></td>
       <td rowspan="2" class="full" align="center">Yes</td>