[Sema] Add warning for unused lambda captures

[malcolm.parsons]

Summary

Warn when a lambda explicitly captures something that is not used in its body.

The warning is part of -Wunused and can be enabled with -Wunused-lambda-capture.

[arphaman]

test/SemaCXX/uninitialized.cpp

1437

I think that expected-warning shouldn't be used here as you have (void)fname in the lambda (I don't get this warning if I test this locally).

[malcolm.parsons]

Don't warn in a dependent context.
Remove spurious expected-warning.

[arphaman]

I think that the patch would be neater if you add "-Wno-unused-lambda-capture" to the options for all of the tests that are modified by this patch in the CXX/ directory. This would avoid redundant (void) uses and ensure that the (void) uses won't interfere with the original intent where things might be only used in the capture list.

[malcolm.parsons]

Use -Wno-unused-lambda-capture in existing tests.

[malcolm.parsons]

include/clang/Sema/ScopeInfo.h

457

Should this be moved into one of the PointerIntPairs?

[arphaman]

include/clang/Sema/ScopeInfo.h

457

I'm not sure.. If we needed other capturing information in the future I would say that this should be its own field, but I'm not aware of anything else that's needed for this class. So I guess it would be better to pack it into VarAndNestedAndThis, but I wouldn't say it's a deal breaker.

[aaron.ballman]

include/clang/Sema/ScopeInfo.h

457

I'm not keen on inconsistently initializating data members; can you perform this initialization in the constructor instead?

lib/Parse/ParseExprCXX.cpp

738

This change is unrelated to the patch; you can go ahead and commit it without review rather than have it as part of this patch.

lib/Sema/SemaLambda.cpp

1479

Why does From need to be a non-const reference?

1483

Missing a full stop at the end of the comment.

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

17

This does not match the behavior for other -Wunused flags. e.g.,

void f() {
  int i;
  (void)sizeof(i);
}

I don't think diagnosing this test case is correct.

59

Likewise here.

[• Quuxplusone]

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

17

I see some value to maybe diagnosing *something* here. For example, [] { return sizeof(i); } would produce the same result as [i] { return sizeof(i); } but with one fewer capture, so removing the i might be seen as an improvement.

But I'm not sure how to convey this information to the user. You could say "variable i used in unevaluated context refers to the i in the outer scope, not the captured i"... except that I think that would be false. Given that you *have* captured an i, sizeof(i) definitely refers to the captured one AFAIK. The fact that the captured i shadows an i in the outer scope is irrelevant --- in fact the user is *expecting* to shadow the outer i.

Perhaps it would be appropriate to reword the diagnostic to "lambda captures variable i unnecessarily". I would also lean toward splitting it into two diagnostics — one for "this capture is unnecessary" (as in this example) and one for "this capture doesn't even appear lexically in the body of the lambda". Not sure how other people would feel about that.

You should add some test cases with decltype(i) for the same reason as sizeof(i).

26

Would this still produce a diagnostic if decltype(j) were something complicated like lock_guard or string? Presumably it should do the same thing, more or less, as the other -Wunused diagnostics, which I think is "don't warn if the constructor/destructor might actually do important work".

[malcolm.parsons]

include/clang/Sema/ScopeInfo.h

457

I'm not keen on repeating the initialization in every constructor.

lib/Sema/SemaLambda.cpp

1479

It's not related to the warning; it looks like an unnecessary copy.

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

17

Does "lambda capture 'i' is not odr-used" make more sense?

26

I was planning to check for that; thanks for the reminder.

[• Quuxplusone]

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

17

Does "lambda capture 'i' is not odr-used" make more sense?

That would completely satisfy *me*, for what that's worth. It admittedly doesn't match the other -Wunused diagnostics, but it is concise and correct — at least I assume it's correct. :)

[malcolm.parsons]

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

17

C++14 [expr.prim.lambda]p18:

[ Note: An id-expression that is not an odr-use refers to the original entity, never to a member
of the closure type. Furthermore, such an id-expression does not cause the implicit capture of the entity.
— end note ]

[malcolm.parsons]

Change warning message.
Check for side effects.
Add tests for side effects.
Add tests for decltype.
Use const reference.
Add . to comment.
Remove unrelated comment fix.

