Fix spurious Wunused-lambda-capture warning

[kongyi]

Summary

Clang emits unused-lambda-capture warning for captures in generic lambdas even though they are actually used.

Fixes PR31815.

[malcolm.parsons]

Thanks for looking at this for me.

lib/Sema/SemaLambda.cpp

1525–1532

Should generic lambdas and lambdas in a dependent context be treated the same?

Is a lambda inside a generic lambda in a dependent context?

[kongyi]

lib/Sema/SemaLambda.cpp

1525–1532

Generic lambdas are essentially templated lambdas. For diagnosing unused captures, they can be treated as the same. However we are not generating diagnoses within dependent contexts right now (L1524), so this is not really related to this fix.

[ahatanak]

lib/Sema/SemaLambda.cpp

1525–1532

It looks like clang stops warning about the unnecessary capture in the following code when this patch is applied:

void foo2(int);

void foo1() {
  const int c = 10;
  auto lambda1 = [c](auto a) { // clang used to issue warning "lambda capture 'c' is not required to be captured for this use"
    foo2(c);
  };
  lambda1(100);
}

Is it possible to suppress the warning if From is an init capture instead?

[malcolm.parsons]

lib/Sema/SemaLambda.cpp

1526–1527

This would be better using a ternary operator.
Add a comment too.

[malcolm.parsons]

I don't understand why init captures have this problem.
The variable is defined within the context of the lambda, but it's not within the context of the templated method.
Are you working around a bug somewhere else?

[kongyi]

For normal captures, variables are safe to eliminate if they are non-ODR used or totally unused. However for init captures, non-ODR usage still depends on the capture; they are only safe to eliminate if totally unused.

[malcolm.parsons]

LGTM!

lib/Sema/SemaLambda.cpp

LambdaCaptureDefault CaptureDefault =
       mapImplicitCaptureStyle(LSI->ImpCaptureStyle);
   CXXRecordDecl *Class;
   CXXMethodDecl *CallOperator;
   SourceRange IntroducerRange;
   bool ExplicitParams;
   bool ExplicitResultType;
   CleanupInfo LambdaCleanup;
   bool ContainsUnexpandedParameterPack;
+  bool IsGenericLambda;
   {
     CallOperator = LSI->CallOperator;
     Class = LSI->Lambda;
     IntroducerRange = LSI->IntroducerRange;
     ExplicitParams = LSI->ExplicitParams;
     ExplicitResultType = !LSI->HasImplicitReturnType;
     LambdaCleanup = LSI->Cleanup;
     ContainsUnexpandedParameterPack = LSI->ContainsUnexpandedParameterPack;
-    
+    IsGenericLambda = Class->isGenericLambda();
     CallOperator->setLexicalDeclContext(Class);
     Decl *TemplateOrNonTemplateCallOperatorDecl = 
         CallOperator->getDescribedFunctionTemplate()  
         ? CallOperator->getDescribedFunctionTemplate() 
         : cast<Decl>(CallOperator);
 
     TemplateOrNonTemplateCallOperatorDecl->setLexicalDeclContext(Class);
     Class->addDecl(TemplateOrNonTemplateCallOperatorDecl);
 
     PopExpressionEvaluationContext();
 
     // Translate captures.
     auto CurField = Class->field_begin();
     for (unsigned I = 0, N = LSI->Captures.size(); I != N; ++I, ++CurField) {
       const LambdaScopeInfo::Capture &From = LSI->Captures[I];
       assert(!From.isBlockCapture() && "Cannot capture __block variables");
       bool IsImplicit = I >= LSI->NumExplicitCaptures;
 
       // Warn about unused explicit captures.
-      if (!CurContext->isDependentContext() && !IsImplicit && !From.isODRUsed())
+      if (!CurContext->isDependentContext() && !IsImplicit && !From.isODRUsed()) {
+        // Initialized captures that are non-ODR used may not be eliminated.
+        bool NonODRUsedInitCapture =
+            IsGenericLambda && From.isNonODRUsed() && From.getInitExpr();
+        if (!NonODRUsedInitCapture)
           DiagnoseUnusedLambdaCapture(From);
+      }
 
       // Handle 'this' capture.
       if (From.isThisCapture()) {
         Captures.push_back(
             LambdaCapture(From.getLocation(), IsImplicit,
                           From.isCopyCapture() ? LCK_StarThis : LCK_This));
         CaptureInits.push_back(From.getInitExpr());
         continue;
       }
if (Captures.empty() && CaptureDefault == LCD_None)
                                    CallOperator);
 
     // Objective-C++:
     //   The closure type for a lambda-expression has a public non-virtual
     //   non-explicit const conversion function to a block pointer having the
     //   same parameter and return types as the closure type's function call
     //   operator.
     // FIXME: Fix generic lambda to block conversions.
-    if (getLangOpts().Blocks && getLangOpts().ObjC1 && 
-                                              !Class->isGenericLambda())
+    if (getLangOpts().Blocks && getLangOpts().ObjC1 && !IsGenericLambda)
       addBlockPointerConversion(*this, IntroducerRange, Class, CallOperator);
     
     // Finalize the lambda class.
     SmallVector<Decl*, 4> Fields(Class->fields());
     ActOnFields(nullptr, Class->getLocation(), Class, Fields, SourceLocation(),
                 SourceLocation(), nullptr);
     CheckCompletedCXXClass(Class);
   }

