[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()) {
+    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