[aaron.ballman]

include/clang/Basic/DiagnosticSemaKinds.td

319

We do not use the term "odr-use" in any of our other frontend diagnostics; I don't think this is a term that users will actually understand. I think we should drop the term and just use "used".

include/clang/Sema/ScopeInfo.h

457

Consistency is the important bit (see the golden rule in http://llvm.org/docs/CodingStandards.html) -- if you want to move things to be in-class initializers, that would be a reasonable follow-up patch. For this patch, please put the initializer into the constructor.

lib/Sema/SemaLambda.cpp

1479

Thanks for adding the const qualifier.

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

17

Yes, that is correct; it's just incredibly confusing to most mortal programmers. Perhaps instead we can add extra information to the diagnostic telling the user that the variable need not be captured when it's in an unevaluated context (if possible). e.g.,

"lambda capture %0 %select{is not used|is not required to be captured for this use}1"

or something similar. My concern here is that coding standards tell users to explicitly capture variables that are referenced within the lambda, and the user will get a diagnostic that they assume is a false positive because most people don't know what an odr-use is. A quick search online found a handful of such coding standards, btw.

26

One more complex case:

#include <typeinfo>

struct B {
  virtual ~B() = default;
};

struct D : B {};

struct C {
  B& get_d() const;
  C get_c() const;
};

void f() {
  C c1, c2;
  [c1, c2] {
    (void)typeid(c1.get_d());
    (void)typeid(c2.get_c());
  }();
}

Hopefully this does not diagnose c1 as being unused but still diagnoses c2 as unused.

[malcolm.parsons]

Improve warning message for use in unevaluated context.
Initialise used flags in constructors.

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

26

These tests are run with -nostdsysteminc, so I ran it manually:

aaron.cpp:17:21: warning: expression with side effects will be evaluated despite being used as an operand to 'typeid'
      [-Wpotentially-evaluated-expression]
    (void)typeid(c1.get_d());
                    ^
aaron.cpp:16:8: warning: lambda capture 'c2' is not required to be captured for use in an unevaluated context [-Wunused-lambda-capture]
  [c1, c2] {
       ^
2 warnings generated.

[aaron.ballman]

LGTM; this is an awesome new diagnostic, thank you for working on it!

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

26

Perfect!

[malcolm.parsons]

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

87

I don't know why the unevaluated context warning didn't work here.

[aaron.ballman]

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

87

Hmm, it should have, come to think of it. I don't think that's an odr-use (when I get near a standard, I'll double-check), and it is unevaluated. Worth poking at.

[malcolm.parsons]

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

87

The unevaluated context warning worked on line 38 where it's not in a template and on line 85 where it's sizeof instead of decltype.

Somehow the template instantiation is avoiding some work when the capture doesn't have a dependent type.

[aaron.ballman]

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

87

That might make some degree of sense. Btw, I did double check, and it's definitely not an odr-use.

I think this edge case can be handled in a follow-up patch if you want to get the primary work in. If you'd prefer to have it fixed for the initial commit, that's obviously fine too.

[malcolm.parsons]

http://lab.llvm.org:8011/builders/sanitizer-ppc64be-linux/builds/1122/steps/bootstrap%20clang/logs/stdio

/home/buildbots/ppc64be-sanitizer/sanitizer-ppc64be/build/llvm/lib/Analysis/ValueTracking.cpp:1116:17: error: lambda capture 'BitWidth' is not used [-Werror,-Wunused-lambda-capture]
    auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
                ^
/home/buildbots/ppc64be-sanitizer/sanitizer-ppc64be/build/llvm/lib/Analysis/ValueTracking.cpp:1127:17: error: lambda capture 'BitWidth' is not used [-Werror,-Wunused-lambda-capture]
    auto KZF = [BitWidth](const APInt &KnownZero, unsigned ShiftAmt) {
                ^
/home/buildbots/ppc64be-sanitizer/sanitizer-ppc64be/build/llvm/lib/Analysis/ValueTracking.cpp:1131:17: error: lambda capture 'BitWidth' is not used [-Werror,-Wunused-lambda-capture]
    auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
                ^
3 errors generated.

The warnings are correct.

Should I remove the unused lambda captures or revert this changeset?

[arphaman]

IMO, you can go ahead and commit a fix that removes the captures, and the fix can be reviewed post-commit. I don't think you should revert this patch as you'll have to remove the captures anyway before reinstating this patch, so might as well do it now.

[aaron.ballman]

In D28467#645348, @malcolm.parsons wrote:

http://lab.llvm.org:8011/builders/sanitizer-ppc64be-linux/builds/1122/steps/bootstrap%20clang/logs/stdio

/home/buildbots/ppc64be-sanitizer/sanitizer-ppc64be/build/llvm/lib/Analysis/ValueTracking.cpp:1116:17: error: lambda capture 'BitWidth' is not used [-Werror,-Wunused-lambda-capture]
    auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
                ^
/home/buildbots/ppc64be-sanitizer/sanitizer-ppc64be/build/llvm/lib/Analysis/ValueTracking.cpp:1127:17: error: lambda capture 'BitWidth' is not used [-Werror,-Wunused-lambda-capture]
    auto KZF = [BitWidth](const APInt &KnownZero, unsigned ShiftAmt) {
                ^
/home/buildbots/ppc64be-sanitizer/sanitizer-ppc64be/build/llvm/lib/Analysis/ValueTracking.cpp:1131:17: error: lambda capture 'BitWidth' is not used [-Werror,-Wunused-lambda-capture]
    auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
                ^
3 errors generated.

The warnings are correct.

Should I remove the unused lambda captures or revert this changeset?

The warnings look correct to me; I think you should remove the unused lambda captures (no need for a test or review since changes are NFC).

[malcolm.parsons]

There are quite a few of them!

[krasin]

This change makes Clang hardly incompatible with MSVC++. Consider the following program:

#include <stdio.h>

int main(void) {
  const int kDelta = 10000001;
  auto g = [kDelta](int i)
           {
             printf("%d\n", i % kDelta);
           };
  g(2);
}

Clang will warn about the unused lambda capture:

$ clang++ lala.cc -o lala -std=c++14 -Wall -Werror && ./lala
lala.cc:5:13: error: lambda capture 'kDelta' is not required to be captured for use in an unevaluated context [-Werror,-Wunused-lambda-capture]
  auto g = [kDelta](int i)
            ^
1 error generated.

It will compile without any warnings if I remove kDelta from the list of captures:

#include <stdio.h>

int main(void) {
  const int kDelta = 10000001;
  auto g = [](int i)
           {
             printf("%d\n", i % kDelta);
           };
  g(2);
}

But then Microsoft C++ compiler will raise the error:

error C3493: 'kDelta' cannot be implicitly captured because no default capture mode has been specified

At this point, I am unsure how can this be improved, but I feel that pointing out this inconsistency might be useful.
For real world case, see https://codereview.chromium.org/2646553002/, where I tried to fix unused lambda captures in V8, in particular, this failure: https://build.chromium.org/p/tryserver.v8/builders/v8_win_rel_ng/builds/21172/steps/compile/logs/stdio

[malcolm.parsons]

MSVC's behaviour is discussed here: https://social.msdn.microsoft.com/Forums/SqlServer/en-US/4abf18bd-4ae4-4c72-ba3e-3b13e7909d5f/error-c2057-or-c3493-trying-to-use-an-integral-constant-expression-inside-a-lambda?forum=vclanguage
and here:
https://connect.microsoft.com/VisualStudio/feedback/details/725780

[ahatanak]

In D28467#649861, @krasin wrote:

This change makes Clang hardly incompatible with MSVC++. Consider the following program:

#include <stdio.h>

int main(void) {
  const int kDelta = 10000001;
  auto g = [kDelta](int i)
           {
             printf("%d\n", i % kDelta);
           };
  g(2);
}

Clang will warn about the unused lambda capture:

$ clang++ lala.cc -o lala -std=c++14 -Wall -Werror && ./lala
lala.cc:5:13: error: lambda capture 'kDelta' is not required to be captured for use in an unevaluated context [-Werror,-Wunused-lambda-capture]
  auto g = [kDelta](int i)
            ^
1 error generated.

Is kDelta considered to be used in an unevaluated context here? I thought unevaluated context in c++ means the expression is used as operands of operators such as typeid and decltype.

include/clang/Basic/DiagnosticGroups.td

 def UnusedExceptionParameter : DiagGroup<"unused-exception-parameter">;
 def UnneededInternalDecl : DiagGroup<"unneeded-internal-declaration">;
 def UnneededMemberFunction : DiagGroup<"unneeded-member-function">;
 def UnusedPrivateField : DiagGroup<"unused-private-field">;
 def UnusedFunction : DiagGroup<"unused-function", [UnneededInternalDecl]>;
 def UnusedMemberFunction : DiagGroup<"unused-member-function",
                                      [UnneededMemberFunction]>;
 def UnusedLabel : DiagGroup<"unused-label">;
+def UnusedLambdaCapture : DiagGroup<"unused-lambda-capture">;
 def UnusedParameter : DiagGroup<"unused-parameter">;
 def UnusedResult : DiagGroup<"unused-result">;
 def PotentiallyEvaluatedExpression : DiagGroup<"potentially-evaluated-expression">;
 def UnevaluatedExpression : DiagGroup<"unevaluated-expression",
                                       [PotentiallyEvaluatedExpression]>;
 def UnusedValue : DiagGroup<"unused-value", [UnusedComparison, UnusedResult,
                                              UnevaluatedExpression]>;
 def UnusedConstVariable : DiagGroup<"unused-const-variable">;
def Conversion : DiagGroup<"conversion",
                             SignConversion,
                             StringConversion]>,
                  DiagCategory<"Value Conversion Issue">;
 
 def Unused : DiagGroup<"unused",
                        [UnusedArgument, UnusedFunction, UnusedLabel,
                         // UnusedParameter, (matches GCC's behavior)
                         // UnusedMemberFunction, (clean-up llvm before enabling)
-                        UnusedPrivateField, UnusedLocalTypedef,
-                        UnusedValue, UnusedVariable, UnusedPropertyIvar]>,
+                        UnusedPrivateField, UnusedLambdaCapture,
+                        UnusedLocalTypedef, UnusedValue, UnusedVariable,
+                        UnusedPropertyIvar]>,
                         DiagCategory<"Unused Entity Issue">;
 
 // Format settings.
 def FormatInvalidSpecifier : DiagGroup<"format-invalid-specifier">;
 def FormatSecurity : DiagGroup<"format-security">;
 def FormatNonStandard : DiagGroup<"format-non-iso">;
 def FormatY2K : DiagGroup<"format-y2k">;
 def FormatPedantic : DiagGroup<"format-pedantic">;

include/clang/Basic/DiagnosticSemaKinds.td

def warn_unneeded_static_internal_decl : Warning<
   "'static' function %0 declared in header file "
   "should be declared 'static inline'">,
   InGroup<UnneededInternalDecl>, DefaultIgnore;
 def warn_unneeded_member_function : Warning<
   "member function %0 is not needed and will not be emitted">,
   InGroup<UnneededMemberFunction>, DefaultIgnore;
 def warn_unused_private_field: Warning<"private field %0 is not used">,
   InGroup<UnusedPrivateField>, DefaultIgnore;
+def warn_unused_lambda_capture: Warning<"lambda capture %0 is not used">,
+  InGroup<UnusedLambdaCapture>, DefaultIgnore;
 
 def warn_parameter_size: Warning<
   "%0 is a large (%1 bytes) pass-by-value argument; "
   "pass it by reference instead ?">, InGroup<LargeByValueCopy>;
 def warn_return_value_size: Warning<
   "return value of %0 is a large (%1 bytes) pass-by-value object; "
   "pass it by reference instead ?">, InGroup<LargeByValueCopy>;
 def warn_return_value_udt: Warning<

include/clang/Sema/ScopeInfo.h

class Capture {
 
     /// \brief The location of the ellipsis that expands a parameter pack.
     SourceLocation EllipsisLoc;
 
     /// \brief The type as it was captured, which is in effect the type of the
     /// non-static data member that would hold the capture.
     QualType CaptureType;
 
+    /// \brief Whether an explicit capture has been used in the body of the
+    /// lambda.
+    bool Used = false;
+
   public:
     Capture(VarDecl *Var, bool Block, bool ByRef, bool IsNested,
             SourceLocation Loc, SourceLocation EllipsisLoc,
             QualType CaptureType, Expr *Cpy)
         : VarAndNestedAndThis(Var, IsNested ? IsNestedCapture : 0),
           InitExprAndCaptureKind(
               Cpy, !Var ? Cap_VLA : Block ? Cap_Block : ByRef ? Cap_ByRef
                                                               : Cap_ByCopy),
bool isBlockCapture() const {
       return InitExprAndCaptureKind.getInt() == Cap_Block;
     }
     bool isVLATypeCapture() const {
       return InitExprAndCaptureKind.getInt() == Cap_VLA;
     }
     bool isNested() const {
       return VarAndNestedAndThis.getInt() & IsNestedCapture;
     }
+    bool isUsed() const { return Used; }
+    void markUsed() { Used = true; }
 
     VarDecl *getVariable() const {
       return VarAndNestedAndThis.getPointer();
     }
     
     /// \brief Retrieve the location at which this variable was captured.
     SourceLocation getLocation() const { return Loc; }
     

lib/Parse/ParseExprCXX.cpp

 /// \brief Parse a lambda introducer.
 /// \param Intro A LambdaIntroducer filled in with information about the
 ///        contents of the lambda-introducer.
 /// \param SkippedInits If non-null, we are disambiguating between an Obj-C
 ///        message send and a lambda expression. In this mode, we will
 ///        sometimes skip the initializers for init-captures and not fully
 ///        populate \p Intro. This flag will be set to \c true if we do so.
 /// \return A DiagnosticID if it hit something unexpected. The location for
-///         for the diagnostic is that of the current token.
+///         the diagnostic is that of the current token.
 Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
                                                  bool *SkippedInits) {
   typedef Optional<unsigned> DiagResult;
 
   assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['.");
   BalancedDelimiterTracker T(*this, tok::l_square);
   T.consumeOpen();
 

lib/Sema/SemaExpr.cpp

do {
     }
 
     FunctionScopeInfo  *FSI = FunctionScopes[FunctionScopesIndex];
     CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FSI);
 
 
     // Check whether we've already captured it.
     if (isVariableAlreadyCapturedInScopeInfo(CSI, Var, Nested, CaptureType, 
-                                             DeclRefType)) 
+                                             DeclRefType)) {
+      if (BuildAndDiagnose)
+        CSI->getCapture(Var).markUsed();
       break;
+    }
     // If we are instantiating a generic lambda call operator body, 
     // we do not want to capture new variables.  What was captured
     // during either a lambdas transformation or initial parsing
     // should be used. 
     if (isGenericLambdaCallOperatorSpecialization(DC)) {
       if (BuildAndDiagnose) {
         LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CSI);   
         if (LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None) {

lib/Sema/SemaExprCXX.cpp

bool Sema::CheckCXXThisCapture(SourceLocation Loc, const bool Explicit,
 
 
   unsigned NumCapturingClosures = 0;
   for (unsigned idx = MaxFunctionScopesIndex; idx != 0; idx--) {
     if (CapturingScopeInfo *CSI =
             dyn_cast<CapturingScopeInfo>(FunctionScopes[idx])) {
       if (CSI->CXXThisCaptureIndex != 0) {
         // 'this' is already being captured; there isn't anything more to do.
+        if (BuildAndDiagnose)
+          CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed();
         break;
       }
       LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI);
       if (LSI && isGenericLambdaCallOperatorSpecialization(LSI->CallOperator)) {
         // This context can't implicitly capture 'this'; fail out.
         if (BuildAndDiagnose)
           Diag(Loc, diag::err_this_capture)
               << (Explicit && idx == MaxFunctionScopesIndex);

lib/Sema/SemaLambda.cpp

bool ContainsUnexpandedParameterPack;
     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) {
-      LambdaScopeInfo::Capture From = LSI->Captures[I];
+      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.isUsed()) {
+        auto diag = Diag(From.getLocation(), diag::warn_unused_lambda_capture);
+        if (From.isThisCapture())
+          diag << "'this'";
+        else
+          diag << From.getVariable();
+      }
+
       // 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;
       }

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

-// RUN: %clang_cc1 -std=c++11 %s -Wunused -verify
+// RUN: %clang_cc1 -std=c++11 %s -Wunused -Wno-unused-lambda-capture -verify
 
 void odr_used() {
   int i = 17;
   [i]{}();
 }
 
 struct ReachingThis {
   static void static_foo() {

test/CXX/expr/expr.prim/expr.prim.lambda/p13.cpp

-// RUN: %clang_cc1 -std=c++11 %s -Wunused -verify
+// RUN: %clang_cc1 -std=c++11 %s -Wunused -Wno-unused-lambda-capture -verify
 
 void f2() {
   int i = 1;
   void g1(int = ([i]{ return i; })()); // expected-error{{lambda expression in default argument cannot capture any entity}}
   void g2(int = ([i]{ return 0; })()); // expected-error{{lambda expression in default argument cannot capture any entity}}
   void g3(int = ([=]{ return i; })()); // expected-error{{lambda expression in default argument cannot capture any entity}}
   void g4(int = ([=]{ return 0; })());
   void g5(int = ([]{ return sizeof i; })());
 }
 
 namespace lambda_in_default_args {
   int f(int = [] () -> int { int n; return ++n; } ());
   template<typename T> T g(T = [] () -> T { T n; return ++n; } ());
   int k = f() + g<int>();
 }

test/CXX/expr/expr.prim/expr.prim.lambda/p16.cpp

-// RUN: %clang_cc1 -std=c++11 %s -Wunused -verify
+// RUN: %clang_cc1 -std=c++11 %s -Wunused -Wno-unused-lambda-capture -verify
 
 
 struct X {
   X(const X&) = delete; // expected-note 2{{explicitly marked deleted}}
   X(X&);
 };
 
 void test_capture(X x) {

test/CXX/expr/expr.prim/expr.prim.lambda/p18.cpp

-// RUN: %clang_cc1 -std=c++11 %s -Wunused -verify
+// RUN: %clang_cc1 -std=c++11 %s -Wunused -Wno-unused-lambda-capture -verify
 // expected-no-diagnostics
 
 template<typename T, typename U>
 struct is_same {
   static const bool value = false;
 };
 
 template<typename T>

test/CXX/expr/expr.prim/expr.prim.lambda/p19.cpp

-// RUN: %clang_cc1 -std=c++11 %s -Wunused -verify
+// RUN: %clang_cc1 -std=c++11 %s -Wunused -Wno-unused-lambda-capture -verify
 
 struct MoveOnly {
   MoveOnly(MoveOnly&&);
   MoveOnly(const MoveOnly&);
 };
 
 template<typename T> T &&move(T&);
 void test_special_member_functions(MoveOnly mo, int i) {

test/SemaCXX/uninitialized.cpp

-// RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -Wno-unused-value -std=c++11 -verify %s
+// RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -Wno-unused-value -Wno-unused-lambda-capture -std=c++11 -verify %s
 
 // definitions for std::move
 namespace std {
 inline namespace foo {
 template <class T> struct remove_reference { typedef T type; };
 template <class T> struct remove_reference<T&> { typedef T type; };
 template <class T> struct remove_reference<T&&> { typedef T type; };
 

 };
 }
 
 void array_capture(bool b) {
   const char fname[] = "array_capture";
   if (b) {
     int unused; // expected-warning {{unused variable}}
   } else {
     [fname]{};
   }
 }

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

+// RUN: %clang_cc1 -fsyntax-only -Wunused-lambda-capture -Wused-but-marked-unused -Wno-uninitialized -verify -std=c++14 %s
+
+void test() {
+  int i = 0;
+
+  auto captures_nothing = [] {};
+
+  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_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 used}}
+
+  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 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}}
+  };
+}
+
+class Foo
+{
+  void test() {
+    auto explicit_this_used = [this] { return i; };
+    auto explicit_this_used_void = [this] { (void)this; };
+    auto explicit_this_unused = [this] {}; // expected-warning{{lambda capture 'this' is not used}}
+  }
+  int i;
+};
+
+template <typename T>
+void test_templated() {
+  int i = 0;
+
+  auto captures_nothing = [] {};
+
+  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_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 used}}
+
+  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 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}}
+  };
+}
+
+void test_use_template() {
+  test_templated<int>(); // expected-note{{in instantiation of function template specialization 'test_templated<int>' requested here}}
+}