test/SemaCXX/warn-unused-lambda-capture.cpp

void test_templated() {
 
   auto captures_nothing_by_value = [=] {};
   auto captures_nothing_by_reference = [&] {};
 
   auto implicit_by_value = [=]() mutable { i++; };
   auto implicit_by_reference = [&] { i++; };
 
   auto explicit_by_value_used = [i] { return i + 1; };
+  auto explicit_by_value_used_generic = [i](auto c) { return i + 1; };
   auto explicit_by_value_used_void = [i] { (void)i; };
+
   auto explicit_by_value_unused = [i] {}; // expected-warning{{lambda capture 'i' is not used}}
   auto explicit_by_value_unused_sizeof = [i] { return sizeof(i); }; // expected-warning{{lambda capture 'i' is not required to be captured for this use}}
   auto explicit_by_value_unused_decltype = [i] { decltype(i) j = 0; }; // expected-warning{{lambda capture 'i' is not used}}
   auto explicit_by_value_unused_const = [k] { return k + 1; };         // expected-warning{{lambda capture 'k' is not required to be captured for this use}}
+  auto explicit_by_value_unused_const_generic = [k](auto c) { return k + 1; }; // expected-warning{{lambda capture 'k' is not required to be captured for this use}}
 
   auto explicit_by_reference_used = [&i] { i++; };
   auto explicit_by_reference_unused = [&i] {}; // expected-warning{{lambda capture 'i' is not used}}
 
   auto explicit_initialized_reference_used = [&j = i] { return j + 1; };
   auto explicit_initialized_reference_unused = [&j = i]{}; // expected-warning{{lambda capture 'j' is not used}}
 
   auto explicit_initialized_value_used = [j = 1] { return j + 1; };
   auto explicit_initialized_value_unused = [j = 1] {}; // expected-warning{{lambda capture 'j' is not used}}
   auto explicit_initialized_value_non_trivial_constructor = [j = NonTrivialConstructor()]{};
   auto explicit_initialized_value_non_trivial_destructor = [j = NonTrivialDestructor()]{};
   auto explicit_initialized_value_trivial_init = [j = Trivial()]{}; // expected-warning{{lambda capture 'j' is not used}}
   auto explicit_initialized_value_non_trivial_init = [j = Trivial(42)]{};
   auto explicit_initialized_value_with_side_effect = [j = side_effect()]{};
+  auto explicit_initialized_value_generic_used = [i = 1](auto c) mutable { i++; };
+  auto explicit_initialized_value_generic_unused = [i = 1](auto c) mutable {}; // expected-warning{{lambda capture 'i' is not used}}
 
   auto nested = [&i] {
     auto explicit_by_value_used = [i] { return i + 1; };
     auto explicit_by_value_unused = [i] {}; // expected-warning{{lambda capture 'i' is not used}}
   };
 
   Trivial trivial;
   auto explicit_by_value_trivial = [trivial] {}; // expected-warning{{lambda capture 'trivial' is not used}}