[Sema] Add a note pointing to the first use of an implicit capture

[vsk]

Summary

When it's not possible to initialize an implicit capture, add a note
pointing to the first use of the captured variable.

Example (the note is new):

lambda-expressions.cpp:81:15: error: no matching constructor for initialization of 'G'

return [=]{
        ^

lambda-expressions.cpp:82:24: note: implicitly capturing 'g', first used here

const G* gg = &g;
               ^

As suggested in https://reviews.llvm.org/D50927.

[rsmith]

clang/lib/Sema/SemaLambda.cpp

1432

This early exit leaves your CodeSynthesisContext on the stack. Consider using RAII?

clang/test/SemaCXX/lambda-expressions.cpp

87

Why are these @+1?

[vsk]

clang/test/SemaCXX/lambda-expressions.cpp

87

A 'no matching constructor' error is present on the line containing "[=]" (pointing to the '=' sign), as well as on the line containing "gg = &g" (pointing to the last 'g').

I'll try to capture that in a neater way.

Stepping back a bit, I think clang does this to make it clear that an implicit capture is part of the problem. It does seem strange to me that we'd emit the same error twice, but according to baseline version of this test, that's the expected behavior. Let me know if I should try and change that diagnostic.

[vsk]

@rsmith, friendly ping. I'm not in a rush on this one, but I know you wanted to see an improvement in lambda capture diagnostics.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_covariant_return_type_different_qualifications : Error<
   "return type of virtual function %0 is not covariant with the return type of "
   "the function it overrides (%1 has different qualifiers than %2)">;
 def err_covariant_return_type_class_type_more_qualified : Error<
   "return type of virtual function %0 is not covariant with the return type of "
   "the function it overrides (class type %1 is more qualified than class "
   "type %2">;
 
+// C++ lambdas
+def note_implicitly_capturing_var_first_used_here : Note<
+  "implicitly capturing %0, first used here">;
+
 // C++ implicit special member functions
 def note_in_declaration_of_implicit_special_member : Note<
   "while declaring the implicit %sub{select_special_member_kind}1"
   " for %0">;
 
 // C++ constructors
 def err_constructor_cannot_be : Error<"constructor cannot be declared '%0'">;
 def err_invalid_qualified_constructor : Error<

clang/include/clang/Sema/Sema.h

enum SynthesisKind {
       /// We are defining a synthesized function (such as a defaulted special
       /// member).
       DefiningSynthesizedFunction,
 
       /// Added for Template instantiation observation.
       /// Memoization means we are _not_ instantiating a template because
       /// it is already instantiated (but we entered a context where we
       /// would have had to if it was not already instantiated).
-      Memoization
+      Memoization,
+
+      /// We are initializing an implicit capture for a lambda.
+      ImplicitLambdaCaptureInitialization,
     } Kind;
 
     /// Was the enclosing context a non-instantiation SFINAE context?
     bool SavedInNonInstantiationSFINAEContext;
 
     /// The point of instantiation or synthesis within the source code.
     SourceLocation PointOfInstantiation;
 

clang/lib/Frontend/FrontendActions.cpp

static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
     case CodeSynthesisContext::ExceptionSpecInstantiation:
       return "ExceptionSpecInstantiation";
     case CodeSynthesisContext::DeclaringSpecialMember:
       return "DeclaringSpecialMember";
     case CodeSynthesisContext::DefiningSynthesizedFunction:
       return "DefiningSynthesizedFunction";
     case CodeSynthesisContext::Memoization:
       return "Memoization";
+    case CodeSynthesisContext::ImplicitLambdaCaptureInitialization:
+      return "ImplicitLambdaCaptureInitialization";
     }
     return "";
   }
 
   template <bool BeginInstantiation>
   static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
                                     const CodeSynthesisContext &Inst) {
     std::string YAML;

clang/lib/Sema/SemaLambda.cpp

 #include "clang/AST/ExprCXX.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/SemaLambda.h"
+#include "llvm/ADT/ScopeExit.h"
 using namespace clang;
 using namespace sema;
 
 /// Examines the FunctionScopeInfo stack to determine the nearest
 /// enclosing lambda (to the current lambda) that is 'capture-ready' 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-ready lambda's LambdaScopeInfo.
static ExprResult performLambdaVarCaptureInitialization(
     Sema &S, const Capture &Capture, FieldDecl *Field,
     SourceLocation ImplicitCaptureLoc, bool IsImplicitCapture) {
   assert(Capture.isVariableCapture() && "not a variable capture");
 
   auto *Var = Capture.getVariable();
   SourceLocation Loc =
       IsImplicitCapture ? ImplicitCaptureLoc : Capture.getLocation();
 
+  if (IsImplicitCapture) {
+    Sema::CodeSynthesisContext Ctx;
+    Ctx.Entity = Var;
+    Ctx.Kind = Sema::CodeSynthesisContext::ImplicitLambdaCaptureInitialization;
+    Ctx.PointOfInstantiation = Capture.getLocation();
+    S.pushCodeSynthesisContext(Ctx);
+  }
+  auto PopCodeSynthesisStackOnExit = llvm::make_scope_exit([&] {
+    if (IsImplicitCapture)
+      S.popCodeSynthesisContext();
+  });
+
   // C++11 [expr.prim.lambda]p21:
   //   When the lambda-expression is evaluated, the entities that
   //   are captured by copy are used to direct-initialize each
   //   corresponding non-static data member of the resulting closure
   //   object. (For array members, the array elements are
   //   direct-initialized in increasing subscript order.) These
   //   initializations are performed in the (unspecified) order in
   //   which the non-static data members are declared.
 
   // C++ [expr.prim.lambda]p12:
   //   An entity captured by a lambda-expression is odr-used (3.2) in
   //   the scope containing the lambda-expression.
   ExprResult RefResult = S.BuildDeclarationNameExpr(
       CXXScopeSpec(), DeclarationNameInfo(Var->getDeclName(), Loc), Var);
   if (RefResult.isInvalid())
     return ExprError();
   Expr *Ref = RefResult.get();
 
   auto Entity = InitializedEntity::InitializeLambdaCapture(
       Var->getIdentifier(), Field->getType(), Loc);
   InitializationKind InitKind = InitializationKind::CreateDirect(Loc, Loc, Loc);
   InitializationSequence Init(S, Entity, InitKind, Ref);
   return Init.Perform(S, Entity, InitKind, Ref);
 }

clang/lib/Sema/SemaTemplateInstantiate.cpp

bool Sema::CodeSynthesisContext::isInstantiationRecord() const {
   case DeducedTemplateArgumentSubstitution:
   case PriorTemplateArgumentSubstitution:
     return true;
 
   case DefaultTemplateArgumentChecking:
   case DeclaringSpecialMember:
   case DefiningSynthesizedFunction:
   case ExceptionSpecEvaluation:
+  case ImplicitLambdaCaptureInitialization:
     return false;
 
   // This function should never be called when Kind's value is Memoization.
   case Memoization:
     break;
   }
 
   llvm_unreachable("Invalid SynthesisKind!");
case CodeSynthesisContext::DefiningSynthesizedFunction: {
       if (CSM != CXXInvalid) {
         Diags.Report(Active->PointOfInstantiation,
                      diag::note_member_synthesized_at)
           << CSM << Context.getTagDeclType(MD->getParent());
       }
       break;
     }
 
+    case CodeSynthesisContext::ImplicitLambdaCaptureInitialization: {
+      Diags.Report(Active->PointOfInstantiation,
+                   diag::note_implicitly_capturing_var_first_used_here)
+          << cast<NamedDecl>(Active->Entity);
+      break;
+    }
+
     case CodeSynthesisContext::Memoization:
       break;
     }
   }
 }
 
 Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
   if (InNonInstantiationSFINAEContext)
for (SmallVectorImpl<CodeSynthesisContext>::const_reverse_iterator
     case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
       // We're either substitution explicitly-specified template arguments
       // or deduced template arguments, so SFINAE applies.
       assert(Active->DeductionInfo && "Missing deduction info pointer");
       return Active->DeductionInfo;
 
     case CodeSynthesisContext::DeclaringSpecialMember:
     case CodeSynthesisContext::DefiningSynthesizedFunction:
+    case CodeSynthesisContext::ImplicitLambdaCaptureInitialization:
       // This happens in a context unrelated to template instantiation, so
       // there is no SFINAE.
       return None;
 
     case CodeSynthesisContext::ExceptionSpecEvaluation:
       // FIXME: This should not be treated as a SFINAE context, because
       // we will cache an incorrect exception specification. However, clang
       // bootstrap relies this! See PR31692.

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

 class NonConstCopy {
 public:
   NonConstCopy(NonConstCopy&); // expected-note{{would lose const}}
 };
 
 void capture_by_copy(NonCopyable nc, NonCopyable &ncr, const NonConstCopy nco) {
   (void)[nc] { }; // expected-error{{capture of variable 'nc' as type 'NonCopyable' calls private copy constructor}}
   (void)[=] { // expected-error{{capture of variable 'ncr' as type 'NonCopyable' calls private copy constructor}}
-    ncr.foo();
+    ncr.foo(); // expected-note{{implicitly capturing 'ncr', first used here}}
   }();
 
   [nco] {}(); // expected-error{{no matching constructor for initialization of 'const NonConstCopy'}}
 }
 
 struct NonTrivial {
   NonTrivial();
   NonTrivial(const NonTrivial &);

clang/test/SemaCXX/lambda-expressions.cpp

void test() {
     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}}
 
     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'}}
+    [=]() {
+      return [=]{ // expected-error {{no matching constructor for initialization of 'G'}}
+        const G* gg = &g; // expected-note {{implicitly capturing 'g', first used here}}
+        return gg->a;
+      }();
+    };
+    (void)^{
+      return [=]{ // expected-error {{no matching constructor for initialization of 'const G'}}
+        const G* gg = &g; // expected-error {{no matching constructor for initialization of 'const G'}} expected-note {{implicitly capturing 'g', first used here}}
+        return gg->a;
+      }();
+    };
 
     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}}
 
     // References can appear in constant expressions if they are initialized by
     // reference constant expressions.
     int i;
     int &ref_i = i; // expected-note {{declared}}
struct S {
     int c = []{ int k = 0; return [=]{ return k; }(); }(); // ok
     int d = []{ return [=]{ return n; }(); }(); // expected-error {{'this' cannot be implicitly captured in this context}}
   };
 }
 
 namespace PR18473 {
   template<typename T> void f() {
     T t(0);
-    (void) [=]{ int n = t; }; // expected-error {{deleted}}
+    (void)[=] { // expected-error {{call to deleted constructor of 'PR18473::NoCopy'}}
+      int n = t; // expected-note {{implicitly capturing 't', first used here}}
+    };
   }
 
   template void f<int>();
   struct NoCopy {
     NoCopy(int);
     NoCopy(const NoCopy &) = delete; // expected-note {{deleted}}
     operator int() const;
   };