[Clang] Correctly capture bindings in dependent lambdas.

[cor3ntin]

Summary

Structured bindings were not properly marked odr-used
and therefore captured in generic lambddas.

Fixes #57826

It is unclear to me if further simplification can be gained
through the allowance described in
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0588r1.html.

Either way, I think this makes support for P0588 completes,
but we probably want to add test for that in a separate PR.
(and I lack confidence I understand P0588 sufficiently to assert
the completeness of our cnformance).

[cor3ntin]

Forgot to clang-format!

[cor3ntin]

(No changelog, this fixes an unreleased feature)

[cor3ntin]

Use the getPotentiallyDecomposedVarDecl everywhere it makes sense.

[aaron.ballman]

Thanks for this! Can you also add a release note for the changes?

clang/include/clang/AST/Decl.h

673

This should be moved up to around line 77 or so (and kept in alphabetical order).

clang/lib/AST/DeclCXX.cpp

3234–3237

No need to use the fully-qualified name (we weren't using it for the calls to isa either).

clang/lib/Sema/SemaDeclCXX.cpp

91 ↗

(On Diff #472920)

1. We should rename Decl to something that doesn't shadow the name of a type, since we're here.
2. Can Decl be null? You're assuming it can't be below with the isa call, so this could switch to cast.

clang/lib/Sema/SemaExpr.cpp

18391–18394

19486–19488

19490

19494–19497

Can re-flow this comment.

[cor3ntin]

In D137244#3915633, @aaron.ballman wrote:

Thanks for this! Can you also add a release note for the changes?

Thanks for the Review!
As mentioned this fixes an unreleased feature, hence why I don't think a release note entry is necessary.

[cor3ntin]

clang/lib/AST/DeclCXX.cpp

3234–3237

My IDE completion being weird, sorry about that :)

[cor3ntin]

Address Aaron's comment.

[shafik]

clang/lib/Sema/SemaExpr.cpp

18256–18257

[cor3ntin]

Address Shafik's comment

[shafik]

This looks reasonable to me but not confident enough to approve it.

[cor3ntin]

@aaron.ballman gentle ping. I hope your feedback was addressed to your satisfaction :)

[aaron.ballman]

Mostly just nits from me at this point.

clang/lib/AST/DeclCXX.cpp

3232

clang/lib/Sema/SemaDeclCXX.cpp

125 ↗

(On Diff #474770)

ValueDecl is a subclass of NamedDecl and the diagnostic printer knows how to properly print those -- I assume this is an NFC change (or near enough to it).

clang/lib/Sema/SemaExpr.cpp

19655–19657

Should this comment be moved elsewhere, as it now seems detached from the original logic.

clang/lib/Sema/TreeTransform.h

13317–13318

clang/test/SemaCXX/cxx20-decomposition.cpp

96

Spurious whitespace?

160

Same edit elsewhere. Did clang-format get confused?

[cor3ntin]

clang/lib/AST/DeclCXX.cpp

3232

That's future tech, assert would part that as 2 macros arguments!

[aaron.ballman]

clang/lib/AST/DeclCXX.cpp

3232

Ugh.

(isa<VarDecl, BindingDecl>(this)) && ...

should suppress that problem, right? I don't feel strongly though.

[cor3ntin]

Address Aaron's comments

[cor3ntin]

clang/lib/AST/DeclCXX.cpp

3232

Oh right, that works too :)

clang/lib/Sema/SemaExpr.cpp

19655–19657

I think it's still relevant. the logic is still doing lambda captures, and we still don't need to do anything else, and the fixme is not resolved.

[cor3ntin]

Rewrite assert in DeclCXX.cpp

[rymiel]

clang/test/SemaCXX/cxx20-decomposition.cpp

160

It can't be clang-format because it would figuratively explode due to https://github.com/llvm/llvm-project/issues/40694! (but it did remind me to investigate that issue)

[aaron.ballman]

clang/lib/Sema/SemaDeclCXX.cpp

125 ↗

