Fix PR32831: 'this capture while instantiating generic lambda call operator specializ...

When computing the appropriate cv-qualifiers for the 'this' capture, we have to examine each enclosing lambda - but when using the FunctionScopeInfo stack we have to ensure that the lambda below (outer) is the decl-context of the closure-class of the current lambda.

https://bugs.llvm.org/show_bug.cgi?id=32831

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@301735 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index d65570fcef766e9ae19b3e32ee2c8387a32a26e7..ed4580952adf85fc841aed2091ab55738585b95c 100644 (file)
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -901,17 +901,35 @@ static QualType adjustCVQualifiersForCXXThisWithinLambda(
   // capturing lamdbda's call operator.
   //
 
-  // The issue is that we cannot rely entirely on the FunctionScopeInfo stack
-  // since ScopeInfos are pushed on during parsing and treetransforming. But
-  // since a generic lambda's call operator can be instantiated anywhere (even
-  // end of the TU) we need to be able to examine its enclosing lambdas and so
-  // we use the DeclContext to get a hold of the closure-class and query it for
-  // capture information.  The reason we don't just resort to always using the
-  // DeclContext chain is that it is only mature for lambda expressions
-  // enclosing generic lambda's call operators that are being instantiated.
+  // Since the FunctionScopeInfo stack is representative of the lexical
+  // nesting of the lambda expressions during initial parsing (and is the best
+  // place for querying information about captures about lambdas that are
+  // partially processed) and perhaps during instantiation of function templates
+  // that contain lambda expressions that need to be transformed BUT not
+  // necessarily during instantiation of a nested generic lambda's function call
+  // operator (which might even be instantiated at the end of the TU) - at which
+  // time the DeclContext tree is mature enough to query capture information
+  // reliably - we use a two pronged approach to walk through all the lexically
+  // enclosing lambda expressions:
+  //
+  //  1) Climb down the FunctionScopeInfo stack as long as each item represents
+  //  a Lambda (i.e. LambdaScopeInfo) AND each LSI's 'closure-type' is lexically
+  //  enclosed by the call-operator of the LSI below it on the stack (while
+  //  tracking the enclosing DC for step 2 if needed).  Note the topmost LSI on
+  //  the stack represents the innermost lambda.
+  //
+  //  2) Iterate out through the DeclContext chain (if it represents a lambda's
+  //  call operator, and therefore must be a generic lambda's call operator,
+  //  which is the only time an inconsistency between the LSI and the
+  //  DeclContext should occur) querying closure types regarding capture
+  //  information.
 
+
+  // 1) Climb down the function scope info stack.
   for (int I = FunctionScopes.size();
-       I-- && isa<LambdaScopeInfo>(FunctionScopes[I]);
+       I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
+       (!CurLSI || CurLSI->Lambda->getDeclContext() ==
+                       cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
        CurDC = getLambdaAwareParentOfDeclContext(CurDC)) {
     CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
 
@@ -927,11 +945,17 @@ static QualType adjustCVQualifiersForCXXThisWithinLambda(
       return ASTCtx.getPointerType(ClassType);
     }
   }
-  // We've run out of ScopeInfos but check if CurDC is a lambda (which can
-  // happen during instantiation of generic lambdas)
+
+  // 2) We've run out of ScopeInfos but check if CurDC is a lambda (which can
+  // happen during instantiation of its nested generic lambda call operator)
   if (isLambdaCallOperator(CurDC)) {
-    assert(CurLSI);
-    assert(isGenericLambdaCallOperatorSpecialization(CurLSI->CallOperator));
+    assert(CurLSI && "While computing 'this' capture-type for a generic "
+                     "lambda, we must have a corresponding LambdaScopeInfo");
+    assert(isGenericLambdaCallOperatorSpecialization(CurLSI->CallOperator) &&
+           "While computing 'this' capture-type for a generic lambda, when we "
+           "run out of enclosing LSI's, yet the enclosing DC is a "
+           "lambda-call-operator we must be (i.e. Current LSI) in a generic "
+           "lambda call oeprator");
     assert(CurDC == getLambdaAwareParentOfDeclContext(CurLSI->CallOperator));
 
     auto IsThisCaptured =

diff --git a/test/SemaCXX/cxx1z-lambda-star-this.cpp b/test/SemaCXX/cxx1z-lambda-star-this.cpp
index a84e653f5c8376c417379dbcb6ee0ac0a172fcc7..56fe79914221954bfb31fcf70f669acf51c49ffc 100644 (file)
--- a/test/SemaCXX/cxx1z-lambda-star-this.cpp
+++ b/test/SemaCXX/cxx1z-lambda-star-this.cpp
@@ -229,3 +229,69 @@ int main() {
 \r
 } //end ns test_star_this\r
 \r
+namespace PR32831 {\r
+// https://bugs.llvm.org/show_bug.cgi?id=32831\r
+namespace ns1 {\r
+template <typename Func> void fun_template(Func func) {\r
+  (void) [&]() { \r
+    func(0); \r
+  };\r
+}\r
+\r
+class A {\r
+  void member_foo() {\r
+    (void) [this] {\r
+      (void) [this] {\r
+        fun_template(\r
+            [this](auto X) {\r
+              auto L = [this](auto Y) \r
+              { member_foo(); };\r
+              L(5);\r
+            }\r
+        );\r
+        fun_template(\r
+            [this](auto) { member_foo(); });\r
+\r
+      };\r
+    };\r
+  }\r
+};\r
+} // end ns1\r
+\r
+namespace ns2 {\r
+\r
+struct B {\r
+  int data = 0;\r
+  template<class F>\r
+  void mem2(F f) {\r
+    (void) [&] (auto f) {\r
+      (void) [&] { f(this->data); };\r
+    }(f);\r
+  }\r
+\r
+};\r
+\r
+class A {\r
+  void member_foo() {\r
+    (void) [this] {\r
+      (void) [this] {\r
+        B{}.mem2(\r
+            [this](auto X) {\r
+              auto L = [this](auto Y) \r
+              { member_foo(); };\r
+              L(5);\r
+            }\r
+        );\r
+        B{}.mem2(\r
+            [this](auto) { member_foo(); });\r
+\r
+      };\r
+    };\r
+  }\r
+};\r
+\r
+\r
+} // end ns2\r
+\r
+}\r
+\r