[Clang] Implement CWG2358 Explicit capture of value

[aaron.ballman]

Precommit CI seems to have caught valid failures this time.

clang/lib/Sema/SemaDeclCXX.cpp

159–172

164

165

[cor3ntin]

Fix tests + address aaron's feedback

[aaron.ballman]

clang/lib/Sema/SemaDeclCXX.cpp

169

Can you add a test case showing what happens with structured bindings? e.g.,

int array[] = { 1, 2 };
auto [a, b] = array; 

void func(int c = [x = a] { return x; }());

Note, I think Clang has a bug here so you might have to write the test with a FIXME comment. (I don't think we implement https://wg21.link/cwg2358 or http://eel.is/c++draft/expr.prim.lambda#capture-3 properly yet.)

The part that worries me there specifically is that a BindingDecl is a ValueDecl and not a VarDecl, so I think that cast<> may assert in this case.

[aaron.ballman]

clang/lib/Sema/SemaDeclCXX.cpp

169

*sigh* this is implementing CWG2358...

So no FIXME comment, I think we should add a test to demonstrate that this works.

[cor3ntin]

Properly handle structured bindings in init capture

[cor3ntin]

clang/lib/Sema/SemaDeclCXX.cpp

107–111

Note that https://reviews.llvm.org/D137244 introduces a utility to do that, but i''d rather avoid having to many dependencies between these patches.

[cor3ntin]

Fix tests

[aaron.ballman]

LGTM!

Adding the language WG in case there are reviews coming from the peanut gallery. Please wait a day before landing just in case.

clang/lib/Sema/SemaDeclCXX.cpp

107–111

So the plan is to land this change, then in D137244 change this usage to the helper function introduced by that patch?

[cor3ntin]

clang/lib/Sema/SemaDeclCXX.cpp

107–111

Yup, i think this would be a good order of operation

clang/docs/ReleaseNotes.rst

 - Implemented DR692, DR1395 and DR1432. Use the ``-fclang-abi-compat=15`` option
   to get the old partial ordering behavior regarding packs. Note that the fix for
   DR1432 is speculative that there is no wording or even resolution for this issue.
   A speculative fix for DR1432 is needed because it fixes regressions caused by DR692.
 - Clang's default C++/ObjC++ standard is now ``gnu++17`` instead of ``gnu++14``.
   This means Clang will by default accept code using features from C++17 and
   conforming GNU extensions. Projects incompatible with C++17 can add
   ``-std=gnu++14`` to their build settings to restore the previous behaviour.
+- Implemented DR2358 allowing init captures in lambdas in default arguments.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 - Support capturing structured bindings in lambdas
   (`P1091R3 <https://wg21.link/p1091r3>`_ and `P1381R1 <https://wg21.link/P1381R1>`_).
   This fixes issues `Issue 52720 <https://github.com/llvm/llvm-project/issues/52720>`_,
   `Issue 54300 <https://github.com/llvm/llvm-project/issues/54300>`_,
   `Issue 54301 <https://github.com/llvm/llvm-project/issues/54301>`_,

clang/lib/Sema/SemaDeclCXX.cpp

if (const auto *Param = dyn_cast<ParmVarDecl>(Decl)) {
     // C++17 [dcl.fct.default]p9 (by CWG 2082):
     //   [...] A parameter shall not appear as a potentially-evaluated
     //   expression in a default argument. [...]
     //
     if (DRE->isNonOdrUse() != NOUR_Unevaluated)
       return S.Diag(DRE->getBeginLoc(),
                     diag::err_param_default_argument_references_param)
              << Param->getDeclName() << DefaultArg->getSourceRange();
-  } else if (const auto *VDecl = dyn_cast<VarDecl>(Decl)) {
+  } else {
+    const VarDecl *VD = nullptr;
+    if (const auto *BD = dyn_cast<BindingDecl>(Decl))
+      VD = dyn_cast_if_present<VarDecl>(BD->getDecomposedDecl());
+    else
+      VD = dyn_cast<VarDecl>(Decl);
+    if (VD) {
       // C++ [dcl.fct.default]p7:
       //   Local variables shall not be used in default argument
       //   expressions.
       //
       // C++17 [dcl.fct.default]p7 (by CWG 2082):
       //   A local variable shall not appear as a potentially-evaluated
       //   expression in a default argument.
       //
       // C++20 [dcl.fct.default]p7 (DR as part of P0588R1, see also CWG 2346):
-    //   Note: A local variable cannot be odr-used (6.3) in a default argument.
+      //   Note: A local variable cannot be odr-used (6.3) in a default
+      //   argument.
       //
-    if (VDecl->isLocalVarDecl() && !DRE->isNonOdrUse())
+      if (VD->isLocalVarDecl() && !DRE->isNonOdrUse())
         return S.Diag(DRE->getBeginLoc(),
                       diag::err_param_default_argument_references_local)
-             << VDecl->getDeclName() << DefaultArg->getSourceRange();
+               << Decl->getDeclName() << DefaultArg->getSourceRange();
+    }
   }
-
   return false;
 }
 
 /// VisitCXXThisExpr - Visit a C++ "this" expression.
 bool CheckDefaultArgumentVisitor::VisitCXXThisExpr(const CXXThisExpr *ThisE) {
   // C++ [dcl.fct.default]p8:
   //   The keyword this shall not be used in a default argument of a
   //   member function.
for (const Expr *E : POE->semantics()) {
     }
 
     Invalid |= Visit(E);
   }
   return Invalid;
 }
 
 bool CheckDefaultArgumentVisitor::VisitLambdaExpr(const LambdaExpr *Lambda) {
-  // C++11 [expr.lambda.prim]p13:
-  //   A lambda-expression appearing in a default argument shall not
-  //   implicitly or explicitly capture any entity.
-  if (Lambda->capture_begin() == Lambda->capture_end())
-    return false;
-
-  return S.Diag(Lambda->getBeginLoc(), diag::err_lambda_capture_default_arg);
+  // [expr.prim.lambda.capture]p9
+  // a lambda-expression appearing in a default argument cannot implicitly or
+  // explicitly capture any local entity. Such a lambda-expression can still
+  // have an init-capture if any full-expression in its initializer satisfies
+  // the constraints of an expression appearing in a default argument.
+  bool Invalid = false;
+  for (const LambdaCapture &LC : Lambda->captures()) {
+    if (!Lambda->isInitCapture(&LC))
+      return S.Diag(LC.getLocation(), diag::err_lambda_capture_default_arg);
+    // Init captures are always VarDecl.
+    auto *D = cast<VarDecl>(LC.getCapturedVar());
+    Invalid |= Visit(D->getInit());
+  }
+  return Invalid;
 }
 } // namespace
 
 void
 Sema::ImplicitExceptionSpecification::CalledDecl(SourceLocation CallLoc,
                                                  const CXXMethodDecl *Method) {
   // If we have an MSAny spec already, don't bother.
   if (!Method || ComputedEST == EST_MSAny)

clang/test/CXX/drs/dr23xx.cpp

#pragma clang __debug dump not_use
   int not_use_2(X *x) {
     // CHECK: MemberExpr {{.*}} ->n {{.*}} non_odr_use_constant
     // CHECK: DeclRefExpr {{.*}} 'x'
     return x->n;
   }
 #pragma clang __debug dump not_use_2
 }
 
+#if __cplusplus >= 201402L
+namespace dr2358 { // dr2358: 16
+  void f2() {
+    int i = 1;
+    void g1(int = [xxx=1] { return xxx; }());  // OK
+    void g2(int = [xxx=i] { return xxx; }());  // expected-error {{default argument references local variable 'i' of enclosing function}}
+  }
+}
+#endif
+
 #if __cplusplus >= 201707L
 // Otherwise, if the qualified-id std::tuple_size<E> names a complete class
 // type **with a member value**, the expression std::tuple_size<E>::value shall
 // be a well-formed integral constant expression
 namespace dr2386 { // dr2386: 9
 struct Bad1 { int a, b; };
 struct Bad2 { int a, b; };
 } // namespace dr2386

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p13.cpp

-// RUN: %clang_cc1 -std=c++11 %s -Wunused -Wno-unused-lambda-capture -verify
+// RUN: %clang_cc1 -std=c++11 %s -Wunused -Wno-unused-lambda-capture -Wno-c++14-extensions -verify
+
+const int global = 0;
+int global_array[] = { 1, 2 };
+auto [ga, gb] = global_array;
 
 void f2() {
   int i = 1;
   void g1(int = ([i]{ return i; })()); // expected-error{{lambda expression in default argument cannot capture any entity}}
   void g2(int = ([i]{ return 0; })()); // expected-error{{lambda expression in default argument cannot capture any entity}}
   void g3(int = ([=]{ return i; })()); // expected-error{{lambda expression in default argument cannot capture any entity}}
   void g4(int = ([=]{ return 0; })());
   void g5(int = ([]{ return sizeof i; })());
+  void g6(int = ([x=1, y = global, &z = global]{ return x; })());
+  void g7(int = ([x=i, &y=i]{ return x; })()); // expected-error 2{{default argument references local variable 'i' of enclosing function}}
+}
+
+
+void structured_bindings() {
+  int array[] = { 1, 2 };
+  auto [a, b] = array;
+  void func(int c = [x = a, &xref = a, y = ga, &yref = ga] { return x; }()); // expected-error {{default argument references local variable 'a' of enclosing function}}
 }
 
 namespace lambda_in_default_args {
   int f(int = [] () -> int { int n; return ++n; } ());
   template<typename T> T g(T = [] () -> T { T n; return ++n; } ());
   int k = f() + g<int>();
 }

clang/www/cxx_dr_status.html

<tr id="2357">
     <td>NAD</td>
     <td>Lookup in member function declarations</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2358">
     <td><a href="https://wg21.link/cwg2358">2358</a></td>
     <td>CD5</td>
     <td>Explicit capture of value</td>
-    <td class="none" align="center">Unknown</td>
+    <td class="unreleased" align="center">Clang 16</td>
   </tr>
   <tr id="2359">
     <td><a href="https://wg21.link/cwg2359">2359</a></td>
     <td>CD5</td>
     <td>Unintended copy initialization with designated initializers</td>
     <td class="none" align="center">Unknown</td>
   </tr>
   <tr id="2360">