(On Diff #474770)

Did this one not work the way I expected?

clang/lib/Sema/SemaExpr.cpp

19655–19657

Okay, fine by me, I thought it might make more sense in DoMarkPotentialCapture, but I see now that the comment relates more to where it is currently.

[cor3ntin]

clang/lib/Sema/SemaDeclCXX.cpp

125 ↗

(On Diff #474770)

I'm still running the tests, It does seem fine :)

[cor3ntin]

Symplify printing a NamedDecl in moved code per Aaron's comment

[aaron.ballman]

LGTM assuming precommit CI doesn't discover any problems from the latest changes.

clang/include/clang/AST/Decl.h

public:
   static DeclContext *castToDeclContext(const NamespaceDecl *D) {
     return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
   }
   static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
     return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
   }
 };
 
+class VarDecl;
+
 /// Represent the declaration of a variable (in which case it is
 /// an lvalue) a function (in which case it is a function designator) or
 /// an enum constant.
 class ValueDecl : public NamedDecl {
   QualType DeclType;
 
   void anchor() override;
 
public:
   ///        or declared with the weak or weak-ref attr.
   bool isWeak() const;
 
   /// Whether this variable is the implicit variable for a lambda init-capture.
   /// Only VarDecl can be init captures, but both VarDecl and BindingDecl
   /// can be captured.
   bool isInitCapture() const;
 
+  // If this is a VarDecl, or a BindindDecl with an
+  // associated decomposed VarDecl, return that VarDecl.
+  VarDecl* getPotentiallyDecomposedVarDecl();
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
 };
 
 /// A struct with extended info about a syntactic
 /// name qualifier, to be used for the case of out-of-line declarations.
 struct QualifierInfo {

clang/include/clang/Sema/ScopeInfo.h

public:
   }
 
   bool hasPotentialCaptures() const {
     return getNumPotentialVariableCaptures() ||
                                   PotentialThisCaptureLocation.isValid();
   }
 
   void visitPotentialCaptures(
-      llvm::function_ref<void(VarDecl *, Expr *)> Callback) const;
+      llvm::function_ref<void(ValueDecl *, Expr *)> Callback) const;
 };
 
 FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy()
     : Base(nullptr, false) {}
 
 FunctionScopeInfo::WeakObjectProfileTy
 FunctionScopeInfo::WeakObjectProfileTy::getSentinel() {
   FunctionScopeInfo::WeakObjectProfileTy Result;

clang/include/clang/Sema/Sema.h

public:
   // explicit nested-name-specifier).
   void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);
   void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
                               bool MightBeOdrUse = true);
   void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
   void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);
   void MarkMemberReferenced(MemberExpr *E);
   void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E);
-  void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc,
+  void MarkCaptureUsedInEnclosingContext(ValueDecl *Capture, SourceLocation Loc,
                                          unsigned CapturingScopeIndex);
 
   ExprResult CheckLValueToRValueConversionOperand(Expr *E);
   void CleanupVarDeclMarking();
 
   enum TryCaptureKind {
     TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
   };

clang/include/clang/Sema/SemaLambda.h

 /// enclosing lambda (to the current lambda) that is 'capture-capable' for
 /// the variable referenced in the current lambda (i.e. \p VarToCapture).
 /// If successful, returns the index into Sema's FunctionScopeInfo stack
 /// of the capture-capable lambda's LambdaScopeInfo.
 /// See Implementation for more detailed comments.
 
 Optional<unsigned> getStackIndexOfNearestEnclosingCaptureCapableLambda(
     ArrayRef<const sema::FunctionScopeInfo *> FunctionScopes,
-    VarDecl *VarToCapture, Sema &S);
+    ValueDecl *VarToCapture, Sema &S);
 
 } // clang
 
 #endif

clang/lib/AST/DeclCXX.cpp

 }
 
 StaticAssertDecl *StaticAssertDecl::CreateDeserialized(ASTContext &C,
                                                        unsigned ID) {
   return new (C, ID) StaticAssertDecl(nullptr, SourceLocation(), nullptr,
                                       nullptr, SourceLocation(), false);
 }
 
