// capturing lamdbda's call operator.
//
- // 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.
+ // 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.
-
- // 1) Climb down the function scope info stack.
for (int I = FunctionScopes.size();
- I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
- (!CurLSI || CurLSI->Lambda->getDeclContext() ==
- cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
+ I-- && isa<LambdaScopeInfo>(FunctionScopes[I]);
CurDC = getLambdaAwareParentOfDeclContext(CurDC)) {
CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
return ASTCtx.getPointerType(ClassType);
}
}
-
- // 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)
+ // We've run out of ScopeInfos but check if CurDC is a lambda (which can
+ // happen during instantiation of generic lambdas)
if (isLambdaCallOperator(CurDC)) {
- 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(CurLSI);
+ assert(isGenericLambdaCallOperatorSpecialization(CurLSI->CallOperator));
assert(CurDC == getLambdaAwareParentOfDeclContext(CurLSI->CallOperator));
auto IsThisCaptured =
-// 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(); });
- };
- };
- }
-};
-
-} // namespace ns2
-
-} // namespace PR32831
-
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -emit-llvm-only %s\r
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING\r
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS\r
+// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING\r
+\r
+template<class, class> constexpr bool is_same = false;\r
+template<class T> constexpr bool is_same<T, T> = true;\r
+\r
+namespace test_star_this {\r
+namespace ns1 {\r
+class A {\r
+ int x = 345;\r
+ auto foo() {\r
+ (void) [*this, this] { }; //expected-error{{'this' can appear only once}}\r
+ (void) [this] { ++x; };\r
+ (void) [*this] { ++x; }; //expected-error{{read-only variable}}\r
+ (void) [*this] () mutable { ++x; };\r
+ (void) [=] { return x; };\r
+ (void) [&, this] { return x; };\r
+ (void) [=, *this] { return x; };\r
+ (void) [&, *this] { return x; };\r
+ }\r
+};\r
+} // end ns1\r
+\r
+namespace ns2 {\r
+ class B {\r
+ B(const B&) = delete; //expected-note{{deleted here}}\r
+ int *x = (int *) 456;\r
+ void foo() {\r
+ (void)[this] { return x; };\r
+ (void)[*this] { return x; }; //expected-error{{call to deleted}}\r
+ }\r
+ };\r
+} // end ns2\r
+namespace ns3 {\r
+ class B {\r
+ B(const B&) = delete; //expected-note2{{deleted here}}\r
+ \r
+ int *x = (int *) 456;\r
+ public: \r
+ template<class T = int>\r
+ void foo() {\r
+ (void)[this] { return x; };\r
+ (void)[*this] { return x; }; //expected-error2{{call to deleted}}\r
+ }\r
+ \r
+ B() = default;\r
+ } b;\r
+ B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}\r
+} // end ns3\r
+\r
+namespace ns4 {\r
+template<class U>\r
+class B {\r
+ B(const B&) = delete; //expected-note{{deleted here}}\r
+ double d = 3.14;\r
+ public: \r
+ template<class T = int>\r
+ auto foo() {\r
+ const auto &L = [*this] (auto a) mutable { //expected-error{{call to deleted}}\r
+ d += a; \r
+ return [this] (auto b) { return d +=b; }; \r
+ }; \r
+ }\r
+ \r
+ B() = default;\r
+};\r
+void main() {\r
+ B<int*> b;\r
+ b.foo(); //expected-note{{in instantiation}}\r
+} // end main \r
+} // end ns4\r
+namespace ns5 {\r
+\r
+struct X {\r
+ double d = 3.14;\r
+ X(const volatile X&);\r
+ void foo() {\r
+ \r
+ }\r
+ \r
+ void foo() const { //expected-note{{const}}\r
+ \r
+ auto L = [*this] () mutable { \r
+ static_assert(is_same<decltype(this), X*>);\r
+ ++d;\r
+ auto M = [this] { \r
+ static_assert(is_same<decltype(this), X*>); \r
+ ++d;\r
+ auto N = [] {\r
+ static_assert(is_same<decltype(this), X*>); \r
+ };\r
+ };\r
+ };\r
+ \r
+ auto L1 = [*this] { \r
+ static_assert(is_same<decltype(this), const X*>);\r
+ auto M = [this] () mutable { \r
+ static_assert(is_same<decltype(this), const X*>); \r
+ auto N = [] {\r
+ static_assert(is_same<decltype(this), const X*>); \r
+ };\r
+ };\r
+ auto M2 = [*this] () mutable { \r
+ static_assert(is_same<decltype(this), X*>); \r
+ auto N = [] {\r
+ static_assert(is_same<decltype(this), X*>); \r
+ };\r
+ };\r
+ };\r
+ \r
+ auto GL1 = [*this] (auto a) { \r
+ static_assert(is_same<decltype(this), const X*>);\r
+ auto M = [this] (auto b) mutable { \r
+ static_assert(is_same<decltype(this), const X*>); \r
+ auto N = [] (auto c) {\r
+ static_assert(is_same<decltype(this), const X*>); \r
+ };\r
+ return N;\r
+ };\r
+ \r
+ auto M2 = [*this] (auto a) mutable { \r
+ static_assert(is_same<decltype(this), X*>); \r
+ auto N = [] (auto b) {\r
+ static_assert(is_same<decltype(this), X*>); \r
+ };\r
+ return N;\r
+ };\r
+ return [=](auto a) mutable { M(a)(a); M2(a)(a); };\r
+ };\r
+ \r
+ GL1("abc")("abc");\r
+ \r
+ \r
+ auto L2 = [this] () mutable {\r
+ static_assert(is_same<decltype(this), const X*>); \r
+ ++d; //expected-error{{cannot assign}}\r
+ };\r
+ auto GL = [*this] (auto a) mutable {\r
+ static_assert(is_same<decltype(this), X*>);\r
+ ++d;\r
+ auto M = [this] (auto b) { \r
+ static_assert(is_same<decltype(this), X*>); \r
+ ++d;\r
+ auto N = [] (auto c) {\r
+ static_assert(is_same<decltype(this), X*>); \r
+ };\r
+ N(3.14);\r
+ };\r
+ M("abc");\r
+ };\r
+ GL(3.14);\r
+ \r
+ }\r
+ void foo() volatile const {\r
+ auto L = [this] () {\r
+ static_assert(is_same<decltype(this), const volatile X*>);\r
+ auto M = [*this] () mutable { \r
+ static_assert(is_same<decltype(this), X*>);\r
+ auto N = [this] {\r
+ static_assert(is_same<decltype(this), X*>);\r
+ auto M = [] {\r
+ static_assert(is_same<decltype(this), X*>);\r
+ };\r
+ };\r
+ auto N2 = [*this] {\r
+ static_assert(is_same<decltype(this), const X*>);\r
+ };\r
+ };\r
+ auto M2 = [*this] () {\r
+ static_assert(is_same<decltype(this), const X*>); \r
+ auto N = [this] {\r
+ static_assert(is_same<decltype(this), const X*>);\r
+ };\r
+ };\r
+ };\r
+ }\r
+ \r
+};\r
+\r
+} //end ns5\r
+namespace ns6 {\r
+struct X {\r
+ double d;\r
+ auto foo() const {\r
+ auto L = [*this] () mutable {\r
+ auto M = [=] (auto a) {\r
+ auto N = [this] {\r
+ ++d;\r
+ static_assert(is_same<decltype(this), X*>);\r
+ auto O = [*this] {\r
+ static_assert(is_same<decltype(this), const X*>);\r
+ };\r
+ };\r
+ N();\r
+ static_assert(is_same<decltype(this), X*>);\r
+ };\r
+ return M;\r
+ };\r
+ return L;\r
+ }\r
+}; \r
+\r
+int main() {\r
+ auto L = X{}.foo();\r
+ auto M = L();\r
+ M(3.14);\r
+}\r
+} // end ns6\r
+namespace ns7 {\r
+\r
+struct X {\r
+ double d;\r
+ X();\r
+ X(const X&); \r
+ X(X&) = delete;\r
+ auto foo() const {\r
+ //OK - the object used to initialize our capture is a const object and so prefers the non-deleted ctor.\r
+ const auto &&L = [*this] { };\r
+ }\r
+ \r
+}; \r
+int main() {\r
+ X x;\r
+ x.foo();\r
+}\r
+} // end ns7\r
+\r
+} //end ns test_star_this\r
+\r
projects / clang / commitdiff