From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1888) id 299023857C43; Fri, 19 Nov 2021 13:54:49 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 299023857C43 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Patrick Palka To: gcc-cvs@gcc.gnu.org Subject: [gcc r12-5403] c++: nested lambda capturing a capture proxy [PR94376] X-Act-Checkin: gcc X-Git-Author: Patrick Palka X-Git-Refname: refs/heads/master X-Git-Oldrev: f316727e5f6a4c58b63bdee9ad6be785f97f5ee7 X-Git-Newrev: fd740165e54151ea794fca34904f5c2e2ea1dcda Message-Id: <20211119135449.299023857C43@sourceware.org> Date: Fri, 19 Nov 2021 13:54:49 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 19 Nov 2021 13:54:49 -0000 https://gcc.gnu.org/g:fd740165e54151ea794fca34904f5c2e2ea1dcda commit r12-5403-gfd740165e54151ea794fca34904f5c2e2ea1dcda Author: Patrick Palka Date: Fri Nov 19 08:54:25 2021 -0500 c++: nested lambda capturing a capture proxy [PR94376] Here when determining the type of the FIELD_DECL for the by-value capture of 'i' in the inner lambda, we incorrectly give it the type const int instead of int since the effective initializer is the proxy for the outer capture, and this proxy is const since the outer lambda is non-mutable. This patch fixes this by making lambda_capture_field_type handle by-value capturing of capture proxies specially, namely we instead consider the type of their FIELD_DECL which unlike the proxy has the true cv-quals of the captured entity. PR c++/94376 gcc/cp/ChangeLog: * lambda.c (lambda_capture_field_type): Simplify by handling the is_this case first. When capturing by-value a capture proxy, consider the type of the corresponding field instead. gcc/testsuite/ChangeLog: * g++.dg/cpp0x/lambda/lambda-nested9.C: New test. Diff: --- gcc/cp/lambda.c | 19 +++++++--- gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested9.C | 41 ++++++++++++++++++++++ 2 files changed, 56 insertions(+), 4 deletions(-) diff --git a/gcc/cp/lambda.c b/gcc/cp/lambda.c index f68c68ca16e..c39a2bca416 100644 --- a/gcc/cp/lambda.c +++ b/gcc/cp/lambda.c @@ -195,7 +195,9 @@ lambda_capture_field_type (tree expr, bool explicit_init_p, tree type; bool is_this = is_this_parameter (tree_strip_nop_conversions (expr)); - if (!is_this && explicit_init_p) + if (is_this) + type = TREE_TYPE (expr); + else if (explicit_init_p) { tree auto_node = make_auto (); @@ -209,7 +211,7 @@ lambda_capture_field_type (tree expr, bool explicit_init_p, else type = do_auto_deduction (type, expr, auto_node); } - else if (!is_this && type_dependent_expression_p (expr)) + else if (type_dependent_expression_p (expr)) { type = cxx_make_type (DECLTYPE_TYPE); DECLTYPE_TYPE_EXPR (type) = expr; @@ -219,10 +221,19 @@ lambda_capture_field_type (tree expr, bool explicit_init_p, } else { + if (!by_reference_p && is_capture_proxy (expr)) + { + /* When capturing by-value another capture proxy from an enclosing + lambda, consider the type of the corresponding field instead, + as the proxy may be additionally const-qualifed if the enclosing + lambda is non-mutable (PR94376). */ + gcc_assert (TREE_CODE (DECL_VALUE_EXPR (expr)) == COMPONENT_REF); + expr = TREE_OPERAND (DECL_VALUE_EXPR (expr), 1); + } + type = non_reference (unlowered_expr_type (expr)); - if (!is_this - && (by_reference_p || TREE_CODE (type) == FUNCTION_TYPE)) + if (by_reference_p || TREE_CODE (type) == FUNCTION_TYPE) type = build_reference_type (type); } diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested9.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested9.C new file mode 100644 index 00000000000..ff7da3b0ce1 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nested9.C @@ -0,0 +1,41 @@ +// PR c++/94376 +// { dg-do compile { target c++11 } } + +int main() { + // We used to incorrectly reject the first two cases. + int i = 0; + [=] () { + [=] () mutable { + ++i; + }; + }; + +#if __cpp_init_captures + [j=0] () { + [=] () mutable { + ++j; + }; + }; +#endif + + [=] () { + [&] () mutable { + ++i; // { dg-error "read-only" } + }; + }; + + const int j = 0; + [=] () { + [=] () mutable { + ++j; // { dg-error "read-only" } + }; + }; + +#if __cpp_init_captures + [j=0] () { + [&] () mutable { + ++j; // { dg-error "read-only" } + }; + }; +#endif +}