+
+VarDecl* ValueDecl::getPotentiallyDecomposedVarDecl() {
+  assert((isa<VarDecl>(this) || isa<BindingDecl>(this)) && "expected a VarDecl or a BindingDecl");
+  if (auto *Var = llvm::dyn_cast<VarDecl>(this))
+    return Var;
+  if (auto *BD = llvm::dyn_cast<BindingDecl>(this))
+    return llvm::dyn_cast<VarDecl>(BD->getDecomposedDecl());
+  return nullptr;
+}
+
+
 void BindingDecl::anchor() {}
 
 BindingDecl *BindingDecl::Create(ASTContext &C, DeclContext *DC,
                                  SourceLocation IdLoc, IdentifierInfo *Id) {
   return new (C, DC) BindingDecl(DC, IdLoc, Id);
 }
 
 BindingDecl *BindingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {

clang/lib/Sema/ScopeInfo.cpp

 bool CapturingScopeInfo::isVLATypeCaptured(const VariableArrayType *VAT) const {
   for (auto &Cap : Captures)
     if (Cap.isVLATypeCapture() && Cap.getCapturedVLAType() == VAT)
       return true;
   return false;
 }
 
 void LambdaScopeInfo::visitPotentialCaptures(
-    llvm::function_ref<void(VarDecl *, Expr *)> Callback) const {
+    llvm::function_ref<void(ValueDecl *, Expr *)> Callback) const {
   for (Expr *E : PotentiallyCapturingExprs) {
     if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
-      Callback(cast<VarDecl>(DRE->getFoundDecl()), E);
+      Callback(cast<ValueDecl>(DRE->getFoundDecl()), E);
     } else if (auto *ME = dyn_cast<MemberExpr>(E)) {
-      Callback(cast<VarDecl>(ME->getMemberDecl()), E);
+      Callback(cast<ValueDecl>(ME->getMemberDecl()), E);
     } else if (auto *FP = dyn_cast<FunctionParmPackExpr>(E)) {
-      for (VarDecl *VD : *FP)
+      for (ValueDecl *VD : *FP)
         Callback(VD, E);
     } else {
       llvm_unreachable("unexpected expression in potential captures list");
     }
   }
 }
 
 FunctionScopeInfo::~FunctionScopeInfo() { }
 BlockScopeInfo::~BlockScopeInfo() { }
 CapturedRegionScopeInfo::~CapturedRegionScopeInfo() { }

clang/lib/Sema/SemaExpr.cpp

 /// Directly mark a variable odr-used. Given a choice, prefer to use
 /// MarkVariableReferenced since it does additional checks and then
 /// calls MarkVarDeclODRUsed.
 /// If the variable must be captured:
 ///  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
 ///  - else capture it in the DeclContext that maps to the
 ///    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.
 static void
-MarkVarDeclODRUsed(VarDecl *Var, SourceLocation Loc, Sema &SemaRef,
+MarkVarDeclODRUsed(ValueDecl *V, SourceLocation Loc, Sema &SemaRef,
                    const unsigned *const FunctionScopeIndexToStopAt = nullptr) {
   // Keep track of used but undefined variables.
   // FIXME: We shouldn't suppress this warning for static data members.
+  VarDecl* Var = V->getPotentiallyDecomposedVarDecl();
+  assert(Var && "expected a capturable variable");
+
   if (Var->hasDefinition(SemaRef.Context) == VarDecl::DeclarationOnly &&
       (!Var->isExternallyVisible() || Var->isInline() ||
        SemaRef.isExternalWithNoLinkageType(Var)) &&
       !(Var->isStaticDataMember() && Var->hasInit())) {
     SourceLocation &old = SemaRef.UndefinedButUsed[Var->getCanonicalDecl()];
     if (old.isInvalid())
       old = Loc;
   }
   QualType CaptureType, DeclRefType;
   if (SemaRef.LangOpts.OpenMP)
-    SemaRef.tryCaptureOpenMPLambdas(Var);
-  SemaRef.tryCaptureVariable(Var, Loc, Sema::TryCapture_Implicit,
+    SemaRef.tryCaptureOpenMPLambdas(V);
+  SemaRef.tryCaptureVariable(V, Loc, Sema::TryCapture_Implicit,
     /*EllipsisLoc*/ SourceLocation(),
     /*BuildAndDiagnose*/ true,
     CaptureType, DeclRefType,
     FunctionScopeIndexToStopAt);
 
   if (SemaRef.LangOpts.CUDA && Var->hasGlobalStorage()) {
     auto *FD = dyn_cast_or_null<FunctionDecl>(SemaRef.CurContext);
     auto VarTarget = SemaRef.IdentifyCUDATarget(Var);
     auto UserTarget = SemaRef.IdentifyCUDATarget(FD);
     if (VarTarget == Sema::CVT_Host &&
         (UserTarget == Sema::CFT_Device || UserTarget == Sema::CFT_HostDevice ||
          UserTarget == Sema::CFT_Global)) {
       // Diagnose ODR-use of host global variables in device functions.
       // Reference of device global variables in host functions is allowed
       // through shadow variables therefore it is not diagnosed.
if (VarTarget == Sema::CVT_Host &&
       // externalize the static device side variable ODR-used by host code.
       if (!Var->hasExternalStorage())
         SemaRef.getASTContext().CUDADeviceVarODRUsedByHost.insert(Var);
       else if (SemaRef.LangOpts.GPURelocatableDeviceCode)
         SemaRef.getASTContext().CUDAExternalDeviceDeclODRUsedByHost.insert(Var);
     }
   }
 
-  Var->markUsed(SemaRef.Context);
+  V->markUsed(SemaRef.Context);
 }
 
-void Sema::MarkCaptureUsedInEnclosingContext(VarDecl *Capture,
+void Sema::MarkCaptureUsedInEnclosingContext(ValueDecl *Capture,
                                              SourceLocation Loc,
                                              unsigned CapturingScopeIndex) {
   MarkVarDeclODRUsed(Capture, Loc, *this, &CapturingScopeIndex);
 }
 
 void diagnoseUncapturableValueReferenceOrBinding(Sema &S, SourceLocation loc,
                                                  ValueDecl *var) {
   DeclContext *VarDC = var->getDeclContext();
static DeclContext *getParentOfCapturingContextOrNull(DeclContext *DC,
 
   ValueDecl *Underlying = Var;
   auto *BD = dyn_cast_or_null<BindingDecl>(Var);
   if (BD)
     Underlying = BD->getDecomposedDecl();
 
   if (auto *VD = dyn_cast<VarDecl>(Underlying)) {
     if (VD->hasLocalStorage() && Diagnose)
       diagnoseUncapturableValueReferenceOrBinding(S, Loc, Var);
   }
   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, ValueDecl *Var,
                                  SourceLocation Loc, const bool Diagnose,
                                  Sema &S) {
 
bool Sema::tryCaptureVariable(
   // An init-capture is notionally from the context surrounding its
   // declaration, but its parent DC is the lambda class.
   DeclContext *VarDC = Var->getDeclContext();
   const auto *VD = dyn_cast<VarDecl>(Var);
   if (VD) {
     if (VD->isInitCapture())
       VarDC = VarDC->getParent();
   } else {
-    VD = dyn_cast<DecompositionDecl>(
-        cast<BindingDecl>(Var)->getDecomposedDecl());
+    VD = Var->getPotentiallyDecomposedVarDecl();
   }
   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 (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
       llvm_unreachable("Unexpected expression");
     }
   }
 
   assert(MaybeODRUseExprs.empty() &&
          "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?");
 }
 
+static void DoMarkPotentialCapture(Sema &SemaRef, SourceLocation Loc, ValueDecl *Var, Expr *E) {
+  VarDecl* VD = Var->getPotentiallyDecomposedVarDecl();
+  if(!VD)
+    return;
+
+  const bool RefersToEnclosingScope =
+      (SemaRef.CurContext != VD->getDeclContext() &&
+       VD->getDeclContext()->isFunctionOrMethod() && VD->hasLocalStorage());
+  if (RefersToEnclosingScope) {
+    LambdaScopeInfo *const LSI =
+        SemaRef.getCurLambda(/*IgnoreNonLambdaCapturingScope=*/true);
+    if (LSI && (!LSI->CallOperator ||
+                !LSI->CallOperator->Encloses(Var->getDeclContext()))) {
+      // If a variable could potentially be odr-used, defer marking it so
+      // until we finish analyzing the full expression for any
+      // lvalue-to-rvalue
+      // or discarded value conversions that would obviate odr-use.
+      // Add it to the list of potential captures that will be analyzed
+      // later (ActOnFinishFullExpr) for eventual capture and odr-use marking
+      // unless the variable is a reference that was initialized by a constant
+      // expression (this will never need to be captured or odr-used).
+      //
+      // FIXME: We can simplify this a lot after implementing P0588R1.
+      assert(E && "Capture variable should be used in an expression.");
+      if (!Var->getType()->isReferenceType() ||
+          !VD->isUsableInConstantExpressions(SemaRef.Context))
+        LSI->addPotentialCapture(E->IgnoreParens());
+    }
+  }
+}
+
 static void DoMarkVarDeclReferenced(
     Sema &SemaRef, SourceLocation Loc, VarDecl *Var, Expr *E,
     llvm::DenseMap<const VarDecl *, int> &RefsMinusAssignments) {
   assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||
           isa<FunctionParmPackExpr>(E)) &&
          "Invalid Expr argument to DoMarkVarDeclReferenced");
   Var->setReferenced();
 
if (E && Var->isUsableInConstantExpressions(SemaRef.Context))
       SemaRef.MaybeODRUseExprs.insert(E);
     else
       MarkVarDeclODRUsed(Var, Loc, SemaRef);
     break;
 
   case OdrUseContext::Dependent:
     // If this is a dependent context, we don't need to mark variables as
     // odr-used, but we may still need to track them for lambda capture.
     // FIXME: Do we also need to do this inside dependent typeid expressions
     // (which are modeled as unevaluated at this point)?
-    const bool RefersToEnclosingScope =
-        (SemaRef.CurContext != Var->getDeclContext() &&
-         Var->getDeclContext()->isFunctionOrMethod() && Var->hasLocalStorage());
-    if (RefersToEnclosingScope) {
-      LambdaScopeInfo *const LSI =
-          SemaRef.getCurLambda(/*IgnoreNonLambdaCapturingScope=*/true);
-      if (LSI && (!LSI->CallOperator ||
-                  !LSI->CallOperator->Encloses(Var->getDeclContext()))) {
-        // If a variable could potentially be odr-used, defer marking it so
-        // until we finish analyzing the full expression for any
-        // lvalue-to-rvalue
-        // or discarded value conversions that would obviate odr-use.
-        // Add it to the list of potential captures that will be analyzed
-        // later (ActOnFinishFullExpr) for eventual capture and odr-use marking
-        // unless the variable is a reference that was initialized by a constant
-        // expression (this will never need to be captured or odr-used).
-        //
-        // FIXME: We can simplify this a lot after implementing P0588R1.
-        assert(E && "Capture variable should be used in an expression.");
-        if (!Var->getType()->isReferenceType() ||
-            !Var->isUsableInConstantExpressions(SemaRef.Context))
-          LSI->addPotentialCapture(E->IgnoreParens());
-      }
-    }
+    DoMarkPotentialCapture(SemaRef, Loc, Var, E);
     break;
   }
 }
 
 static void DoMarkBindingDeclReferenced(Sema &SemaRef, SourceLocation Loc,
-                                        BindingDecl *BD) {
+                                        BindingDecl *BD, Expr *E) {
   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);
   }
+  else if(OdrUse == OdrUseContext::Dependent) {
+    DoMarkPotentialCapture(SemaRef, Loc, BD, E);
+  }
+
 }
 
 /// 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);
