On Thu, Jul 10, 2025 at 02:13:06PM -0400, Jason Merrill wrote:
> On 7/9/25 4:27 PM, Marek Polacek wrote:
> > On Tue, Jul 08, 2025 at 12:15:03PM -0400, Jason Merrill wrote:
> > > On 7/7/25 4:52 PM, Marek Polacek wrote:
> > > > Bootstrapped/regtested on x86_64-pc-linux-gnu, ok for trunk?
> > > >
> > > > -- >8 --
> > > > This patch is an attempt to implement P2036R3 along with P2579R0, fixing
> > > > build breakages caused by P2036R3.
> > > >
> > > > The simplest example is:
> > > >
> > > > auto counter1 = [j=0]() mutable -> decltype(j) {
> > > > return j++;
> > > > };
> > > >
> > > > which currently doesn't compile because the 'j' in the capture isn't
> > > > visible in the trailing return type. With these proposals, the 'j'
> > > > will be in a lambda scope which spans the trailing return type, so
> > > > this test will compile.
> > > >
> > > > This oughtn't be difficult but decltype and other issues made this patch
> > > > much more challenging.
> > > >
> > > > We have to push the explicit captures before going into
> > > > _lambda_declarator_opt
> > > > because that is what parses the trailing return type. Yet we can't
> > > > build
> > > > any captures until after _lambda_body -> start_lambda_function which
> > > > creates the lambda's operator(), without which we can't build a proxy,
> > > > but _lambda_body happens only after parsing the declarator. This patch
> > > > works around it by creating a fake operator() in make_dummy_lambda_op.
> > >
> > > I was thinking that we could build the real operator() earlier, before the
> > > trailing return type, so that it's there for the above uses, and then
> > > splice
> > > in the trailing return type to the already-built function declaration,
> > > perhaps with apply_deduced_return_type.
> >
> > Ah, I see what you mean. But it's not just the return type that we don't
> > have at the point where we have to have the operator(): it's also tx_qual,
> > exception_spec, std_attrs, and trailing_requires_clause. Especially the
> > requires clause seems to be awkward to set post grokmethod; it seems I'd
> > have to replicate the flag_concepts block in grokfndecl?
> >
> > Maybe I could add (by that I mean add it to the lambda via
> > finish_member_declaration) a bare bones operator() for the purposes of
> > parsing the return type/noexcept/requires, then after parsing them
> > construct a real operator(), then find a slot of the bare bones op(),
> > and replace it with the complete one. I'm not sure if that makes sense
> > to do though.
>
> I was hoping to avoid building more than one op(). But really, why do you
> need an op() at all for building the proxies? Could you use
> build_dummy_object instead of DECL_ARGUMENTS of some fake op()?
The problem is that we need operator() to be the var's DECL_CONTEXT
for is_capture_proxy:
&& LAMBDA_FUNCTION_P (DECL_CONTEXT (decl)));
> > > > Another thing is that in "-> decltype(j)" we don't have the right
> > > > current_function_decl yet, so I've added the in_lambda_declarator_p flag
> > > > to be used in finish_decltype_type so that we know this decltype
> > > > appertains
> > > > to a lambda -- then current_lambda_expr should give us the right lambda,
> > > > which has another new flag tracking whether mutable was seen.
>
> The flag to finish_decltype_type seems unneeded; we should be able to tell
> from the proxy that it belongs to a lambda. And I would think that the new
> handling in finish_decltype_type seems right in general; always refer to
> current_lambda_expr instead of current_function_decl, etc.
Good point. I've removed the flag and simplified the patch quite a bit.
However:
- to honor [expr.prim.id.unqual]/4, I have to know if the decltype is
in the lambda's parameter-declaration-clause or not:
[=]() -> decltype((x)) // float const&
[=](decltype((x)) y) // float&
so I'm using LAMBDA_EXPR_CONST_QUAL_P for that.
- if we want to handle nested lambdas correctly:
[=](decltype((x)) y) {} // float&
[=] {
[](decltype((x)) y) {}; // float const&
}
we probably will need a new flag for decltype.
> > @@ -3351,8 +3351,12 @@ check_local_shadow (tree decl)
> > }
> > /* Don't complain if it's from an enclosing function. */
> > else if (DECL_CONTEXT (old) == current_function_decl
> > - && TREE_CODE (decl) != PARM_DECL
> > - && TREE_CODE (old) == PARM_DECL)
> > + && ((TREE_CODE (decl) != PARM_DECL
> > + && TREE_CODE (old) == PARM_DECL)
> > + || (is_capture_proxy (old)
> > + && current_lambda_expr ()
> > + && DECL_CONTEXT (old)
> > + == lambda_function (current_lambda_expr ()))))
>
> What case is this handling? Doesn't the previous if already deal with
> parm/capture collision?
The proposal says that
[x=1]{ int x; }
is invalid, so I wanted to give an error for it. But since -Wshadow
warns for the case above, I've dropped that hunk and that simplifies
the patch even more.
> > @@ -287,7 +288,7 @@ struct GTY(()) cp_binding_level {
> > /* The kind of scope that this object represents. However, a
> > SK_TEMPLATE_SPEC scope is represented with KIND set to
> > SK_TEMPLATE_PARMS and EXPLICIT_SPEC_P set to true. */
> > - ENUM_BITFIELD (scope_kind) kind : 4;
> > + ENUM_BITFIELD (scope_kind) kind : 5;
> > /* True if this scope is an SK_TEMPLATE_SPEC scope. This field is
> > only valid if KIND == SK_TEMPLATE_PARMS. */
>
> You also need to adjust the count of available bits.
Oop, fixed.
> > @@ -11807,6 +11807,9 @@ cp_parser_lambda_expression (cp_parser* parser)
> > if (type == error_mark_node)
> > return error_mark_node;
> > + /* A lambda scope starts immediately after the lambda-introducer of E
> > + and extends to the end of the compound-statement of E. */
> > + begin_scope (sk_lambda, NULL_TREE);
> > record_lambda_scope (lambda_expr);
> > record_lambda_scope_discriminator (lambda_expr);
>
> I would put the begin_scope after the record_lambda_scope*, since the latter
> are about the enclosing scope.
OK.
> > @@ -11857,6 +11860,10 @@ cp_parser_lambda_expression (cp_parser* parser)
> > if (cp_parser_start_tentative_firewall (parser))
> > start = token;
> > + /* Inject the captures for the sake of the possible
> > + trailing-return-type -- we have to be able to look them up. */
> > + push_capture_proxies (lambda_expr);
>
> ...maybe this far after, since the proxies are what live in the lambda
> scope?
Done.
Here's what I have now. Thanks,
Bootstrapped/regtested on x86_64-pc-linux-gnu.
-- >8 --
This patch is an attempt to implement P2036R3 along with P2579R0, fixing
build breakages caused by P2036R3.
The simplest example is:
auto counter1 = [j=0]() mutable -> decltype(j) {
return j++;
};
which currently doesn't compile because the 'j' in the capture isn't
visible in the trailing return type. With these proposals, the 'j'
will be in a lambda scope which spans the trailing return type, so
this test will compile.
This oughtn't be difficult but decltype and other issues made this patch
much more challenging.
We have to push the explicit captures before going into _lambda_declarator_opt
because that is what parses the trailing return type. Yet we can't build
any captures until after _lambda_body -> start_lambda_function which
creates the lambda's operator(), without which we can't build a proxy,
but _lambda_body happens only after parsing the declarator. This patch
works around it by creating a fake operator() in make_dummy_lambda_op.
Another thing is that in "-> decltype(j)" we don't have the right
current_function_decl yet. If current_lambda_expr gives us a lambda,
we know this decltype appertains to a lambda. But we have to know if we
are in a parameter-declaration-clause: as per [expr.prim.id.unqual]/4.4,
if we are, we shouldn't be adding "const". The new LAMBDA_EXPR_CONST_QUAL_P
flag tracks this. But it doesn't handle nested lambdas yet, specifically,
[expr.prim.id.unqual]/14.
I don't think this patch changes behavior for the tests in
"capture-default with [=]" as the paper promises; clang++ behaves the
same as gcc with this patch.
PR c++/102610
gcc/cp/ChangeLog:
* cp-tree.h (LAMBDA_EXPR_CONST_QUAL_P): Define.
(make_dummy_lambda_op): Declare.
(push_capture_proxies): Declare.
* lambda.cc (build_capture_proxy): No longer static. If we do not have
the operator() yet, build up a fake one.
(push_capture_proxies): New.
(start_lambda_function): Use it.
* name-lookup.cc (cp_binding_level_descriptor): Add lambda-scope.
(begin_scope) <case sk_lambda>: New case.
* name-lookup.h (enum scope_kind): Add sk_lambda.
(struct cp_binding_level): Widen kind.
* parser.cc (cp_parser_lambda_expression): Create a new (lambda) scope
after the lambda-introducer. Push the capture proxies.
(cp_parser_lambda_declarator_opt): Set LAMBDA_EXPR_CONST_QUAL_P.
(make_dummy_lambda_op): New.
* pt.cc (tsubst_lambda_expr): Begin/end a lambda scope. Push the
capture proxies.
* semantics.cc (automatic_var_p): New.
(finish_decltype_type): Use current_lambda_expr. Look at
LAMBDA_EXPR_CONST_QUAL_P if we don't have the relevant
current_function_decl yet.
gcc/testsuite/ChangeLog:
* g++.dg/cpp0x/lambda/lambda-decltype3.C: Remove xfail.
* g++.dg/cpp23/lambda-scope1.C: New test.
* g++.dg/cpp23/lambda-scope2.C: New test.
* g++.dg/cpp23/lambda-scope3.C: New test.
* g++.dg/cpp23/lambda-scope4.C: New test.
* g++.dg/cpp23/lambda-scope4b.C: New test.
* g++.dg/cpp23/lambda-scope5.C: New test.
* g++.dg/cpp23/lambda-scope6.C: New test.
* g++.dg/cpp23/lambda-scope7.C: New test.
* g++.dg/cpp23/lambda-scope8.C: New test.
---
gcc/cp/cp-tree.h | 10 +
gcc/cp/lambda.cc | 32 ++-
gcc/cp/name-lookup.cc | 4 +-
gcc/cp/name-lookup.h | 5 +-
gcc/cp/parser.cc | 47 ++++
gcc/cp/pt.cc | 7 +
gcc/cp/semantics.cc | 50 ++--
.../g++.dg/cpp0x/lambda/lambda-decltype3.C | 2 +-
gcc/testsuite/g++.dg/cpp23/lambda-scope1.C | 82 +++++++
gcc/testsuite/g++.dg/cpp23/lambda-scope2.C | 217 ++++++++++++++++++
gcc/testsuite/g++.dg/cpp23/lambda-scope3.C | 44 ++++
gcc/testsuite/g++.dg/cpp23/lambda-scope4.C | 41 ++++
gcc/testsuite/g++.dg/cpp23/lambda-scope4b.C | 42 ++++
gcc/testsuite/g++.dg/cpp23/lambda-scope5.C | 22 ++
gcc/testsuite/g++.dg/cpp23/lambda-scope6.C | 20 ++
gcc/testsuite/g++.dg/cpp23/lambda-scope7.C | 20 ++
gcc/testsuite/g++.dg/cpp23/lambda-scope8.C | 25 ++
17 files changed, 645 insertions(+), 25 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope1.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope2.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope3.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope4.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope4b.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope5.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope6.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope7.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/lambda-scope8.C
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 5708aa13a48..3df09733712 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -474,6 +474,7 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX];
ATOMIC_CONSTR_EXPR_FROM_CONCEPT_P (in ATOMIC_CONSTR)
STATIC_INIT_DECOMP_BASE_P (in the TREE_LIST for {static,tls}_aggregates)
MUST_NOT_THROW_THROW_P (in MUST_NOT_THROW_EXPR)
+ LAMBDA_EXPR_CONST_QUAL_P (in LAMBDA_EXPR)
2: IDENTIFIER_KIND_BIT_2 (in IDENTIFIER_NODE)
ICS_THIS_FLAG (in _CONV)
DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (in VAR_DECL)
@@ -1547,6 +1548,13 @@ enum cp_lambda_default_capture_mode_type {
#define LAMBDA_EXPR_THIS_CAPTURE(NODE) \
(((struct tree_lambda_expr *)LAMBDA_EXPR_CHECK (NODE))->this_capture)
+/* True if we should add "const" when figuring out the type of an entity
+ in a lambda. This is false in the parameter-declaration-clause of
+ a lambda; after that, it will remain false if the mutable keyword is
+ present. */
+#define LAMBDA_EXPR_CONST_QUAL_P(NODE) \
+ TREE_LANG_FLAG_1 (LAMBDA_EXPR_CHECK (NODE))
+
/* True iff uses of a const variable capture were optimized away. */
#define LAMBDA_EXPR_CAPTURE_OPTIMIZED(NODE) \
TREE_LANG_FLAG_2 (LAMBDA_EXPR_CHECK (NODE))
@@ -7758,6 +7766,7 @@ extern location_t defparse_location (tree);
extern void maybe_show_extern_c_location (void);
extern bool literal_integer_zerop (const_tree);
extern tree attr_chainon (tree, tree);
+extern tree make_dummy_lambda_op ();
/* in pt.cc */
extern tree canonical_type_parameter (tree);
@@ -8285,6 +8294,7 @@ extern void record_lambda_scope (tree
lambda);
extern void record_lambda_scope_discriminator (tree lambda);
extern void record_lambda_scope_sig_discriminator (tree lambda, tree fn);
extern tree start_lambda_function (tree fn, tree lambda_expr);
+extern void push_capture_proxies (tree);
extern void finish_lambda_function (tree body);
extern bool regenerated_lambda_fn_p (tree);
extern tree lambda_regenerating_args (tree);
diff --git a/gcc/cp/lambda.cc b/gcc/cp/lambda.cc
index 525e8ef4b34..28740d3c71e 100644
--- a/gcc/cp/lambda.cc
+++ b/gcc/cp/lambda.cc
@@ -409,9 +409,10 @@ lambda_proxy_type (tree ref)
/* MEMBER is a capture field in a lambda closure class. Now that we're
inside the operator(), build a placeholder var for future lookups and
- debugging. */
+ debugging. Except that if we're called from push_capture_proxies, we
+ do not have the operator() yet, and have to build up a fake one. */
-static tree
+tree
build_capture_proxy (tree member, tree init)
{
tree var, object, fn, closure, name, lam, type;
@@ -422,6 +423,9 @@ build_capture_proxy (tree member, tree init)
closure = DECL_CONTEXT (member);
fn = lambda_function (closure);
lam = CLASSTYPE_LAMBDA_EXPR (closure);
+ const bool early_p = (fn == NULL_TREE);
+ if (early_p)
+ fn = make_dummy_lambda_op ();
object = DECL_ARGUMENTS (fn);
/* The proxy variable forwards to the capture field. */
@@ -503,11 +507,19 @@ build_capture_proxy (tree member, tree init)
if (name == this_identifier)
{
+ if (early_p)
+ return var;
gcc_assert (LAMBDA_EXPR_THIS_CAPTURE (lam) == member);
LAMBDA_EXPR_THIS_CAPTURE (lam) = var;
}
- if (fn == current_function_decl)
+ if (early_p)
+ {
+ gcc_checking_assert (current_binding_level->kind == sk_lambda);
+ /* insert_capture_proxy below wouldn't push into the lambda scope. */
+ pushdecl (var);
+ }
+ else if (fn == current_function_decl)
insert_capture_proxy (var);
else
vec_safe_push (LAMBDA_EXPR_PENDING_PROXIES (lam), var);
@@ -1776,6 +1788,16 @@ record_lambda_scope_sig_discriminator (tree lambda, tree
fn)
LAMBDA_EXPR_SCOPE_SIG_DISCRIMINATOR (lambda) = sig->count++;
}
+/* Push the proxies for any explicit captures in LAMBDA_EXPR. */
+
+void
+push_capture_proxies (tree lambda_expr)
+{
+ for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap;
+ cap = TREE_CHAIN (cap))
+ build_capture_proxy (TREE_PURPOSE (cap), TREE_VALUE (cap));
+}
+
tree
start_lambda_function (tree fco, tree lambda_expr)
{
@@ -1788,9 +1810,7 @@ start_lambda_function (tree fco, tree lambda_expr)
tree body = begin_function_body ();
/* Push the proxies for any explicit captures. */
- for (tree cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap;
- cap = TREE_CHAIN (cap))
- build_capture_proxy (TREE_PURPOSE (cap), TREE_VALUE (cap));
+ push_capture_proxies (lambda_expr);
return body;
}
diff --git a/gcc/cp/name-lookup.cc b/gcc/cp/name-lookup.cc
index 9aa7c16f64b..6019400e104 100644
--- a/gcc/cp/name-lookup.cc
+++ b/gcc/cp/name-lookup.cc
@@ -4635,7 +4635,8 @@ cp_binding_level_descriptor (cp_binding_level *scope)
"template-parameter-scope",
"template-explicit-spec-scope",
"transaction-scope",
- "openmp-scope"
+ "openmp-scope",
+ "lambda-scope"
};
static_assert (ARRAY_SIZE (scope_kind_names) == sk_count,
"must keep names aligned with scope_kind enum");
@@ -4726,6 +4727,7 @@ begin_scope (scope_kind kind, tree entity)
case sk_transaction:
case sk_omp:
case sk_stmt_expr:
+ case sk_lambda:
scope->keep = keep_next_level_flag;
break;
diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h
index 2fa736bd046..4acee3f86f4 100644
--- a/gcc/cp/name-lookup.h
+++ b/gcc/cp/name-lookup.h
@@ -214,6 +214,7 @@ enum scope_kind {
"template <>", this scope is always empty. */
sk_transaction, /* A synchronized or atomic statement. */
sk_omp, /* An OpenMP structured block. */
+ sk_lambda, /* A lambda scope. */
sk_count /* Number of scope_kind enumerations. */
};
@@ -287,7 +288,7 @@ struct GTY(()) cp_binding_level {
/* The kind of scope that this object represents. However, a
SK_TEMPLATE_SPEC scope is represented with KIND set to
SK_TEMPLATE_PARMS and EXPLICIT_SPEC_P set to true. */
- ENUM_BITFIELD (scope_kind) kind : 4;
+ ENUM_BITFIELD (scope_kind) kind : 5;
/* True if this scope is an SK_TEMPLATE_SPEC scope. This field is
only valid if KIND == SK_TEMPLATE_PARMS. */
@@ -315,7 +316,7 @@ struct GTY(()) cp_binding_level {
parent scope. */
unsigned artificial : 1;
- /* 21 bits left to fill a 32-bit word. */
+ /* 20 bits left to fill a 32-bit word. */
};
/* The binding level currently in effect. */
diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index 0d9ed2ea82b..d238ecc3432 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -11868,6 +11868,14 @@ cp_parser_lambda_expression (cp_parser* parser)
if (cp_parser_start_tentative_firewall (parser))
start = token;
+ /* A lambda scope starts immediately after the lambda-introducer of E
+ and extends to the end of the compound-statement of E. */
+ begin_scope (sk_lambda, NULL_TREE);
+
+ /* Inject the captures for the sake of the possible
+ trailing-return-type -- we have to be able to look them up. */
+ push_capture_proxies (lambda_expr);
+
ok &= cp_parser_lambda_declarator_opt (parser, lambda_expr);
if (ok && cp_parser_error_occurred (parser))
@@ -11888,6 +11896,8 @@ cp_parser_lambda_expression (cp_parser* parser)
if (ok)
maybe_add_lambda_conv_op (type);
+ /* Leave the lambda scope. */
+ pop_bindings_and_leave_scope ();
finish_struct (type, /*attributes=*/NULL_TREE);
in_consteval_if_p = save_in_consteval_if_p;
@@ -12275,6 +12285,8 @@ cp_parser_lambda_declarator_opt (cp_parser* parser,
tree lambda_expr)
clear_decl_specs (&lambda_specs);
/* A lambda op() is const unless explicitly 'mutable'. */
cp_cv_quals quals = TYPE_QUAL_CONST;
+ /* Don't add "const" to entities in the parameter-declaration-clause. */
+ LAMBDA_EXPR_CONST_QUAL_P (lambda_expr) = false;
/* The template-parameter-list is optional, but must begin with
an opening angle if present. */
@@ -12453,6 +12465,10 @@ cp_parser_lambda_declarator_opt (cp_parser* parser,
tree lambda_expr)
}
}
+ /* Now we're done with the parameter-declaration-clause, and should
+ assume "const" unless "mutable" was present. */
+ LAMBDA_EXPR_CONST_QUAL_P (lambda_expr) = quals == TYPE_QUAL_CONST;
+
tx_qual = cp_parser_tx_qualifier_opt (parser);
if (omitted_parms_loc && tx_qual)
{
@@ -12589,6 +12605,37 @@ cp_parser_lambda_declarator_opt (cp_parser* parser,
tree lambda_expr)
}
}
+/* Create a fake operator() for a lambda. We do this so that we can
+ build_capture_proxy even before start_lambda_function. */
+
+tree
+make_dummy_lambda_op ()
+{
+ cp_decl_specifier_seq return_type_specs;
+ cp_cv_quals quals = TYPE_UNQUALIFIED;
+
+ clear_decl_specs (&return_type_specs);
+ return_type_specs.type = make_auto ();
+
+ void *p = obstack_alloc (&declarator_obstack, 0);
+
+ cp_declarator *declarator = make_id_declarator (NULL_TREE,
+ call_op_identifier,
+ sfk_none,
+ input_location);
+
+ declarator = make_call_declarator (declarator, void_list_node, quals,
+ VIRT_SPEC_UNSPECIFIED,
+ REF_QUAL_NONE, NULL_TREE,
+ NULL_TREE, NULL_TREE, NULL_TREE,
+ NULL_TREE, UNKNOWN_LOCATION);
+
+ tree fco = grokmethod (&return_type_specs, declarator, NULL_TREE);
+ obstack_free (&declarator_obstack, p);
+
+ return fco;
+}
+
/* Parse the body of a lambda expression, which is simply
compound-statement
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index ca8d61dbca1..cc1debcb974 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -20479,6 +20479,12 @@ tsubst_lambda_expr (tree t, tree args, tsubst_flags_t
complain, tree in_decl)
tree fntype = static_fn_type (oldfn);
+ begin_scope (sk_lambda, NULL_TREE);
+
+ /* Like in cp_parser_lambda_expression, we need to bring the captures
+ into the lambda scope. */
+ push_capture_proxies (r);
+
tree saved_ctp = current_template_parms;
if (oldtmpl)
{
@@ -20594,6 +20600,7 @@ tsubst_lambda_expr (tree t, tree args, tsubst_flags_t
complain, tree in_decl)
}
out:
+ pop_bindings_and_leave_scope ();
finish_struct (type, /*attr*/NULL_TREE);
insert_pending_capture_proxies ();
diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index 77fac458ec8..cab5046bf38 100644
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -4509,6 +4509,14 @@ outer_automatic_var_p (tree decl)
&& !TREE_STATIC (decl));
}
+/* Returns true iff DECL is an automatic variable. */
+
+static bool
+automatic_var_p (tree decl)
+{
+ return VAR_P (decl) && !TREE_STATIC (decl);
+}
+
/* DECL satisfies outer_automatic_var_p. Possibly complain about it or
rewrite it for lambda capture.
@@ -12887,9 +12895,12 @@ finish_decltype_type (tree expr, bool
id_expression_or_member_access_p,
}
else
{
- if (outer_automatic_var_p (STRIP_REFERENCE_REF (expr))
- && current_function_decl
- && LAMBDA_FUNCTION_P (current_function_decl))
+ const bool cfun_is_lambda_p
+ = (current_function_decl && LAMBDA_FUNCTION_P (current_function_decl));
+ if ((outer_automatic_var_p (STRIP_REFERENCE_REF (expr))
+ && cfun_is_lambda_p)
+ || (automatic_var_p (STRIP_REFERENCE_REF (expr))
+ && current_lambda_expr ()))
{
/* [expr.prim.id.unqual]/3: If naming the entity from outside of an
unevaluated operand within S would refer to an entity captured by
@@ -12907,7 +12918,7 @@ finish_decltype_type (tree expr, bool
id_expression_or_member_access_p,
And we don't handle nested lambdas properly, where we need to
consider the outer lambdas as well (PR112926). */
tree decl = STRIP_REFERENCE_REF (expr);
- tree lam = CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT
(current_function_decl));
+ tree lam = current_lambda_expr ();
tree cap = lookup_name (DECL_NAME (decl), LOOK_where::BLOCK,
LOOK_want::HIDDEN_LAMBDA);
@@ -12923,17 +12934,26 @@ finish_decltype_type (tree expr, bool
id_expression_or_member_access_p,
if (type && !TYPE_REF_P (type))
{
- tree obtype = TREE_TYPE (DECL_ARGUMENTS (current_function_decl));
- if (WILDCARD_TYPE_P (non_reference (obtype)))
- /* We don't know what the eventual obtype quals will be. */
- goto dependent;
- auto direct_type = [](tree t){
- if (INDIRECT_TYPE_P (t))
- return TREE_TYPE (t);
- return t;
- };
- int const quals = cp_type_quals (type)
- | cp_type_quals (direct_type (obtype));
+ int quals;
+ if (cfun_is_lambda_p)
+ {
+ tree obtype = TREE_TYPE (DECL_ARGUMENTS
(current_function_decl));
+ if (WILDCARD_TYPE_P (non_reference (obtype)))
+ /* We don't know what the eventual obtype quals will be. */
+ goto dependent;
+ auto direct_type = [](tree t){
+ if (INDIRECT_TYPE_P (t))
+ return TREE_TYPE (t);
+ return t;
+ };
+ quals = (cp_type_quals (type)
+ | cp_type_quals (direct_type (obtype)));
+ }
+ else
+ /* We are in the parameter clause, trailing return type, or
+ the requires clause and have no relevant c_f_decl yet. */
+ quals = (LAMBDA_EXPR_CONST_QUAL_P (lam)
+ ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED);
type = cp_build_qualified_type (type, quals);
type = build_reference_type (type);
}
diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-decltype3.C
b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-decltype3.C
index 2e06e496140..6ba0dabc37d 100644
--- a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-decltype3.C
+++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-decltype3.C
@@ -11,7 +11,7 @@ void f() {
decltype((x)) y2 = y1; // y2 has type float const&
decltype(r) r1 = y1; // r1 has type float&
decltype((r)) r2 = y2; // r2 has type float const&
- return y2; // { dg-bogus "'float&' to 'const float'" "" {
xfail *-*-* } }
+ return y2; // { dg-bogus "'float&' to 'const float'" }
};
[=](decltype((x)) y) {
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope1.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope1.C
new file mode 100644
index 00000000000..690463da92d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope1.C
@@ -0,0 +1,82 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++23 } }
+
+template <typename T, typename U>
+constexpr bool is_same = false;
+
+template <typename T>
+constexpr bool is_same<T, T> = true;
+
+struct S {
+ void foo () {
+ auto counter1 = [j=0]() mutable -> decltype(j) {
+ return j++;
+ };
+ }
+};
+
+// [expr.prim.id.unqual]/3.2
+void
+f ()
+{
+ float x, &r = x;
+
+ [=]() -> decltype((x)) { // lambda returns float const& because this
lambda is not mutable and
+ // x is an lvalue
+ decltype(x) y1; // y1 has type float
+ decltype((x)) y2 = y1; // y2 has type float const&
+ decltype(r) r1 = y1; // r1 has type float&
+ decltype((r)) r2 = y2; // r2 has type float const&
+ return y2;
+ };
+
+ [=](decltype((x)) y) {
+ decltype((x)) z = x; // OK, y has type float&, z has type float
const&
+ static_assert(is_same<float&, decltype((y))>);
+ static_assert(is_same<const float&, decltype((z))>);
+ };
+
+ [=] {
+ [](decltype((x)) y) { // OK, lambda takes a parameter of type float
const&
+ };
+
+ [x=1](decltype((x)) y) {
+ decltype((x)) z = x; // OK, y has type int&, z has type int const&
+ // FIXME We don't handle nested lambdas yet?
+ //static_assert(is_same<int&, decltype((y))>);
+ static_assert(is_same<const int&, decltype((z))>);
+ };
+ };
+
+ [x=1](decltype((x)) y) {
+ decltype((x)) z = x;
+ static_assert(is_same<int&, decltype((y))>);
+ static_assert(is_same<const int&, decltype((z))>);
+ };
+}
+
+void
+ok ()
+{
+ auto counter1 = [j=0]() mutable -> decltype(j) {
+ static_assert(is_same<int&, decltype((j))>);
+ return j++;
+ };
+
+ auto l = [j=0]() -> decltype(j) {
+ static_assert(is_same<const int&, decltype((j))>);
+ return j;
+ };
+
+ int y;
+ [=] -> decltype((y)) {
+ return y;
+ };
+}
+
+void
+foo ()
+{
+ int x = [x](int y[sizeof x]){return sizeof x;}(0);
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope2.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope2.C
new file mode 100644
index 00000000000..6b55e5fe513
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope2.C
@@ -0,0 +1,217 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++23 } }
+// From LLVM's test/SemaCXX/lambda-capture-type-deduction.cpp
+
+template <typename T, typename U>
+constexpr bool is_same = false;
+
+template <typename T>
+constexpr bool is_same<T, T> = true;
+
+void
+f ()
+{
+ int y;
+
+ static_assert(is_same<const int &,
+ decltype([x = 1] -> decltype((x)) { return x; }())>);
+
+ static_assert(is_same<int &,
+ decltype([x = 1] mutable -> decltype((x)) { return x;
}())>);
+
+ static_assert(is_same<const int &,
+ decltype([=] -> decltype((y)) { return y; }())>);
+
+ static_assert(is_same<int &,
+ decltype([=] mutable -> decltype((y)) { return y;
}())>);
+
+ // Clang++ rejects this one, though the only difference is the extra (),
+ // and without the () the result is correct, as demonstrated above.
+ static_assert(is_same<const int &,
+ decltype([=]() -> decltype((y)) { return y; }())>);
+
+ static_assert(is_same<int &,
+ decltype([=]() mutable -> decltype((y)) { return y;
}())>);
+
+ static_assert(is_same<const int &,
+ decltype([y] -> decltype((y)) { return y; }())>);
+
+ static_assert(is_same<int &,
+ decltype([y] mutable -> decltype((y)) { return y;
}())>);
+
+
+ auto ref = [&x = y](
+ decltype([&](decltype(x)) { return 0; }) y) {
+ return x;
+ };
+}
+
+void
+nested ()
+{
+ int x, y, z;
+ (void)[&](
+ decltype([&](
+ decltype([=](
+ decltype([&](
+ decltype([&](decltype(x)) {}))
{})) {})) {})){};
+
+ (void)[&](
+ decltype([&](
+ decltype([&](
+ decltype([&](
+ decltype([&](decltype(y)) {}))
{})) {})) {})){};
+
+ (void)[=](
+ decltype([=](
+ decltype([=](
+ decltype([=](
+ decltype([&]<decltype(z)> {}))
{})) {})) {})){};
+}
+
+void
+test_noexcept ()
+{
+ int y;
+
+ static_assert(noexcept([x = 1] noexcept(is_same<const int &, decltype((x))>)
{}()));
+ static_assert(noexcept([x = 1] mutable noexcept(is_same<int &,
decltype((x))>) {}()));
+ static_assert(noexcept([y] noexcept(is_same<const int &, decltype((y))>)
{}()));
+ static_assert(noexcept([y] mutable noexcept(is_same<int &, decltype((y))>)
{}()));
+ static_assert(noexcept([=] noexcept(is_same<const int &, decltype((y))>)
{}()));
+ static_assert(noexcept([=] mutable noexcept(is_same<int &, decltype((y))>)
{}()));
+ static_assert(noexcept([&] noexcept(is_same<int &, decltype((y))>) {}()));
+ static_assert(noexcept([&] mutable noexcept(is_same<int &, decltype((y))>)
{}()));
+}
+
+void
+check_params ()
+{
+ int i = 0;
+ int &j = i;
+
+ [=](decltype((j)) jp, decltype((i)) ip) {
+ static_assert(is_same<const int&, decltype((j))>);
+ static_assert(is_same<const int &, decltype((i))>);
+ static_assert(is_same<int &, decltype((jp))>);
+ static_assert(is_same<int &, decltype((ip))>);
+ };
+
+ [=](decltype((j)) jp, decltype((i)) ip) mutable {
+ static_assert(is_same<int &, decltype((j))>);
+ static_assert(is_same<int &, decltype((i))>);
+ static_assert(is_same<int &, decltype((jp))>);
+ static_assert(is_same<int &, decltype((ip))>);
+ static_assert(is_same<int &, decltype(jp)>);
+ static_assert(is_same<int &, decltype(ip)>);
+ };
+
+ [a = 0](decltype((a)) ap) mutable {
+ static_assert(is_same<int &, decltype((a))>);
+ static_assert(is_same<int, decltype(a)>);
+ static_assert(is_same<int &, decltype(ap)>);
+ decltype(a) x;
+ decltype((a)) y = x;
+ static_assert(is_same<int &, decltype(y)>);
+ };
+
+ [a = 0](decltype((a)) ap) {
+ static_assert(is_same<const int &, decltype((a))>);
+ static_assert(is_same<int, decltype(a)>);
+ static_assert(is_same<int&, decltype((ap))>);
+ decltype(a) x;
+ decltype((a)) y = x;
+ static_assert(is_same<const int &, decltype(y)>);
+ };
+
+ int a;
+ [a](decltype((a)) ap) mutable {
+ static_assert(is_same<int &, decltype((a))>);
+ static_assert(is_same<int, decltype(a)>);
+ static_assert(is_same<int &, decltype(ap)>);
+ decltype(a) x;
+ decltype((a)) y = x;
+ static_assert(is_same<int &, decltype(y)>);
+ };
+
+ [a](decltype((a)) ap) {
+ static_assert(is_same<const int &, decltype((a))>);
+ static_assert(is_same<int, decltype(a)>);
+ static_assert(is_same<int&, decltype((ap))>);
+ decltype(a) x;
+ decltype((a)) y = x;
+ static_assert(is_same<const int &, decltype(y)>);
+ };
+}
+
+template <typename T>
+void
+check_params_tpl ()
+{
+ T i = 0;
+ T &j = i;
+ (void)[=](decltype((j)) jp, decltype((i)) ip) {
+ static_assert(is_same<const int&, decltype((j))>);
+ static_assert(is_same<const int &, decltype((i))>);
+ // In these two, clang++ produces 'const int&'. Why, when it's
+ // the same as in check_params, just not a template?
+ static_assert(is_same<int &, decltype((jp))>);
+ static_assert(is_same<int &, decltype((ip))>);
+ };
+
+ (void)[=](decltype((j)) jp, decltype((i)) ip) mutable {
+ static_assert(is_same<int &, decltype((j))>);
+ static_assert(is_same<int &, decltype((i))>);
+ static_assert(is_same<int &, decltype((jp))>);
+ static_assert(is_same<int &, decltype((ip))>);
+ static_assert(is_same<int &, decltype(jp)>);
+ static_assert(is_same<int &, decltype(ip)>);
+ };
+
+ (void)[a = 0](decltype((a)) ap) mutable {
+ static_assert(is_same<int &, decltype((a))>);
+ static_assert(is_same<int, decltype(a)>);
+ static_assert(is_same<int &, decltype(ap)>);
+ };
+ (void)[a = 0](decltype((a)) ap) {
+ static_assert(is_same<const int &, decltype((a))>);
+ static_assert(is_same<int, decltype(a)>);
+ static_assert(is_same<int&, decltype((ap))>);
+ };
+}
+
+template<typename T>
+void
+test_requires ()
+{
+ int x;
+
+ [x = 1]() requires is_same<const int &, decltype((x))> {} ();
+ [x = 1]() mutable requires is_same<int &, decltype((x))> {}
+ ();
+ [x]() requires is_same<const int &, decltype((x))> {} ();
+ [x]() mutable requires is_same<int &, decltype((x))> {}
+ ();
+ [=]() requires is_same<const int &, decltype((x))> {} ();
+ [=]() mutable requires is_same<int &, decltype((x))> {}
+ ();
+ [&]() requires is_same<int &, decltype((x))> {}
+ ();
+ [&]() mutable requires is_same<int &, decltype((x))> {}
+ ();
+ [&x]() requires is_same<int &, decltype((x))> {}
+ ();
+ [&x]() mutable requires is_same<int &, decltype((x))> {}
+ ();
+
+ [x = 1]() requires is_same<const int &, decltype((x))> {} ();
+ [x = 1]() mutable requires is_same<int &, decltype((x))> {} ();
+}
+
+void
+use ()
+{
+ test_requires<int>();
+ check_params_tpl<int>();
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope3.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope3.C
new file mode 100644
index 00000000000..697fdaae095
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope3.C
@@ -0,0 +1,44 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++17 } }
+
+template <typename T>
+inline constexpr auto
+equal1 (T &&t)
+{
+ return [t = 3](const auto& obj) -> decltype(obj == t)
+ {
+ return obj == t;
+ };
+}
+
+template <typename T>
+inline constexpr auto
+equal2 (T &&t)
+{
+ return [t = t](const auto& obj) -> decltype(obj == t)
+ {
+ return obj == t;
+ };
+}
+
+template <typename T>
+inline constexpr auto
+equal3 (T &&t)
+{
+ return [t = 4](const auto& obj) -> decltype(obj == t)
+ {
+ return obj == t;
+ };
+}
+
+void
+g ()
+{
+ constexpr auto l1 = equal1 (5);
+ static_assert (l1 (3));
+ constexpr auto l2 = equal2 (3);
+ static_assert (l2 (3));
+ constexpr auto l3 = equal3 (2);
+ static_assert (l3 (4));
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope4.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope4.C
new file mode 100644
index 00000000000..9442db3f956
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope4.C
@@ -0,0 +1,41 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++17 } }
+
+struct integral_constant {
+ using type = integral_constant;
+};
+template <bool> using __bool_constant = integral_constant;
+template <typename _Fn, typename>
+struct is_invocable : __bool_constant<true> {};
+int forward() { return 42; }
+template <typename...> class tuple;
+struct plus {
+ template <typename _Tp, typename _Up>
+ constexpr auto operator()(_Tp __t, _Up __u) {
+ return __t > __u;
+ }
+};
+constexpr auto equal() {
+ int t = 0;
+ return [t = 3](auto obj) -> decltype(obj == t) { return t; };
+}
+template <typename> struct is_tuple_invocable;
+template <typename... Ts> struct is_tuple_invocable<tuple<Ts...>> {
+ using type = typename is_invocable<Ts...>::type;
+};
+namespace detail {
+template <typename F, typename Tail, typename... T>
+constexpr auto compose(__bool_constant<true>, F f, Tail tail, T... objs) {
+ return f(tail(objs...));
+}
+} // namespace detail
+template <typename F, typename... Fs> constexpr auto compose(F f, Fs... fs) {
+ return [f, tail(fs...)](auto... objs) {
+ auto unitail =
+ typename is_tuple_invocable<tuple<decltype(objs)...>>::type{};
+ return detail::compose(unitail, f, tail, objs...);
+ };
+}
+template <auto> constexpr auto eq = equal();
+static_assert(compose(eq<3>, plus{})(1, 2));
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope4b.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope4b.C
new file mode 100644
index 00000000000..6a9e6ec5e9d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope4b.C
@@ -0,0 +1,42 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++17 } }
+
+struct integral_constant {
+ using type = integral_constant;
+};
+template <bool> using __bool_constant = integral_constant;
+template <typename _Fn, typename>
+struct is_invocable : __bool_constant<true> {};
+int forward() { return 42; }
+template <typename...> class tuple;
+struct plus {
+ template <typename _Tp, typename _Up>
+ constexpr auto operator()(_Tp __t, _Up __u) {
+ return __t > __u;
+ }
+};
+constexpr auto equal() {
+ int t = 0;
+ return [t = 3](auto obj) -> decltype(obj == t) { return t; };
+}
+template <typename> struct is_tuple_invocable;
+template <typename... Ts> struct is_tuple_invocable<tuple<Ts...>> {
+ using type = typename is_invocable<Ts...>::type;
+};
+namespace detail {
+template <typename F, typename Tail, typename... T>
+constexpr auto compose(__bool_constant<true>, F f, Tail tail, T... objs) {
+ return f(tail(objs...));
+}
+} // namespace detail
+template <typename F, typename... Fs>
+constexpr auto compose(F f, Fs... fs) {
+ return [f, tail(fs...)](auto... objs) -> decltype (detail::compose(typename
is_tuple_invocable<tuple<decltype(objs)...>>::type{}, f, tail, objs...)) {
+ auto unitail =
+ typename is_tuple_invocable<tuple<decltype(objs)...>>::type{};
+ return detail::compose(unitail, f, tail, objs...);
+ };
+}
+template <auto> constexpr auto eq = equal();
+static_assert(compose(eq<3>, plus{})(1, 2));
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope5.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope5.C
new file mode 100644
index 00000000000..48b5ef34c9e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope5.C
@@ -0,0 +1,22 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++17 } }
+
+constexpr auto equal() {
+ int t = 0;
+ return [t](auto obj) { return obj; };
+}
+template <typename F>
+constexpr int bar (F) {
+ return 42;
+}
+
+template <typename F>
+constexpr auto compose(F f)
+{
+ return [f=f](int i) -> decltype(bar (f)) {
+ return 42;
+ };
+}
+template <auto> constexpr auto eq = equal();
+static_assert(compose(eq<3>)(1));
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope6.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope6.C
new file mode 100644
index 00000000000..720c1ec6cba
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope6.C
@@ -0,0 +1,20 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++23 } }
+
+void
+g ()
+{
+ /* It looks like this shouldn't work but [expr.prim.lambda.closure]/6
+ says "Otherwise, it is a non-static member function or member function
+ template that is declared const if and only if the lambda-expression's
+ parameter-declaration-clause is not followed by mutable and the
+ lambda-declarator does not contain an explicit object parameter." */
+ auto counter = [j=0](this auto const& self) -> decltype(j) {
+ return j++;
+ };
+
+ auto counter2 = [j=0](this auto& self) -> decltype(j) {
+ return j++;
+ };
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope7.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope7.C
new file mode 100644
index 00000000000..6db39bd8692
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope7.C
@@ -0,0 +1,20 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++14_only } }
+
+template <typename T>
+inline constexpr auto
+equal1 (T &&t)
+{
+ return [t = 3](const auto& obj) -> decltype(obj == t)
+ {
+ return obj == t;
+ };
+}
+
+void
+g ()
+{
+ constexpr auto l1 = equal1 (5); // { dg-error "not literal" }
+ static_assert (l1 (3), ""); // { dg-error "non-constant|non-.constexpr." }
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/lambda-scope8.C
b/gcc/testsuite/g++.dg/cpp23/lambda-scope8.C
new file mode 100644
index 00000000000..f6fb02dee26
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/lambda-scope8.C
@@ -0,0 +1,25 @@
+// P2036R3 - Change scope of lambda trailing-return-type
+// PR c++/102610
+// { dg-do compile { target c++23 } }
+// { dg-options "-Wshadow" }
+
+void
+bad ()
+{
+ [x=1](int x){}; // { dg-error "declared as a capture" }
+ // { dg-warning "shadows a lambda capture" "" { target *-*-* } .-1 }
+ [x=1]{ int x; }; // { dg-warning "shadows a lambda capture" }
+
+ auto f = [i = 5] () { int i; return 0; }; // { dg-warning "shadows a lambda
capture" }
+ auto f2 = [i = 5] <int N> () { int i; return 0; }; // { dg-warning "shadows
a lambda capture" }
+
+ // [expr.prim.lambda.capture]/5
+ int x = 0;
+ auto g = [x](int x) { return 0; }; // { dg-error "declared as a capture" }
+ // { dg-warning "shadows a lambda capture" "" { target *-*-* } .-1 }
+ auto h = [y = 0]<typename y>(y) { return 0; }; // { dg-error "shadows
template parameter" }
+
+ auto l2 = [i = 0, j = i]() -> decltype(i) { // { dg-error "not declared in
this scope" }
+ return i;
+ };
+}
base-commit: a5d9debedd2f46a699c7f0a206f4e0b7d620a111
--
2.50.0
