Replace the broken LambdaCapture::isInitCapture API.

[jdennett]

Summary

A LambdaCapture does not have sufficient information
to correctly determine whether it is an init-capture or not.
Doing so requires knowledge held in the LambdaExpr itself.

It the case of a nested capture of an init-capture it is not
sufficient to check (as LambdaCapture::isInitCapture
did) whether the associated VarDecl was from an init-capture.

This patch moves isInitCapture to the LambdaExpr and updates
capture->isInitCapture() to lambda->isInitCapture(capture).

[jdennett]

Added tests, and fixed the fix.

Clang ToT rejects the (valid) code from the testcase. With this patch,
it is accepted (and works as intended).

[jdennett]

Actually add the test.

[jdennett]

Coding style fix: change parameter name from capture to Capture.

[jdennett]

Fixing formatting.

[rsmith]

LGTM

[jdennett]

Improve formatting of lambda functions.

Don't let the trailing '*' of a lambda's explicitly-specified return
type be immediately adjacent to the left brace that starts the body
of the lambda.

[jdennett]

That last patch was me losing a fight with arc. The clang-format patch is http://reviews.llvm.org/D10410. This one really is closed.

include/clang/AST/DataRecursiveASTVisitor.h

if (Init->isWritten())
     TRY_TO(TraverseStmt(Init->getInit()));
   return true;
 }
 
 template <typename Derived>
 bool
 RecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr *LE,
                                                     const LambdaCapture *C) {
-  if (C->isInitCapture())
+  if (LE->isInitCapture(C))
     TRY_TO(TraverseDecl(C->getCapturedVar()));
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseLambdaBody(LambdaExpr *LE) {
   StmtQueueAction StmtQueue(*this);
   StmtQueue.queue(LE->getBody());

include/clang/AST/ExprCXX.h

LambdaCaptureDefault getCaptureDefault() const {
     return static_cast<LambdaCaptureDefault>(CaptureDefault);
   }
 
   /// \brief Retrieve the location of this lambda's capture-default, if any.
   SourceLocation getCaptureDefaultLoc() const {
     return CaptureDefaultLoc;
   }
 
+  /// \brief Determine whether one of this lambda's captures is an init-capture.
+  bool isInitCapture(const LambdaCapture *capture) const;
+
   /// \brief An iterator that walks over the captures of the lambda,
   /// both implicit and explicit.
   typedef const Capture *capture_iterator;
 
   /// \brief An iterator over a range of lambda captures.
   typedef llvm::iterator_range<capture_iterator> capture_range;
 
   /// \brief Retrieve this lambda's captures.

include/clang/AST/LambdaCapture.h

public:
 
   /// \brief Determine whether this captures a variable length array bound
   /// expression.
   bool capturesVLAType() const {
     return (DeclAndBits.getPointer() == nullptr) &&
            (DeclAndBits.getInt() & Capture_ByCopy);
   }
 
-  /// \brief Determine whether this is an init-capture.
-  bool isInitCapture() const {
-    return capturesVariable() && getCapturedVar()->isInitCapture();
-  }
-
   /// \brief Retrieve the declaration of the local variable being
   /// captured.
   ///
   /// This operation is only valid if this capture is a variable capture
   /// (other than a capture of \c this).
   VarDecl *getCapturedVar() const {
     assert(capturesVariable() && "No variable available for 'this' capture");
     return cast<VarDecl>(DeclAndBits.getPointer());

include/clang/AST/RecursiveASTVisitor.h

if (Init->isWritten() || getDerived().shouldVisitImplicitCode())
     TRY_TO(TraverseStmt(Init->getInit()));
   return true;
 }
 
 template <typename Derived>
 bool
 RecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr *LE,
                                                     const LambdaCapture *C) {
-  if (C->isInitCapture())
+  if (LE->isInitCapture(C))
     TRY_TO(TraverseDecl(C->getCapturedVar()));
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseLambdaBody(LambdaExpr *LE) {
   TRY_TO(TraverseStmt(LE->getBody()));
   return true;

lib/AST/ExprCXX.cpp

LambdaExpr *LambdaExpr::CreateDeserialized(const ASTContext &C,
   unsigned Size = sizeof(LambdaExpr) + sizeof(Stmt *) * (NumCaptures + 1);
   if (NumArrayIndexVars)
     Size += sizeof(VarDecl) * NumArrayIndexVars
           + sizeof(unsigned) * (NumCaptures + 1);
   void *Mem = C.Allocate(Size);
   return new (Mem) LambdaExpr(EmptyShell(), NumCaptures, NumArrayIndexVars > 0);
 }
 
+bool LambdaExpr::isInitCapture(const LambdaCapture *C) const {
+  return (C->capturesVariable() && C->getCapturedVar()->isInitCapture() &&
+    (getCallOperator() == C->getCapturedVar()->getDeclContext()));
+}
+
 LambdaExpr::capture_iterator LambdaExpr::capture_begin() const {
   return getLambdaClass()->getLambdaData().Captures;
 }
 
 LambdaExpr::capture_iterator LambdaExpr::capture_end() const {
   return capture_begin() + NumCaptures;
 }
 

lib/AST/StmtPrinter.cpp

for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
     NeedComma = true;
 
     switch (C->getCaptureKind()) {
     case LCK_This:
       OS << "this";
       break;
 
     case LCK_ByRef:
-      if (Node->getCaptureDefault() != LCD_ByRef || C->isInitCapture())
+      if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C))
         OS << '&';
       OS << C->getCapturedVar()->getName();
       break;
 
     case LCK_ByCopy:
       OS << C->getCapturedVar()->getName();
       break;
     case LCK_VLAType:
       llvm_unreachable("VLA type in explicit captures.");
     }
 
-    if (C->isInitCapture())
+    if (Node->isInitCapture(C))
       PrintExpr(C->getCapturedVar()->getInit());
   }
   OS << ']';
 
   if (Node->hasExplicitParameters()) {
     OS << " (";
     CXXMethodDecl *Method = Node->getCallOperator();
     NeedComma = false;

lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
   // lambda body, because they are not semantically within that scope.
   typedef std::pair<ExprResult, QualType> InitCaptureInfoTy;
   SmallVector<InitCaptureInfoTy, 8> InitCaptureExprsAndTypes;
   InitCaptureExprsAndTypes.resize(E->explicit_capture_end() -
                                   E->explicit_capture_begin());
   for (LambdaExpr::capture_iterator C = E->capture_begin(),
                                     CEnd = E->capture_end();
        C != CEnd; ++C) {
-    if (!C->isInitCapture())
+    if (!E->isInitCapture(C))
       continue;
     EnterExpressionEvaluationContext EEEC(getSema(),
                                           Sema::PotentiallyEvaluated);
     ExprResult NewExprInitResult = getDerived().TransformInitializer(
         C->getCapturedVar()->getInit(),
         C->getCapturedVar()->getInitStyle() == VarDecl::CallInit);
 
     if (NewExprInitResult.isInvalid())
if (C->capturesThis()) {
       continue;
     }
     // Captured expression will be recaptured during captured variables
     // rebuilding.
     if (C->capturesVLAType())
       continue;
 
     // Rebuild init-captures, including the implied field declaration.
-    if (C->isInitCapture()) {
+    if (E->isInitCapture(C)) {
       InitCaptureInfoTy InitExprTypePair = 
           InitCaptureExprsAndTypes[C - E->capture_begin()];
       ExprResult Init = InitExprTypePair.first;
       QualType InitQualType = InitExprTypePair.second;
       if (Init.isInvalid() || InitQualType.isNull()) {
         Invalid = true;
         continue;
       }

test/SemaCXX/cxx1y-init-captures.cpp

int test(T t = T{}) {
   
   }
   
   return 0;
 }
 
 int run = test(); //expected-note {{instantiation}}
 
-}
+}
+
+namespace classification_of_captures_of_init_captures {
+
+template <typename T>
+void f() {
+  [a = 24] () mutable {
+    [&a] { a = 3; }();
+  }();
+}
+
+template <typename T>
+void h() {
+  [a = 24] (auto param) mutable {
+    [&a] { a = 3; }();
+  }(42);
+}
+
+int run() {
+  f<int>();
+  h<int>();
+}
+
+}