r301972 - Fix PR32831 (Try Again): 'this' capture while instantiating generic lambda call operator specialization
Faisal Vali via cfe-commits
cfe-commits at lists.llvm.org
Tue May 2 13:56:35 PDT 2017
Author: faisalv
Date: Tue May 2 15:56:34 2017
New Revision: 301972
URL: http://llvm.org/viewvc/llvm-project?rev=301972&view=rev
Log:
Fix PR32831 (Try Again): '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
This patch was initially committed here: https://reviews.llvm.org/rL301735
Then reverted here: https://reviews.llvm.org/rL301916
The issue with the original patch was a failure to check that the closure type has been created within the LambdaScopeInfo before querying its DeclContext - instead of just assuming it has (silly!). A reduced example such as this highlights the problem:
struct X {
int data;
auto foo() { return [] { return [] -> decltype(data) { return 0; }; }; }
};
When 'data' within decltype(data) tries to determine the type of 'this', none of the LambdaScopeInfo's have their closure types created at that point.
Modified:
cfe/trunk/lib/Sema/SemaExprCXX.cpp
cfe/trunk/test/SemaCXX/cxx1z-lambda-star-this.cpp
Modified: cfe/trunk/lib/Sema/SemaExprCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaExprCXX.cpp?rev=301972&r1=301971&r2=301972&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaExprCXX.cpp (original)
+++ cfe/trunk/lib/Sema/SemaExprCXX.cpp Tue May 2 15:56:34 2017
@@ -901,17 +901,36 @@ static QualType adjustCVQualifiersForCXX
// 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) If we run out of enclosing LSI's, check if the enclosing DeclContext
+ // represents a lambda's call operator. If it does, we must be instantiating
+ // a generic lambda's call operator (represented by the Current LSI, and
+ // should be the only scenario where an inconsistency between the LSI and the
+ // DeclContext should occur), so climb out the DeclContexts if they
+ // represent lambdas, while querying the corresponding 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 || CurLSI->Lambda->getDeclContext() ==
+ cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
CurDC = getLambdaAwareParentOfDeclContext(CurDC)) {
CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
@@ -927,11 +946,17 @@ static QualType adjustCVQualifiersForCXX
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 =
Modified: cfe/trunk/test/SemaCXX/cxx1z-lambda-star-this.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/cxx1z-lambda-star-this.cpp?rev=301972&r1=301971&r2=301972&view=diff
==============================================================================
--- cfe/trunk/test/SemaCXX/cxx1z-lambda-star-this.cpp (original)
+++ cfe/trunk/test/SemaCXX/cxx1z-lambda-star-this.cpp Tue May 2 15:56:34 2017
@@ -1,231 +1,300 @@
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -emit-llvm-only %s
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
-// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
-
-template<class, class> constexpr bool is_same = false;
-template<class T> constexpr bool is_same<T, T> = true;
-
-namespace test_star_this {
-namespace ns1 {
-class A {
- int x = 345;
- auto foo() {
- (void) [*this, this] { }; //expected-error{{'this' can appear only once}}
- (void) [this] { ++x; };
- (void) [*this] { ++x; }; //expected-error{{read-only variable}}
- (void) [*this] () mutable { ++x; };
- (void) [=] { return x; };
- (void) [&, this] { return x; };
- (void) [=, *this] { return x; };
- (void) [&, *this] { return x; };
- }
-};
-} // end ns1
-
-namespace ns2 {
- class B {
- B(const B&) = delete; //expected-note{{deleted here}}
- int *x = (int *) 456;
- void foo() {
- (void)[this] { return x; };
- (void)[*this] { return x; }; //expected-error{{call to deleted}}
- }
- };
-} // end ns2
-namespace ns3 {
- class B {
- B(const B&) = delete; //expected-note2{{deleted here}}
-
- int *x = (int *) 456;
- public:
- template<class T = int>
- void foo() {
- (void)[this] { return x; };
- (void)[*this] { return x; }; //expected-error2{{call to deleted}}
- }
-
- B() = default;
- } b;
- B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}
-} // end ns3
-
-namespace ns4 {
-template<class U>
-class B {
- B(const B&) = delete; //expected-note{{deleted here}}
- double d = 3.14;
- public:
- template<class T = int>
- auto foo() {
- const auto &L = [*this] (auto a) mutable { //expected-error{{call to deleted}}
- d += a;
- return [this] (auto b) { return d +=b; };
- };
- }
-
- B() = default;
-};
-void main() {
- B<int*> b;
- b.foo(); //expected-note{{in instantiation}}
-} // end main
-} // end ns4
-namespace ns5 {
-
-struct X {
- double d = 3.14;
- X(const volatile X&);
- void foo() {
-
- }
-
- void foo() const { //expected-note{{const}}
-
- auto L = [*this] () mutable {
- static_assert(is_same<decltype(this), X*>);
- ++d;
- auto M = [this] {
- static_assert(is_same<decltype(this), X*>);
- ++d;
- auto N = [] {
- static_assert(is_same<decltype(this), X*>);
- };
- };
- };
-
- auto L1 = [*this] {
- static_assert(is_same<decltype(this), const X*>);
- auto M = [this] () mutable {
- static_assert(is_same<decltype(this), const X*>);
- auto N = [] {
- static_assert(is_same<decltype(this), const X*>);
- };
- };
- auto M2 = [*this] () mutable {
- static_assert(is_same<decltype(this), X*>);
- auto N = [] {
- static_assert(is_same<decltype(this), X*>);
- };
- };
- };
-
- auto GL1 = [*this] (auto a) {
- static_assert(is_same<decltype(this), const X*>);
- auto M = [this] (auto b) mutable {
- static_assert(is_same<decltype(this), const X*>);
- auto N = [] (auto c) {
- static_assert(is_same<decltype(this), const X*>);
- };
- return N;
- };
-
- auto M2 = [*this] (auto a) mutable {
- static_assert(is_same<decltype(this), X*>);
- auto N = [] (auto b) {
- static_assert(is_same<decltype(this), X*>);
- };
- return N;
- };
- return [=](auto a) mutable { M(a)(a); M2(a)(a); };
- };
-
- GL1("abc")("abc");
-
-
- auto L2 = [this] () mutable {
- static_assert(is_same<decltype(this), const X*>);
- ++d; //expected-error{{cannot assign}}
- };
- auto GL = [*this] (auto a) mutable {
- static_assert(is_same<decltype(this), X*>);
- ++d;
- auto M = [this] (auto b) {
- static_assert(is_same<decltype(this), X*>);
- ++d;
- auto N = [] (auto c) {
- static_assert(is_same<decltype(this), X*>);
- };
- N(3.14);
- };
- M("abc");
- };
- GL(3.14);
-
- }
- void foo() volatile const {
- auto L = [this] () {
- static_assert(is_same<decltype(this), const volatile X*>);
- auto M = [*this] () mutable {
- static_assert(is_same<decltype(this), X*>);
- auto N = [this] {
- static_assert(is_same<decltype(this), X*>);
- auto M = [] {
- static_assert(is_same<decltype(this), X*>);
- };
- };
- auto N2 = [*this] {
- static_assert(is_same<decltype(this), const X*>);
- };
- };
- auto M2 = [*this] () {
- static_assert(is_same<decltype(this), const X*>);
- auto N = [this] {
- static_assert(is_same<decltype(this), const X*>);
- };
- };
- };
- }
-
-};
-
-} //end ns5
-namespace ns6 {
-struct X {
- double d;
- auto foo() const {
- auto L = [*this] () mutable {
- auto M = [=] (auto a) {
- auto N = [this] {
- ++d;
- static_assert(is_same<decltype(this), X*>);
- auto O = [*this] {
- static_assert(is_same<decltype(this), const X*>);
- };
- };
- N();
- static_assert(is_same<decltype(this), X*>);
- };
- return M;
- };
- return L;
- }
-};
-
-int main() {
- auto L = X{}.foo();
- auto M = L();
- M(3.14);
-}
-} // end ns6
-namespace ns7 {
-
-struct X {
- double d;
- X();
- X(const X&);
- X(X&) = delete;
- auto foo() const {
- //OK - the object used to initialize our capture is a const object and so prefers the non-deleted ctor.
- const auto &&L = [*this] { };
- }
-
-};
-int main() {
- X x;
- x.foo();
-}
-} // end ns7
-
-} //end ns test_star_this
-
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -emit-llvm-only %s
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
+
+template <class, class>
+constexpr bool is_same = false;
+template <class T>
+constexpr bool is_same<T, T> = true;
+
+namespace test_star_this {
+namespace ns1 {
+class A {
+ int x = 345;
+ auto foo() {
+ (void)[ *this, this ]{}; //expected-error{{'this' can appear only once}}
+ (void)[this] { ++x; };
+ (void)[*this] { ++x; }; //expected-error{{read-only variable}}
+ (void)[*this]() mutable { ++x; };
+ (void)[=] { return x; };
+ (void)[&, this ] { return x; };
+ (void)[ =, *this ] { return x; };
+ (void)[&, *this ] { return x; };
+ }
+};
+} // namespace ns1
+
+namespace ns2 {
+class B {
+ B(const B &) = delete; //expected-note{{deleted here}}
+ int *x = (int *)456;
+ void foo() {
+ (void)[this] { return x; };
+ (void)[*this] { return x; }; //expected-error{{call to deleted}}
+ }
+};
+} // namespace ns2
+
+namespace ns3 {
+class B {
+ B(const B &) = delete; //expected-note2{{deleted here}}
+
+ int *x = (int *)456;
+
+public:
+ template <class T = int>
+ void foo() {
+ (void)[this] { return x; };
+ (void)[*this] { return x; }; //expected-error2{{call to deleted}}
+ }
+
+ B() = default;
+} b;
+B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}
+} // namespace ns3
+
+namespace ns4 {
+template <class U>
+class B {
+ B(const B &) = delete; //expected-note{{deleted here}}
+ double d = 3.14;
+
+public:
+ template <class T = int>
+ auto foo() {
+ const auto &L = [*this](auto a) mutable { //expected-error{{call to deleted}}
+ d += a;
+ return [this](auto b) { return d += b; };
+ };
+ }
+
+ B() = default;
+};
+void main() {
+ B<int *> b;
+ b.foo(); //expected-note{{in instantiation}}
+} // end main
+} // namespace ns4
+
+namespace ns5 {
+
+struct X {
+ double d = 3.14;
+ X(const volatile X &);
+ void foo() {
+ }
+
+ void foo() const { //expected-note{{const}}
+
+ auto L = [*this]() mutable {
+ static_assert(is_same<decltype(this), X *>);
+ ++d;
+ auto M = [this] {
+ static_assert(is_same<decltype(this), X *>);
+ ++d;
+ auto N = [] {
+ static_assert(is_same<decltype(this), X *>);
+ };
+ };
+ };
+
+ auto L1 = [*this] {
+ static_assert(is_same<decltype(this), const X *>);
+ auto M = [this]() mutable {
+ static_assert(is_same<decltype(this), const X *>);
+ auto N = [] {
+ static_assert(is_same<decltype(this), const X *>);
+ };
+ };
+ auto M2 = [*this]() mutable {
+ static_assert(is_same<decltype(this), X *>);
+ auto N = [] {
+ static_assert(is_same<decltype(this), X *>);
+ };
+ };
+ };
+
+ auto GL1 = [*this](auto a) {
+ static_assert(is_same<decltype(this), const X *>);
+ auto M = [this](auto b) mutable {
+ static_assert(is_same<decltype(this), const X *>);
+ auto N = [](auto c) {
+ static_assert(is_same<decltype(this), const X *>);
+ };
+ return N;
+ };
+
+ auto M2 = [*this](auto a) mutable {
+ static_assert(is_same<decltype(this), X *>);
+ auto N = [](auto b) {
+ static_assert(is_same<decltype(this), X *>);
+ };
+ return N;
+ };
+ return [=](auto a) mutable { M(a)(a); M2(a)(a); };
+ };
+
+ GL1("abc")
+ ("abc");
+
+ auto L2 = [this]() mutable {
+ static_assert(is_same<decltype(this), const X *>);
+ ++d; //expected-error{{cannot assign}}
+ };
+ auto GL = [*this](auto a) mutable {
+ static_assert(is_same<decltype(this), X *>);
+ ++d;
+ auto M = [this](auto b) {
+ static_assert(is_same<decltype(this), X *>);
+ ++d;
+ auto N = [](auto c) {
+ static_assert(is_same<decltype(this), X *>);
+ };
+ N(3.14);
+ };
+ M("abc");
+ };
+ GL(3.14);
+ }
+ void foo() volatile const {
+ auto L = [this]() {
+ static_assert(is_same<decltype(this), const volatile X *>);
+ auto M = [*this]() mutable {
+ static_assert(is_same<decltype(this), X *>);
+ auto N = [this] {
+ static_assert(is_same<decltype(this), X *>);
+ auto M = [] {
+ static_assert(is_same<decltype(this), X *>);
+ };
+ };
+ auto N2 = [*this] {
+ static_assert(is_same<decltype(this), const X *>);
+ };
+ };
+ auto M2 = [*this]() {
+ static_assert(is_same<decltype(this), const X *>);
+ auto N = [this] {
+ static_assert(is_same<decltype(this), const X *>);
+ };
+ };
+ };
+ }
+};
+
+} // namespace ns5
+namespace ns6 {
+struct X {
+ double d;
+ auto foo() const {
+ auto L = [*this]() mutable {
+ auto M = [=](auto a) {
+ auto N = [this] {
+ ++d;
+ static_assert(is_same<decltype(this), X *>);
+ auto O = [*this] {
+ static_assert(is_same<decltype(this), const X *>);
+ };
+ };
+ N();
+ static_assert(is_same<decltype(this), X *>);
+ };
+ return M;
+ };
+ return L;
+ }
+};
+
+int main() {
+ auto L = X{}.foo();
+ auto M = L();
+ M(3.14);
+}
+} // namespace ns6
+namespace ns7 {
+
+struct X {
+ double d;
+ X();
+ X(const X &);
+ X(X &) = delete;
+ auto foo() const {
+ //OK - the object used to initialize our capture is a const object and so prefers the non-deleted ctor.
+ const auto &&L = [*this]{};
+ }
+};
+int main() {
+ X x;
+ x.foo();
+}
+} // namespace ns7
+
+} // namespace test_star_this
+
+namespace PR32831 {
+// https://bugs.llvm.org/show_bug.cgi?id=32831
+namespace ns1 {
+template <typename Func>
+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(); });
+ };
+ };
+ }
+};
+} // namespace ns1
+
+namespace ns2 {
+
+struct B {
+ int data = 0;
+ template <class F>
+ 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(); });
+ };
+ };
+ }
+ int data = 0;
+ auto m2() {
+ return [this] { return [] () -> decltype(data){ return 0; }; };
+ }
+ auto m3() {
+ return [] { return [] () -> decltype(data){ return 0; }; };
+ }
+};
+
+} // namespace ns2
+
+} // namespace PR32831
+
More information about the cfe-commits
mailing list