forked from OSchip/llvm-project
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. llvm-svn: 301972
This commit is contained in:
Faisal Vali
parent
c7695a8e45
commit
999f27e373
|
|
@ -901,17 +901,36 @@ 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) 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 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 =
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue