[Sema] Add some basic lambda capture fix-its

[njames93]

Summary

Adds fix-its when users forget to explicitly capture variables or this in lambdas

Addresses https://github.com/clangd/clangd/issues/697

[njames93]

Remove default capture by value fixit if 'this' is explicitly captured pre c++20.
Fix default capture insertion loc to be at the start of the capture list.

[njames93]

Fix tests

[njames93]

clang/lib/Sema/SemaExprCXX.cpp

1229–1235

Could we just attach this fix directly to the warning?

[njames93]

Restrict availability of default capture fixit based on init captures already specified.
[=, A]() {} and [&, &A]() {} are both invalid as explicit captures can't be specified with the same type as default capture.
So we shouldn't offer '=' fixit if any init captures are by value and '&' if any by ref.

[njames93]

clang/include/clang/Basic/DiagnosticSemaKinds.td

7459–7460

Does the variable name need attaching to the note, given the note is attached to a fix-it containing the name of the variable already?

[njames93]

Ping

[kbobyrev]

In D96975#2594147, @njames93 wrote:

Ping

Hi Nathan! Thanks again for this patch and sorry for not taking time to review it yet. It is a busy week for me and my team, so I wasn't able to do much coding/reviewing, apologies for that. I expect to get some time for this in the upcoming days and I do think it's an important thing to dedicate time for.

[kbobyrev]

Thanks! The code looks right, my comments are mostly for the comments around to validate my mental model of the code structure and behavior.

clang/lib/Sema/SemaExpr.cpp

17413

Would be useful to have high-level comments for all three cases you have here. This one is for individual variables, right?

17422

Not having return; after this one or the other ones throws me off-guard and I came to the realization that what you intend here is: the function can issue all FixItHints - for capturing a variable by value, reference and default captures by value and reference. So, in total there could be 4 FixItHint so that the user could choose between all of those and chose the one they want. Is that correct? I think this is something worth documenting.

17425

This comment seems a bit off to me? Could you please expand? (I also don't understand how this relates to the next line).

17610

now there are 3 cast<LambdaScopeInfo>, maybe introduce a variable? would've been much better with C++ init + condition but still

[kbobyrev]

clang/include/clang/Basic/DiagnosticSemaKinds.td

7462

also, "capture all" is a little confusing to me but I don't know what would be better. "capture everything"/"capture all variables/objects"? don't know if it's better.

[njames93]

Address comments

[njames93]

Add check to prevent emitting copy capture fixes for non-copyable types

[kbobyrev]

LGTM, thanks for implementing this and apologies for the review delay (was a tough week for me & my team).

The code is very easy to follow now and the only suggestions are stylistic nits.

clang/lib/Sema/SemaExpr.cpp

17414

This code heavily relies on not having any default captures and I can see that all of the code paths are correct (this condition is checked before calling the function), but I think it's better to explicitly check this with an assert.

17422

17428

nit: the style seems to be omitting {} for single-line sequences of if/for/whiles, probably remove in this case?

17429

nit: CT -> Ctor? CT looks a little unexpected.

17470

also allows removing enclosing {}

17478

maybe just pull the outside if into the inner one? does not seem to hurt readability and reduces the indentation + LOC number.

[njames93]

Address comments.

[kbobyrev]

clang/lib/Sema/SemaExpr.cpp

17430

(braces are not needed here, too)

[sammccall]

Nice fixes! A few drive-by comments from me, up to you though.

clang/include/clang/Basic/DiagnosticSemaKinds.td

7459–7460

perhaps not, but I don't think it hurts

clang/lib/Sema/SemaExpr.cpp

17418

this lambda looks like it could/should be a standalone function

17427

I suspect you need to handle the case where RD is incomplete

17436

POD is rarely precisely the right concept (and deprecated for that reason).
Is isTriviallyCopyableType() just as good here?

17440

This logic assumes there's no default capture, whic his reasonable but not locally obvious - add an assert?

17472

While it's technically possible to transform [&a, &b] to [=, &a, &b], it seems very unlikely the user actually wants this: we should capture the new variable by copy and make that the default, even though so far we've been listing captures explicitly and by reference.

On the other hand, transforming [a, b] to [=] seems more useful, but isn't supported.

I'd suggest just leaving both cases out - only offer a default capture if there are no explicit captures already.

[kbobyrev]

clang/lib/Sema/SemaExpr.cpp

17440

I think this is the same as https://reviews.llvm.org/D96975#inline-920917 (which is done), am I wrong?

[kbobyrev]

clang/lib/Sema/SemaExpr.cpp

17436

Also, maybe if (T->isTriviallyCopyableType(Sema.getASTContext())) return true; at the top and just return false; here? This saves us the necessity to iterate through the ctors.

[njames93]

Address more comments.

[njames93]

clang/lib/Sema/SemaExpr.cpp

17427

I thought that could be skipped, but yeah you're right you could have a lambda parameter be an incomplete type if you're only referencing it.

17472

Transforming [a, b] to [=] is not a good idea imo. We would be replacing perfectly legal, non ambiguous code.

The reason default capture fix-its are emitted last is because more often than not they wont be the users intentions, however It's still nice to show that it is a possibility.

[sammccall]

clang/lib/Sema/SemaExpr.cpp

17472

I don't think fixits are for surfacing code transformations that are unlikely to be what the user wants.

[njames93]

Update to not offer Default capture fix if other variables are also captured.

[njames93]

Prevent explicit 'this' capture fix-it if default capture mode is '=' and not in c++20 mode.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_copy_capture_with_copy_default : Error<
     "'&' must precede a capture when the capture default is '='">;
   def err_capture_does_not_name_variable : Error<
     "%0 in capture list does not name a variable">;
   def err_capture_non_automatic_variable : Error<
     "%0 cannot be captured because it does not have automatic storage "
     "duration">;
   def err_this_capture : Error<
     "'this' cannot be %select{implicitly |}0captured in this context">;
+  def note_lambda_this_capture_fixit : Note<
+    "explicitly capture 'this'">;
   def err_lambda_capture_anonymous_var : Error<
     "unnamed variable cannot be implicitly captured in a lambda expression">;
   def err_lambda_capture_flexarray_type : Error<
     "variable %0 with flexible array member cannot be captured in "
     "a lambda expression">;
   def err_lambda_impcap : Error<
     "variable %0 cannot be implicitly captured in a lambda with no "
     "capture-default specified">;
+  def note_lambda_variable_capture_fixit : Note<
+    "capture variable %0 by %select{value|reference}1">;
+  def note_lambda_default_capture_fixit : Note<
+    "capture all by %select{value|reference}0">;
   def note_lambda_decl : Note<"lambda expression begins here">;
   def err_lambda_unevaluated_operand : Error<
     "lambda expression in an unevaluated operand">;
   def err_lambda_in_constant_expression : Error<
     "a lambda expression may not appear inside of a constant expression">;
   def err_lambda_in_invalid_context : Error<
     "a lambda expression cannot appear in this context">;
   def err_lambda_return_init_list : Error<

clang/lib/Sema/SemaExpr.cpp

static bool captureInLambda(LambdaScopeInfo *LSI,
   // Add the capture.
   if (BuildAndDiagnose)
     LSI->addCapture(Var, /*isBlock=*/false, ByRef, RefersToCapturedVariable,
                     Loc, EllipsisLoc, CaptureType, Invalid);
 
   return !Invalid;
 }
 
+static void buildLambdaCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI,
+                                    VarDecl *Var) {
+  SmallString<32> FixBuffer;
+  StringRef Separator = LSI->NumExplicitCaptures > 0 ? ", " : "";
+  if (Var->getDeclName().isIdentifier() && !Var->getName().empty()) {
+    SourceLocation VarInsertLoc = LSI->IntroducerRange.getEnd();
+    FixBuffer.assign({Separator, Var->getName()});
+    Sema.Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
+        << Var << /*value*/ 0
+        << FixItHint::CreateInsertion(VarInsertLoc, FixBuffer);
+    FixBuffer.assign({Separator, "&", Var->getName()});
+    Sema.Diag(VarInsertLoc, diag::note_lambda_variable_capture_fixit)
+        << Var << /*reference*/ 1
+        << FixItHint::CreateInsertion(VarInsertLoc, FixBuffer);
+  }
+
+  // Default capture mode must be specified first.
+  SourceLocation DefaultInsertLoc =
+      LSI->IntroducerRange.getBegin().getLocWithOffset(1);
+
+  // Can't default capture by value if this is captured before c++20.
+  if (!LSI->isCXXThisCaptured() || Sema.getLangOpts().CPlusPlus20) {
+    FixBuffer.assign({"=", Separator});
+    Sema.Diag(DefaultInsertLoc, diag::note_lambda_default_capture_fixit)
+        << /*value*/ 0
+        << FixItHint::CreateInsertion(DefaultInsertLoc, FixBuffer);
+  }
+  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,
     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())
if (FunctionScopeIndexToStopAt) {
     }
   }
 
 
   // 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();
   if (IsGlobal &&
       !(LangOpts.OpenMP && isOpenMPCapturedDecl(Var, /*CheckScopeInfo=*/true,
                                                 MaxFunctionScopesIndex)))
     return true;
   Var = 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
   // the variable.
do {
     // should be used.
     if (isGenericLambdaCallOperatorSpecialization(DC)) {
       if (BuildAndDiagnose) {
         LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);
         if (LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None) {
           Diag(ExprLoc, diag::err_lambda_impcap) << Var;
           Diag(Var->getLocation(), diag::note_previous_decl) << Var;
           Diag(LSI->Lambda->getBeginLoc(), diag::note_lambda_decl);
+          buildLambdaCaptureFixit(*this, LSI, Var);
         } else
           diagnoseUncapturableValueReference(*this, ExprLoc, Var, DC);
       }
       return true;
     }
 
     // Try to capture variable-length arrays types.
     if (Var->getType()->isVariablyModifiedType()) {
if (getLangOpts().OpenMP) {
       }
     }
     if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None && !Explicit) {
       // No capture-default, and this is not an explicit capture
       // so cannot capture this variable.
       if (BuildAndDiagnose) {
         Diag(ExprLoc, diag::err_lambda_impcap) << Var;
         Diag(Var->getLocation(), diag::note_previous_decl) << Var;
-        if (cast<LambdaScopeInfo>(CSI)->Lambda)
+        if (cast<LambdaScopeInfo>(CSI)->Lambda) {
           Diag(cast<LambdaScopeInfo>(CSI)->Lambda->getBeginLoc(),
                diag::note_lambda_decl);
+          buildLambdaCaptureFixit(*this, cast<LambdaScopeInfo>(CSI), Var);
+        }
         // FIXME: If we error out because an outer lambda can not implicitly
         // capture a variable that an inner lambda explicitly captures, we
         // should have the inner lambda do the explicit capture - because
         // it makes for cleaner diagnostics later.  This would purely be done
         // so that the diagnostic does not misleadingly claim that a variable
         // can not be captured by a lambda implicitly even though it is captured
         // explicitly.  Suggestion:
         //  - create const bool VariableCaptureWasInitiallyExplicit = Explicit

clang/lib/Sema/SemaExprCXX.cpp

 
 
 Sema::CXXThisScopeRAII::~CXXThisScopeRAII() {
   if (Enabled) {
     S.CXXThisTypeOverride = OldCXXThisTypeOverride;
   }
 }
 
+static void buildLambdaThisCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI) {
+  SourceLocation DiagLoc = LSI->IntroducerRange.getEnd();
+  assert(!LSI->isCXXThisCaptured());
+  Sema.Diag(DiagLoc, diag::note_lambda_this_capture_fixit)
+      << FixItHint::CreateInsertion(
+             DiagLoc, LSI->NumExplicitCaptures > 0 ? ", this" : "this");
+}
+
 bool Sema::CheckCXXThisCapture(SourceLocation Loc, const bool Explicit,
     bool BuildAndDiagnose, const unsigned *const FunctionScopeIndexToStopAt,
     const bool ByCopy) {
   // We don't need to capture this in an unevaluated context.
   if (isUnevaluatedContext() && !Explicit)
     return true;
 
   assert((!ByCopy || Explicit) && "cannot implicitly capture *this by value");
if (CapturingScopeInfo *CSI =
       if (CSI->CXXThisCaptureIndex != 0) {
         // 'this' is already being captured; there isn't anything more to do.
         CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose);
         break;
       }
       LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI);
       if (LSI && isGenericLambdaCallOperatorSpecialization(LSI->CallOperator)) {
         // This context can't implicitly capture 'this'; fail out.
-        if (BuildAndDiagnose)
+        if (BuildAndDiagnose) {
           Diag(Loc, diag::err_this_capture)
               << (Explicit && idx == MaxFunctionScopesIndex);
+          if (!Explicit)
+            buildLambdaThisCaptureFixit(*this, LSI);
+        }
         return true;
       }
       if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByref ||
           CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByval ||
           CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_Block ||
           CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_CapturedRegion ||
           (Explicit && idx == MaxFunctionScopesIndex)) {
         // Regarding (Explicit && idx == MaxFunctionScopesIndex): only the first
         // iteration through can be an explicit capture, all enclosing closures,
         // if any, must perform implicit captures.
 
         // This closure can capture 'this'; continue looking upwards.
         NumCapturingClosures++;
         continue;
       }
       // This context can't implicitly capture 'this'; fail out.
       if (BuildAndDiagnose)
         Diag(Loc, diag::err_this_capture)
             << (Explicit && idx == MaxFunctionScopesIndex);
+
+      if (!Explicit)
+        buildLambdaThisCaptureFixit(*this, LSI);
       return true;
     }
     break;
   }
   if (!BuildAndDiagnose) return false;
 
   // If we got here, then the closure at MaxFunctionScopesIndex on the
   // FunctionScopes stack, can capture the *enclosing object*, so capture it

clang/test/CXX/drs/dr6xx.cpp

void g() {
     struct A {
       void h() {
         int arr[N]; (void)arr;
         f(&N); // expected-error {{declared in enclosing}}
       }
     };
 #if __cplusplus >= 201103L
     (void) [] { int arr[N]; (void)arr; };
-    (void) [] { f(&N); }; // expected-error {{cannot be implicitly captured}} expected-note {{here}}
+    (void) [] { f(&N); }; // expected-error {{cannot be implicitly captured}} expected-note {{here}} expected-note 4 {{capture}}
 #endif
   }
 }

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

void immediately_enclosing(int i) { // expected-note{{'i' declared here}}
   [i]() {
     [i] {}();
   }();
 
   [=]() {
     [i] {}();
   }();
 
-  []() { // expected-note{{lambda expression begins here}}
+  []() { // expected-note{{lambda expression begins here}} expected-note 4 {{capture}}
     [i] {}(); // expected-error{{variable 'i' cannot be implicitly captured in a lambda with no capture-default specified}}
   }();
 }
 
 void f1(int i) { // expected-note{{declared here}}
   int const N = 20;
   auto m1 = [=]{
     int const M = 30;
     auto m2 = [i]{
       int x[N][M];
       x[0][0] = i;
     }; 
     (void)N;
     (void)M;
     (void)m2;
   };
   struct s1 {
     int f;
     void work(int n) { // expected-note{{declared here}}
       int m = n*n;
       int j = 40; // expected-note{{declared here}}
-      auto m3 = [this,m] { // expected-note 3{{lambda expression begins here}}
+      auto m3 = [this,m] { // expected-note 3{{lambda expression begins here}} expected-note 9 {{capture}}
         auto m4 = [&,j] { // expected-error{{variable 'j' cannot be implicitly captured in a lambda with no capture-default specified}}
           int x = n; // expected-error{{variable 'n' cannot be implicitly captured in a lambda with no capture-default specified}}
           x += m;
           x += i; // expected-error{{variable 'i' cannot be implicitly captured in a lambda with no capture-default specified}}
           x += f;
         };
       };
     } 
   };
 }

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p2-generic-lambda-1y.cpp

 
 void unevaluated_operand(P &p, int i) { //expected-note{{declared here}}
   // FIXME: this should only emit one error.
   int i2 = sizeof([](auto a, auto b)->void{}(3, '4')); // expected-error{{lambda expression in an unevaluated operand}} \
                                                        // expected-error{{invalid application of 'sizeof'}}
   const std::type_info &ti1 = typeid([](auto &a) -> P& { static P p; return p; }(i)); // expected-warning {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}}
   const std::type_info &ti2 = typeid([](auto) -> int { return i; }(i));  // expected-error{{lambda expression in an unevaluated operand}}\
                                                                          // expected-error{{cannot be implicitly captured}}\
-                                                                         // expected-note{{begins here}}
+                                                                         // expected-note{{begins here}}\
+                                                                         // expected-note 4 {{capture}}
 }

clang/test/SemaCXX/cxx1y-generic-lambdas-capturing.cpp

L(2, 4);
     auto L2 = [](auto a, int i) {
       return a + i;
     };
     L2(3.14, 2);
   }
   {
     int a; //expected-note{{declared here}}
     auto B = []() { return ^{ return a; }; }; //expected-error{{cannot be implicitly capture}}\
-                                              //expected-note{{begins here}}
+                                              //expected-note{{begins here}}\
+                                              //expected-note 4 {{capture}}
   //[](){ return ({int b = 5; return 'c'; 'x';}); };
 
   //auto X = ^{ return a; };
   
   //auto Y = []() -> auto { return 3; return 'c'; };
 
   }  
 }  
 }
 
 
 namespace test_no_capture{
 void doit() {
   const int x = 10; //expected-note{{declared here}}
   {
     // should not capture 'x' - variable undergoes lvalue-to-rvalue
     auto L = [=](auto a) {
       int y = x;
       return a + y;
     };
     ASSERT_NO_CAPTURES(L);
   }
   {
     // should not capture 'x' - even though certain instantiations require
-    auto L = [](auto a) { //expected-note{{begins here}}
+    auto L = [](auto a) { //expected-note{{begins here}} expected-note 4 {{capture}}
       DEFINE_SELECTOR(a);
       F_CALL(x, a); //expected-error{{'x' cannot be implicitly captured}}
     };
     ASSERT_NO_CAPTURES(L);
     L('s'); //expected-note{{in instantiation of}}
   }
   {
     // Does not capture because no default capture in inner most lambda 'b'
const int x = 5;
     auto L = [=](auto a) {
       DEFINE_SELECTOR(a);
       F_CALL(x, a);
     };
     static_assert(sizeof(L) == 4, "Must be captured");
   }
   {
     int j = 0; //expected-note{{declared}}
-    auto L = [](auto a) {  //expected-note{{begins here}}
+    auto L = [](auto a) {  //expected-note{{begins here}} expected-note 4 {{capture}}
       return j + 1; //expected-error{{cannot be implicitly captured}}
     };
   }
   {
     const int x = 10;
     auto L = [](auto a) {
       //const int y = 20;
       return [](int p) { 
template<class T> struct Y {
   static void f(const int&, R, ...) { }
   template<class R>
   void foo(R t) {
     const int x = 10; //expected-note{{declared here}}
     auto L = [=](auto a) {
        T t2{t};       
        return [](auto b) {
         const int y = 0; //expected-note{{declared here}}
-        return [](auto c) { //expected-note 2{{lambda expression begins here}}
+        return [](auto c) { //expected-note 2{{lambda expression begins here}} expected-note 8 {{capture}}
           f(x, c);  //expected-error{{variable 'x'}}
           f(y, c);  //expected-error{{variable 'y'}}
           return 0; 
         };
       };
     };
     auto M = L(t);
     auto N_char = M('b');
void foo() {
     {
       auto L = [=](auto a) {
         f(a);
       };
       L(3);
       L(3.13);
     }
     {
-      auto L = [](auto a) {
+      auto L = [](auto a) { // expected-note {{explicitly capture 'this'}}
         f(a); //expected-error{{this}}
       };
       L(3.13);
       L(2); //expected-note{{in instantiation}}
     }
   }
   
   int g() {

 }
 namespace more_this_capture_1_1 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [=](auto a) { 
-      return [](int i) {
+      return [](int i) { // expected-note {{explicitly capture 'this'}}
         return [=](auto b) {
           f(decltype(a){}); //expected-error{{this}}
           int x = i;
         };
       };
     };
     auto M = L(0.0);  
     auto N = M(3);
     N(5.32); // OK 
     L(3); // expected-note{{instantiation}}
     return 0;
   }
 };
 int run = X{}.g();
 }
 
 namespace more_this_capture_1_1_1 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [=](auto a) { 
-      return [](auto b) {
+      return [](auto b) { // expected-note {{explicitly capture 'this'}}
         return [=](int i) {
           f(b); 
           f(decltype(a){}); //expected-error{{this}}
         };
       };
     };
     auto M = L(0.0);  // OK
     auto N = M(3.3); //OK
     auto M_int = L(0); //expected-note{{instantiation}}
     return 0;
   }
 };
 int run = X{}.g();
 }
 
 
 namespace more_this_capture_1_1_1_1 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [=](auto a) { 
-      return [](auto b) {
+      return [](auto b) { // expected-note {{explicitly capture 'this'}}
         return [=](int i) {
           f(b); //expected-error{{this}}
           f(decltype(a){}); 
         };
       };
     };
     auto M_double = L(0.0);  // OK
     auto N = M_double(3); //expected-note{{instantiation}}
     
     return 0;
   }
 };
 int run = X{}.g();
 }
 
 namespace more_this_capture_2 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [=](auto a) { 
       return [](int i) {
-        return [=](auto b) {
+        return [=](auto b) { // expected-note {{explicitly capture 'this'}}
           f(b); //expected-error{{'this' cannot}}
           int x = i;
         };
       };
     };
     auto M = L(0.0); 
     auto N = M(3);
     N(5); // NOT OK expected-note{{in instantiation of}}
     return 0;
   }
 };
 int run = X{}.g();
 }
 namespace diagnose_errors_early_in_generic_lambdas {
 
 int foo()
 {
 
   { // This variable is used and must be caught early, do not need instantiation
     const int x = 0; //expected-note{{declared}}
-    auto L = [](auto a) { //expected-note{{begins}}
+    auto L = [](auto a) { //expected-note{{begins}} expected-note 4 {{capture}}
       const int &r = x; //expected-error{{variable}}      
     };
   }
   { // This variable is not used 
     const int x = 0; 
     auto L = [](auto a) { 
       int i = x;       
     };
   }
   { 
   
     const int x = 0; //expected-note{{declared}}
     auto L = [=](auto a) { // <-- #A
       const int y = 0;
-      return [](auto b) { //expected-note{{begins}}
+      return [](auto b) { //expected-note{{begins}} expected-note 4 {{capture}}
         int c[sizeof(b)];
         f(x, c);
         f(y, c);
         int i = x;
         // This use will always be an error regardless of instantiation
         // so diagnose this early.
         const int &r = x; //expected-error{{variable}}
       };
int foo() {
     auto M = L(3);
     M(5);
   }
   {
     // FIXME: why are there 2 error messages here?
     int x;
     auto L = [](auto a) { //expected-note {{declared here}}
       int y = 10; //expected-note {{declared here}}
-      return [](int b) { //expected-note 2{{expression begins here}}
+      return [](int b) { //expected-note 2{{expression begins here}} expected-note 8 {{capture}}
         return [=] (auto c) {
           return a + y; //expected-error 2{{cannot be implicitly captured}}
         };
       };
     };
   }
   {
     int x;
struct X {
   
   int g() {
     auto lam = [=](auto a) { f(a); }; // captures 'this'
     lam(0); // ok.
     lam(0.0); // ok.
     return 0;
   }
   int g2() {
-    auto lam = [](auto a) { f(a); }; // expected-error{{'this'}}
+    auto lam = [](auto a) { f(a); }; // expected-error{{'this'}} expected-note {{explicitly capture 'this'}}
     lam(0); // expected-note{{in instantiation of}}
     lam(0.0); // ok.
     return 0;
   }
   double (*fd)(double) = [](auto a) { f(a); return a; };
   
 };
 
template<class T> struct YUnresolvable {
   T t2 = [=](auto b) { f(b); return b; };
 };
 
 template<class T> struct YUnresolvable2 {
   void f(int) { }
   static void f(double) { }
   
   T t = [](auto a) { f(a); return a; }; //expected-error{{'this'}} \
-                                        //expected-note{{in instantiation of}}
+                                        //expected-note{{in instantiation of}}\
+                                        //expected-note {{explicitly capture 'this'}}
   T t2 = [=](auto b) { f(b); return b; };
 };
 
 
 YUnresolvable<FunctorDouble> yud;
 // This will cause an error since it call's with an int and calls a member function.
 YUnresolvable2<FunctorInt> yui;
 
 
 template<class T> struct YOnlyStatic {
   static void f(double) { }
   
   T t = [](auto a) { f(a); return a; };
 };
 YOnlyStatic<FunctorDouble> yos;
 template<class T> struct YOnlyNonStatic {
   void f(int) { }
   
-  T t = [](auto a) { f(a); return a; }; //expected-error{{'this'}}
+  T t = [](auto a) { f(a); return a; }; //expected-error{{'this'}} expected-note {{explicitly capture 'this'}}
 };
 
 
 }
 
 
 namespace check_nsdmi_and_this_capture_of_data_members {
 
 struct FunctorDouble {
   template<class T> FunctorDouble(T t) { t(2.14); };
 };
 struct FunctorInt {
   template<class T> FunctorInt(T t) { t(2); }; 
 };
 
 template<class T> struct YThisCapture {
   const int x = 10;
   static double d; 
-  T t = [](auto a) { return x; }; //expected-error{{'this'}}
+  T t = [](auto a) { return x; }; //expected-error{{'this'}} expected-note {{explicitly capture 'this'}}
   T t2 = [](auto b) {  return d; };
   T t3 = [this](auto a) {
           return [=](auto b) {
             return x;
          };
   };
   T t4 = [=](auto a) {
           return [=](auto b) {
             return x;
          };
   };
-  T t5 = [](auto a) {
+  T t5 = [](auto a) { // expected-note {{explicitly capture 'this'}}
           return [=](auto b) {
             return x;  //expected-error{{'this'}}
          };
   };
 };
 
 template<class T> double YThisCapture<T>::d = 3.14;
 
template<class T> void foo(T t) { //expected-note 2{{declared here}}
   auto L = []()  //expected-note 2{{begins here}}
     { return t; }; //expected-error 2{{cannot be implicitly captured}}
 }
 template void foo(int); //expected-note{{in instantiation of}}
 
 #else
 
 template<class T> void foo(T t) { //expected-note{{declared here}}
-  auto L = []()  //expected-note{{begins here}}
+  auto L = []()  //expected-note{{begins here}} expected-note 4 {{capture}}
     { return t; }; //expected-error{{cannot be implicitly captured}}
 }
 
 #endif
 }
 
 namespace no_this_capture_for_static {
 

 namespace this_capture_for_non_static {
 
 struct X {
   void f(double) { }
   
   int g() {
     auto L = [=](auto a) { f(a); }; 
     L(0); 
-    auto L2 = [](auto a) { f(a); }; //expected-error {{cannot be implicitly captured}}
+    auto L2 = [](auto a) { f(a); }; //expected-error {{cannot be implicitly captured}} expected-note {{explicitly capture 'this'}}
     return 0;
   }
 };
 
 int run = X{}.g();
 }
 
 namespace this_captures_with_num_args_disambiguation {

 }
 namespace enclosing_function_is_template_this_capture {
 // Only error if the instantiation tries to use the member function.
 struct X {
   void f(int) { }
   static void f(double) { }
   template<class T>
   int g(T t) {
-    auto L = [](auto a) { f(a); }; //expected-error{{'this'}} 
+    auto L = [](auto a) { f(a); }; //expected-error{{'this'}} expected-note {{explicitly capture 'this'}}
     L(t); // expected-note{{in instantiation of}}
     return 0;
   }
 };
 
 int run = X{}.g(0.0); // OK.
 int run2 = X{}.g(0);  // expected-note{{in instantiation of}}
 
 
 }
 
 namespace enclosing_function_is_template_this_capture_2 {
 // This should error, even if not instantiated, since
 // this would need to be captured.
 struct X {
   void f(int) { }
   template<class T>
   int g(T t) {
-    auto L = [](auto a) { f(a); }; //expected-error{{'this'}} 
+    auto L = [](auto a) { f(a); }; //expected-error{{'this'}} expected-note {{explicitly capture 'this'}}
     L(t); 
     return 0;
   }
 };
 
 }
 
 

 namespace nested_this_capture_3_2 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [=](auto a) { 
       return [](int i) {
-        return [=](auto b) {
+        return [=](auto b) { // expected-note {{explicitly capture 'this'}}
           f(b); //expected-error {{'this' cannot}}
           int x = i;
         };
       };
     };
     auto M = L(0.0); 
     auto N = M(3);
     N(5); //expected-note {{in instantiation of}}

 namespace nested_this_capture_4 {
 struct X {
   void f(int) { }
   static void f(double) { }
   
   int g() {
     auto L = [](auto a) { 
       return [=](auto i) {
-        return [=](auto b) {
+        return [=](auto b) { // expected-note {{explicitly capture 'this'}}
           f(b); //expected-error {{'this' cannot}}
           int x = i;
         };
       };
     };
     auto M = L(0.0); 
     auto N = M(3);
     N(5); //expected-note {{in instantiation of}}

clang/test/SemaCXX/cxx1y-generic-lambdas.cpp

auto L = [](auto a) {
     };
   };
   auto M = L(3);
   M(4.15);
  }
 {
   int i = 10; //expected-note 3{{declared here}}
   auto L = [](auto a) {
-    return [](auto b) { //expected-note 3{{begins here}}
+    return [](auto b) { //expected-note 3{{begins here}} expected-note 12 {{capture}}
       i = b;  //expected-error 3{{cannot be implicitly captured}}
       return b;
     };
   };
   auto M = L(3); //expected-note{{instantiation}}
   M(4.15); //expected-note{{instantiation}}
  }
  {

clang/test/SemaCXX/cxx1y-init-captures.cpp

auto M = [x = y,
                 &z = y](T& ... t) { }; 
     auto N = [x = y, 
                 &z = y, n = f(t...), 
                 o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...), t...](T& ... s) { 
                   fv([&a(t)]()->decltype(auto) { 
                     return a;
                   }() ...);
                 };                 
-    auto N2 = [x = y,                     //expected-note3{{begins here}}
+    auto N2 = [x = y,                     //expected-note3{{begins here}} expected-note 6 {{capture all by}}
                 &z = y, n = f(t...), 
-                o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...)](T& ... s) { 
+                o = f([&a(t)](T& ... t)->decltype(auto) { return a; }(t...)...)](T& ... s) { // expected-note 6 {{capture variable 't' by}}
                   fv([&a(t)]()->decltype(auto) { //expected-error 3{{captured}}
                     return a;
                   }() ...);
                 };                 
 
   }
 
   void h(int i, char c) { g(i, c); } //expected-note{{in instantiation}}
int test() {
     auto L = [&z = x](int a) {
       return a;;
     };
         
   }
   {
     const int x = 10;
     auto L = [k = x](char a) { //expected-note {{declared}}
-      return [](int b) { //expected-note {{begins}}
+      return [](int b) { //expected-note {{begins}} expected-note 4 {{capture}}
         return [j = k](int c) { //expected-error {{cannot be implicitly captured}}
           return c;
         };
       };
     };
   }
   {
     const int x = 10;
int test(T t = T{}) {
     const T x = 10;
     auto L = [&z = x](T a) {
       return a;;
     };
         
   }
   { // will need to capture x in outer lambda
     const T x = 10; //expected-note {{declared}}
-    auto L = [z = x](char a) { //expected-note {{begins}}
+    auto L = [z = x](char a) { //expected-note {{begins}} expected-note 4 {{capture}}
       auto M = [&y = x](T b) { //expected-error {{cannot be implicitly captured}}
         return y;
       };
       return M;
     };
         
   }
   { // will need to capture x in outer lambda
auto L = [x, z = x](char a) {
       auto M = [&y = x](T b) { 
         return y;
       };
       return M;
     };
   }
   { // will need to capture x in outer lambda
     const int x = 10; //expected-note {{declared}}
-    auto L = [z = x](char a) { //expected-note {{begins}}
+    auto L = [z = x](char a) { //expected-note {{begins}} expected-note 4 {{capture}}
       auto M = [&y = x](T b) { //expected-error {{cannot be implicitly captured}}
         return y;
       };
       return M;
     };
   }
   {
     // no captures

clang/test/SemaCXX/cxx1z-constexpr-lambdas.cpp

 namespace test_captureless_lambda {
 void f() {
   const char c = 'c';
   auto L = [] { return c; };
   constexpr char C = L();
 }
   
 void f(char c) { //expected-note{{declared here}}
-  auto L = [] { return c; }; //expected-error{{cannot be implicitly captured}} expected-note{{lambda expression begins here}}
+  auto L = [] { return c; }; //expected-error{{cannot be implicitly captured}} expected-note{{lambda expression begins here}} expected-note 4 {{capture}}
   int I = L();
 }
 
 }
 
 namespace test_conversion_function_for_non_capturing_lambdas {
 
 namespace ns1 {

clang/test/SemaCXX/lambda-expressions.cpp

 // RUN: %clang_cc1 -std=c++14 -Wno-unused-value -fsyntax-only -verify -verify=expected-cxx14 -fblocks %s
 // RUN: %clang_cc1 -std=c++17 -Wno-unused-value -fsyntax-only -verify -fblocks %s
 
 namespace std { class type_info; };
 
 namespace ExplicitCapture {
   class C {
     int Member;
 
     static void Overload(int);
     void Overload();
     virtual C& Overload(float);
 
     void ImplicitThisCapture() {
-      [](){(void)Member;}; // expected-error {{'this' cannot be implicitly captured in this context}}
-      const int var = [](){(void)Member; return 0;}(); // expected-error {{'this' cannot be implicitly captured in this context}}
+      [](){(void)Member;}; // expected-error {{'this' cannot be implicitly captured in this context}} expected-note {{explicitly capture 'this'}}
+      const int var = [](){(void)Member; return 0;}(); // expected-error {{'this' cannot be implicitly captured in this context}} expected-note {{explicitly capture 'this'}}
       [&](){(void)Member;};
 
       [this](){(void)Member;};
       [this]{[this]{};};
       []{[this]{};};// expected-error {{'this' cannot be implicitly captured in this context}}
       []{Overload(3);};
-      []{Overload();}; // expected-error {{'this' cannot be implicitly captured in this context}}
+      []{Overload();}; // expected-error {{'this' cannot be implicitly captured in this context}} expected-note {{explicitly capture 'this'}}
       []{(void)typeid(Overload());};
-      []{(void)typeid(Overload(.5f));};// expected-error {{'this' cannot be implicitly captured in this context}}
+      []{(void)typeid(Overload(.5f));};// expected-error {{'this' cannot be implicitly captured in this context}} expected-note {{explicitly capture 'this'}}
     }
   };
 
   void f() {
     [this] () {}; // expected-error {{'this' cannot be captured in this context}}
   }
 }
 
 namespace ReturnDeduction {
   void test() {
     [](){ return 1; };
     [](){ return 1; };
     [](){ return ({return 1; 1;}); };
     [](){ return ({return 'c'; 1;}); }; // expected-error {{must match previous return type}}
     []()->int{ return 'c'; return 1; };
     [](){ return 'c'; return 1; };  // expected-error {{must match previous return type}}
     []() { return; return (void)0; };
     [](){ return 1; return 1; };
   }
 }
 
 namespace ImplicitCapture {
   void test() {
     int a = 0; // expected-note 5 {{declared}}
-    []() { return a; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{begins here}}
+    []() { return a; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{begins here}} expected-note 4 {{capture}}
     [&]() { return a; };
     [=]() { return a; };
     [=]() { int* b = &a; }; // expected-error {{cannot initialize a variable of type 'int *' with an rvalue of type 'const int *'}}
     [=]() { return [&]() { return a; }; };
-    []() { return [&]() { return a; }; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}}
-    []() { return ^{ return a; }; };// expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}}
-    []() { return [&a] { return a; }; }; // expected-error 2 {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note 2 {{lambda expression begins here}}
+    []() { return [&]() { return a; }; }; // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} expected-note 4 {{capture}}
+    []() { return ^{ return a; }; };// expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} expected-note 4 {{capture}}
+    []() { return [&a] { return a; }; }; // expected-error 2 {{variable 'a' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note 2 {{lambda expression begins here}} expected-note 8 {{capture}}
     [=]() { return [&a] { return a; }; }; //
 
     const int b = 2;
     []() { return b; };
 
     union { // expected-note {{declared}}
       int c;
       float d;
     };
     d = 3;
     [=]() { return c; }; // expected-error {{unnamed variable cannot be implicitly captured in a lambda expression}}
 
     __block int e; // expected-note 2{{declared}}
     [&]() { return e; }; // expected-error {{__block variable 'e' cannot be captured in a lambda expression}}
     [&e]() { return e; }; // expected-error {{__block variable 'e' cannot be captured in a lambda expression}}
 
     int f[10]; // expected-note {{declared}}
     [&]() { return f[2]; };
     (void) ^{ return []() { return f[2]; }; }; // expected-error {{variable 'f' cannot be implicitly captured in a lambda with no capture-default specified}} \
-    // expected-note{{lambda expression begins here}}
+    // expected-note{{lambda expression begins here}} expected-note 4 {{capture}}
 
     struct G { G(); G(G&); int a; }; // expected-note 6 {{not viable}}
     G g;
     [=]() { const G* gg = &g; return gg->a; };
     [=]() { return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error {{no matching constructor for initialization of 'G'}}
     (void)^{ return [=]{ const G* gg = &g; return gg->a; }(); }; // expected-error 2 {{no matching constructor for initialization of 'const G'}}
 
     const int h = a; // expected-note {{declared}}
-    []() { return h; }; // expected-error {{variable 'h' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}}
+    []() { return h; }; // expected-error {{variable 'h' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} expected-note 4 {{capture}}
 
     // References can appear in constant expressions if they are initialized by
     // reference constant expressions.
     int i;
     int &ref_i = i; // expected-note {{declared}}
-    [] { return ref_i; }; // expected-error {{variable 'ref_i' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}}
+    [] { return ref_i; }; // expected-error {{variable 'ref_i' cannot be implicitly captured in a lambda with no capture-default specified}} expected-note {{lambda expression begins here}} expected-note 4 {{capture}}
 
     static int j;
     int &ref_j = j;
     [] { return ref_j; }; // ok
   }
 }
 
 namespace SpecialMembers {
template<typename...Ts> void nested2(Ts ...ts) { // expected-note 2{{here}}
     // ill-formed because ts can't be implicitly captured.
     //
     // FIXME: This diagnostic does not explain what's happening. We should
     // specify which 'ts' we're referring to in its diagnostic name. We should
     // also say which slice of the pack expansion is being performed in the
     // instantiation backtrace.
     f([&ts] { return (int)f(ts...); } ()...); // \
     // expected-error 2{{'ts' cannot be implicitly captured}} \
-    // expected-note 2{{lambda expression begins here}}
+    // expected-note 2{{lambda expression begins here}} \
+    // expected-note 8 {{capture}}
   }
   template void nested2(int); // ok
   template void nested2(int, int); // expected-note {{in instantiation of}}
 }
 
 namespace PR13860 {
   void foo() {
     auto x = PR13860UndeclaredIdentifier(); // expected-error {{use of undeclared identifier 'PR13860UndeclaredIdentifier'}}
struct S {
     // expected-cxx14-error@-3 {{a lambda expression may not appear inside of a constant expression}}
     int g(int k = ([=]{ return n; }(), 0));
     // expected-error@-1 {{non-local lambda expression cannot have a capture-default}}
     // expected-error@-2 {{invalid use of non-static data member 'n'}}
 
     int a = [=]{ return n; }(); // ok
     int b = [=]{ return [=]{ return n; }(); }(); // ok
     int c = []{ int k = 0; return [=]{ return k; }(); }(); // ok
-    int d = []{ return [=]{ return n; }(); }(); // expected-error {{'this' cannot be implicitly captured in this context}}
+    int d = []{ return [=]{ return n; }(); }(); // expected-error {{'this' cannot be implicitly captured in this context}} expected-note {{explicitly capture 'this'}}
   };
 }
 
 namespace PR18473 {
   template<typename T> void f() {
     T t(0);
     (void) [=]{ int n = t; }; // expected-error {{deleted}}
   }

 
 namespace captured_name {
 void Test() {
   union {           // expected-note {{'' declared here}}
     int i;
   };
   [] { return i; }; // expected-error {{variable '' cannot be implicitly captured in a lambda with no capture-default specified}}
                     // expected-note@-1 {{lambda expression begins here}}
+                    // expected-note@-2 2 {{capture all by}}
 
 }
 };

clang/test/SemaCXX/lambda-invalid-capture.cpp

 
 void captures_invalid_array_type() {
   g child[100];
   auto q = [child]{};
   const int n = sizeof(q);
 }
 
 int pr43080(int i) { // expected-note {{declared here}}
-  return [] { // expected-note {{begins here}}
+  return [] { // expected-note {{begins here}} expected-note 4 {{capture}}
     return sizeof i <
       i; // expected-error {{variable 'i' cannot be implicitly captured in a lambda with no capture-default specified}}
   }();
 }

clang/test/SemaObjCXX/capturing-flexible-array-in-block.mm

 // RUN: %clang_cc1 -fsyntax-only -fblocks -verify -std=c++11 %s
 // rdar://12655829
 
 void f() {
   struct { int x; int y[]; } a; // expected-note 3 {{'a' declared here}}
   ^{return a.x;}(); // expected-error {{cannot refer to declaration of structure variable with flexible array member inside block}}
   [=] {return a.x;}(); // expected-error {{variable 'a' with flexible array member cannot be captured in a lambda expression}}
-  [] {return a.x;}(); // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default}} expected-note {{here}}
+  [] {return a.x;}(); // expected-error {{variable 'a' cannot be implicitly captured in a lambda with no capture-default}} expected-note {{here}} expected-note 4 {{capture}}
 }