+    DoMarkBindingDeclReferenced(SemaRef, Loc, Decl, E);
     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);

clang/lib/Sema/SemaExprCXX.cpp

assert(
       "The current call operator must be synchronized with Sema's CurContext");
 #endif // NDEBUG
 
   const bool IsFullExprInstantiationDependent = FE->isInstantiationDependent();
 
   // All the potentially captureable variables in the current nested
   // lambda (within a generic outer lambda), must be captured by an
   // outer lambda that is enclosed within a non-dependent context.
-  CurrentLSI->visitPotentialCaptures([&] (VarDecl *Var, Expr *VarExpr) {
+  CurrentLSI->visitPotentialCaptures([&] (ValueDecl *Var, Expr *VarExpr) {
     // If the variable is clearly identified as non-odr-used and the full
     // expression is not instantiation dependent, only then do we not
     // need to check enclosing lambda's for speculative captures.
     // For e.g.:
     // Even though 'x' is not odr-used, it should be captured.
     // int test() {
     //   const int x = 10;
     //   auto L = [=](auto a) {
     //     (void) +x + a;
     //   };
     // }
     if (CurrentLSI->isVariableExprMarkedAsNonODRUsed(VarExpr) &&
         !IsFullExprInstantiationDependent)
       return;
 
+    VarDecl* UnderlyingVar = Var->getPotentiallyDecomposedVarDecl();
+    if(!UnderlyingVar)
+      return;
+
     // If we have a capture-capable lambda for the variable, go ahead and
     // capture the variable in that lambda (and all its enclosing lambdas).
     if (const Optional<unsigned> Index =
             getStackIndexOfNearestEnclosingCaptureCapableLambda(
                 S.FunctionScopes, Var, S))
       S.MarkCaptureUsedInEnclosingContext(Var, VarExpr->getExprLoc(), *Index);
     const bool IsVarNeverAConstantExpression =
-        VariableCanNeverBeAConstantExpression(Var, S.Context);
+        VariableCanNeverBeAConstantExpression(UnderlyingVar, S.Context);
     if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) {
       // This full expression is not instantiation dependent or the variable
       // can not be used in a constant expression - which means
       // this variable must be odr-used here, so diagnose a
       // capture violation early, if the variable is un-captureable.
       // This is purely for diagnosing errors early.  Otherwise, this
       // error would get diagnosed when the lambda becomes capture ready.
       QualType CaptureType, DeclRefType;

clang/lib/Sema/SemaLambda.cpp

 /// \returns An Optional<unsigned> Index that if evaluates to 'true' contains
 /// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda
 /// which is capture-ready.  If the return value evaluates to 'false' then
 /// no lambda is capture-ready for \p VarToCapture.
 
 static inline Optional<unsigned>
 getStackIndexOfNearestEnclosingCaptureReadyLambda(
     ArrayRef<const clang::sema::FunctionScopeInfo *> FunctionScopes,
-    VarDecl *VarToCapture) {
+    ValueDecl *VarToCapture) {
   // Label failure to capture.
   const Optional<unsigned> NoLambdaIsCaptureReady;
 
   // Ignore all inner captured regions.
   unsigned CurScopeIndex = FunctionScopes.size() - 1;
   while (CurScopeIndex > 0 && isa<clang::sema::CapturedRegionScopeInfo>(
                                   FunctionScopes[CurScopeIndex]))
     --CurScopeIndex;

 ///
 /// \returns An Optional<unsigned> Index that if evaluates to 'true' contains
 /// the index (into Sema's FunctionScopeInfo stack) of the innermost lambda
 /// which is capture-capable.  If the return value evaluates to 'false' then
 /// no lambda is capture-capable for \p VarToCapture.
 
 Optional<unsigned> clang::getStackIndexOfNearestEnclosingCaptureCapableLambda(
     ArrayRef<const sema::FunctionScopeInfo *> FunctionScopes,
-    VarDecl *VarToCapture, Sema &S) {
+    ValueDecl *VarToCapture, Sema &S) {
 
   const Optional<unsigned> NoLambdaIsCaptureCapable;
 
   const Optional<unsigned> OptionalStackIndex =
       getStackIndexOfNearestEnclosingCaptureReadyLambda(FunctionScopes,
                                                         VarToCapture);
   if (!OptionalStackIndex)
     return NoLambdaIsCaptureCapable;

clang/lib/Sema/TreeTransform.h

if (C->isPackExpansion()) {
 
         continue;
       }
 
       EllipsisLoc = C->getEllipsisLoc();
     }
 
     // Transform the captured variable.
-    VarDecl *CapturedVar
-      = cast_or_null<VarDecl>(getDerived().TransformDecl(C->getLocation(),
+    ValueDecl *CapturedVar
+      = cast_or_null<ValueDecl>(getDerived().TransformDecl(C->getLocation(),
                                                          C->getCapturedVar()));
     if (!CapturedVar || CapturedVar->isInvalidDecl()) {
       Invalid = true;
       continue;
     }
 
     // Capture the transformed variable.
     getSema().tryCaptureVariable(CapturedVar, C->getLocation(), Kind,
                                  EllipsisLoc);
   }

clang/test/SemaCXX/cxx20-decomposition.cpp

-// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify %s
-// expected-no-diagnostics
+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify -Wunused-variable %s
 
 template <typename, typename>
 constexpr bool is_same = false;
 template <typename T>
 constexpr bool is_same<T, T> = true;
 
 struct S {
   int i;
struct tuple {
 
   int a = 0;
   int &b = a;
 };
 
 namespace std {
 
 template <typename T>
-struct tuple_size {
+struct tuple_size;
+
+template <typename T>
+struct tuple_size<T&> : tuple_size<T>{};
+
+template <typename T>
+requires requires { tuple_size<T>::value; }
+struct tuple_size<const T> : tuple_size<T>{};
+
+template <>
+struct tuple_size<tuple> {
   static constexpr unsigned long value = 2;
 };
 
+
 template <unsigned long, typename T>
 struct tuple_element;
 
 template <>
 struct tuple_element<0, tuple> {
   using type = int;
 };
 
void check_tuple_like() {
   {
     const auto &[v, r] = t;
     (void)[&v, &r ] {
       static_assert(is_same<decltype(v), int>);
       static_assert(is_same<decltype(r), const int &>);
     };
   }
 }
+
+namespace ODRUseTests {
+  struct P { int a; int b; };
+  void GH57826() {
+    const auto [a, b] = P{1, 2}; //expected-note 2{{'b' declared here}} \
+                                 //expected-note 3{{'a' declared here}}
+    (void)[&](auto c) { return b + [&a] {
+        return a;
+    }() ; }(0);
+    (void)[&](auto c) { return b + [&a](auto) {
+        return a;
+    }(0) ; }(0);
+    (void)[=](auto c) { return b + [&a](auto) {
+        return a;
+    }(0) ; }(0);
+    (void)[&a,&b](auto c) { return b + [&a](auto) {
+        return a;
+    }(0) ; }(0);
+    (void)[&a,&b](auto c) { return b + [a](auto) {
+        return a;
+    }(0) ; }(0);
+    (void)[&a](auto c) { return b + [&a](auto) { // expected-error 2{{variable 'b' cannot be implicitly captured}} \
+                                                 // expected-note 2{{lambda expression begins here}} \
+                                                 // expected-note 4{{capture 'b'}}
+        return a;
+    }(0) ; }(0); // expected-note {{in instantiation}}
+    (void)[&b](auto c) { return b + [](auto) {   // expected-note 3{{lambda expression begins here}} \
+                                                 // expected-note 6{{capture 'a'}} \
+                                                 // expected-note 6{{default capture}} \
+                                                 // expected-note {{in instantiation}}
+        return a;  // expected-error 3{{variable 'a' cannot be implicitly captured}}
+    }(0) ; }(0); // expected-note 2{{in instantiation}}
+  }
+}