[cxx2a] P0624R2 fix: only lambdas with no lambda-capture are default-constructible and assignable.

[logan-5]

Summary

This is a fix for rG864949 which only disabled default construction and assignment for lambdas with capture-defaults, where the C++2a draft disables them for lambdas with any lambda-capture at all.

[logan-5]

*ping*

[dblaikie]

Looks good to me. (possible the check (for no default capture and no captures) could be unified with the same check/language used for the implicit function pointer conversion operator ("if (Captures.empty() && CaptureDefault == LCD_None)" - around 1744 in SemaLambda.cpp) - maybe a common utility function to test this condition or the like. But it's hardly a big thing to have it written in two places, really)

[rsmith]

Do you have commit access or do you need someone to commit this for you?

[logan-5]

I had the exact same thought about factoring out this and the function pointer conversion condition. I didn't bother, but I agree it could be a useful function to have.

[logan-5]

I believe I need someone to commit it for me... brand new to all this and unsure, frankly.

clang/lib/AST/DeclCXX.cpp

bool CXXRecordDecl::lambdaIsDefaultConstructibleAndAssignable() const {
   //   constructor if the lambda-expression has a lambda-capture and a
   //   defaulted default constructor otherwise. It has a deleted copy
   //   assignment operator if the lambda-expression has a lambda-capture and
   //   defaulted copy and move assignment operators otherwise.
   //
   // C++17 [expr.prim.lambda]p21:
   //   The closure type associated with a lambda-expression has no default
   //   constructor and a deleted copy assignment operator.
-  if (getLambdaCaptureDefault() != LCD_None)
+  if (getLambdaCaptureDefault() != LCD_None || 
+      getLambdaData().NumCaptures != 0)
     return false;
   return getASTContext().getLangOpts().CPlusPlus2a;
 }
 
 void CXXRecordDecl::addedMember(Decl *D) {
   if (!D->isImplicit() &&
       !isa<FieldDecl>(D) &&
       !isa<IndirectFieldDecl>(D) &&

clang/lib/Sema/SemaDeclCXX.cpp

bool Sema::ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
   assert(!RD->isDependentType() && "do deletion after instantiation");
   if (!LangOpts.CPlusPlus11 || RD->isInvalidDecl())
     return false;
 
   // C++11 [expr.lambda.prim]p19:
   //   The closure type associated with a lambda-expression has a
   //   deleted (8.4.3) default constructor and a deleted copy
   //   assignment operator.
-  // C++2a adds back these operators if the lambda has no capture-default.
+  // C++2a adds back these operators if the lambda has no lambda-capture.
   if (RD->isLambda() && !RD->lambdaIsDefaultConstructibleAndAssignable() &&
       (CSM == CXXDefaultConstructor || CSM == CXXCopyAssignment)) {
     if (Diagnose)
       Diag(RD->getLocation(), diag::note_lambda_decl);
     return true;
   }
 
   // For an anonymous struct or union, the copy and assignment special members

clang/test/SemaCXX/cxx2a-lambda-default-ctor-assign.cpp

 // RUN: %clang_cc1 -std=c++2a -verify %s
 
-auto a = []{};
-decltype(a) a2;
-void f(decltype(a) x, decltype(a) y) {
-  x = y;
-  x = static_cast<decltype(a)&&>(y);
+void no_capture() {
+  auto x = [] {};
+  decltype(x) y;
+  x = x;
+  x = static_cast<decltype(x)&&>(x);
 }
 
-template<typename T>
-struct X {
-  constexpr X() { T::error; } // expected-error {{'::'}}
-  X(const X&);
-  constexpr X &operator=(const X&) { T::error; } // expected-error {{'::'}}
-  constexpr X &operator=(X&&) { T::error; } // expected-error {{'::'}}
-};
-extern X<int> x;
-auto b = [x = x]{}; // expected-note 3{{in instantiation of}}
-decltype(b) b2; // expected-note {{in implicit default constructor}}
-void f(decltype(b) x, decltype(b) y) {
-  x = y; // expected-note {{in implicit copy assignment}}
-  x = static_cast<decltype(b)&&>(y); // expected-note {{in implicit move assignment}}
+void capture_default(int i) {
+  auto x = [=] {}; // expected-note 2{{candidate constructor}} expected-note 2{{lambda expression begins here}}
+  decltype(x) y; // expected-error {{no matching constructor}}
+  x = x; // expected-error {{cannot be assigned}}
+  x = static_cast<decltype(x)&&>(x); // expected-error {{cannot be assigned}}
 }
 
-struct Y {
-  Y() = delete; // expected-note {{deleted}}
-  Y(const Y&);
-  Y &operator=(const Y&) = delete; // expected-note 2{{deleted}}
-  Y &operator=(Y&&) = delete;
-};
-extern Y y;
-auto c = [y = y]{}; // expected-note 3{{deleted because}}
-decltype(c) c2; // expected-error {{deleted}}
-void f(decltype(c) x, decltype(c) y) {
-  x = y; // expected-error {{deleted}}
-  x = static_cast<decltype(c)&&>(y); // expected-error {{deleted}}
+void explicit_capture(int i) {
+  auto x = [i] {}; // expected-note 2{{candidate constructor}} expected-note 2{{lambda expression begins here}}
+  decltype(x) y; // expected-error {{no matching constructor}}
+  x = x; // expected-error {{cannot be assigned}}
+  x = static_cast<decltype(x)&&>(x); // expected-error {{cannot be assigned}}
 }