From 299583cf50f1332278f4eef078ffef791ce0f07f Mon Sep 17 00:00:00 2001 From: Faisal Vali Date: Sat, 29 Apr 2017 03:49:17 +0000 Subject: [PATCH] Fix PR32831: 'this capture while instantiating generic lambda call operator specialization 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 --- lib/Sema/SemaExprCXX.cpp | 50 ++++++++++++++----- test/SemaCXX/cxx1z-lambda-star-this.cpp | 66 +++++++++++++++++++++++++ 2 files changed, 103 insertions(+), 13 deletions(-) diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp index d65570fcef..ed4580952a 100644 --- 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(FunctionScopes[I]); + I-- && isa(FunctionScopes[I]) && + (!CurLSI || CurLSI->Lambda->getDeclContext() == + cast(FunctionScopes[I])->CallOperator); CurDC = getLambdaAwareParentOfDeclContext(CurDC)) { CurLSI = cast(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 a84e653f5c..56fe799142 100644 --- a/test/SemaCXX/cxx1z-lambda-star-this.cpp +++ b/test/SemaCXX/cxx1z-lambda-star-this.cpp @@ -229,3 +229,69 @@ int main() { } //end ns test_star_this +namespace PR32831 { +// https://bugs.llvm.org/show_bug.cgi?id=32831 +namespace ns1 { +template void fun_template(Func func) { + (void) [&]() { + func(0); + }; +} + +class A { + void member_foo() { + (void) [this] { + (void) [this] { + fun_template( + [this](auto X) { + auto L = [this](auto Y) + { member_foo(); }; + L(5); + } + ); + fun_template( + [this](auto) { member_foo(); }); + + }; + }; + } +}; +} // end ns1 + +namespace ns2 { + +struct B { + int data = 0; + template + void mem2(F f) { + (void) [&] (auto f) { + (void) [&] { f(this->data); }; + }(f); + } + +}; + +class A { + void member_foo() { + (void) [this] { + (void) [this] { + B{}.mem2( + [this](auto X) { + auto L = [this](auto Y) + { member_foo(); }; + L(5); + } + ); + B{}.mem2( + [this](auto) { member_foo(); }); + + }; + }; + } +}; + + +} // end ns2 + +} + -- 2.40.0