On Thu, 27 Apr 2023, Patrick Palka wrote: > On Thu, Apr 27, 2023 at 4:46 PM Patrick Palka wrote: > > > > Now that with r14-11-g2245459c85a3f4 made us coerce the template > > arguments of a bound ttp again after level-lowering, this unfortunately > > causes a crash from coerce_template_args_for_ttp in the below testcase. > > > > During the level-lowering substitution T=int into the bound ttp TT > > as part of substitution into the lambda signature, current_template_parms > > is just U=U rather than the ideal TT=TT, U=U. And because we don't > > consistently set DECL_CONTEXT for level-lowered ttps (it's kind of a > > chicken of the egg problem in this case), we attempt to use > > current_template_parms to obtain the outer arguments during > > coerce_template_args_for_ttp. But the depth 1 of c_t_p > > current_template_parms is less than the depth 2 of the level-lowered TT, > > and we end up segfaulting from there. > > > > So for level-lowered ttps it seems we need to get the outer arguments a > > different way -- namely, we can look at the trailing parms of its > > DECL_TEMPLATE_PARMS. > > Note this is not an ideal solution because TREE_CHAIN of > DECL_TEMPLATE_PARMS in this case is just "2 , 1 U", so we're > missing tparm information for the level that the ttp belongs to :/ So > the only difference compared to using current_template_parms in this > case is the extra empty level of args corresponding to the ttp's > level. And on the other hand, this issue seems specific to lambdas because it's in tsubst_lambda_expr that we substitute the function type _before_ substituting and installing the template parameters, which is opposite to the typical order that tsubst_template_decl does things in. And that's ultimately the reason the current_template_parms fallback in coerce_template_args_for_ttp misbehaves in this testcase. So the following seems to be a better fix. With it, current_template_parms is correctly 2 TT, 1 U during substitution the lambda's function type, which makes coerce_template_args_for_ttp happy when level lowering the bound ttp within the function type. -- >8 -- Subject: [PATCH] c++: bound ttp in lambda function type [PR109651] PR c++/109651 gcc/cp/ChangeLog: * pt.cc (tsubst_template_decl): Add default argument to lambda_fntype parameter. Add defaulted lambda_tparms parameter. Prefer to use lambda_tparms instead of substituting DECL_TEMPLATE_PARMS. (tsubst_decl) : Adjust tsubst_template_decl call. (tsubst_lambda_expr): For a generic lambda, substitute DECL_TEMPLATE_PARMS and update current_template_parms before substituting the function type. Pass the substituted DECL_TEMPLATE_PARMS to tsubst_template_decl. gcc/testsuite/ChangeLog: * g++.dg/cpp2a/lambda-generic-ttp1.C: New test. * g++.dg/cpp2a/lambda-generic-ttp2.C: New test. --- gcc/cp/pt.cc | 30 ++++++++++++++----- .../g++.dg/cpp2a/lambda-generic-ttp1.C | 11 +++++++ .../g++.dg/cpp2a/lambda-generic-ttp2.C | 13 ++++++++ 3 files changed, 47 insertions(+), 7 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp2a/lambda-generic-ttp1.C create mode 100644 gcc/testsuite/g++.dg/cpp2a/lambda-generic-ttp2.C diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 678cb7930e3..43713d9ab72 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -14629,7 +14629,8 @@ tsubst_function_decl (tree t, tree args, tsubst_flags_t complain, static tree tsubst_template_decl (tree t, tree args, tsubst_flags_t complain, - tree lambda_fntype) + tree lambda_fntype = NULL_TREE, + tree lambda_tparms = NULL_TREE) { /* We can get here when processing a member function template, member class template, or template template parameter. */ @@ -14719,8 +14720,10 @@ tsubst_template_decl (tree t, tree args, tsubst_flags_t complain, auto tparm_guard = make_temp_override (current_template_parms); DECL_TEMPLATE_PARMS (r) = current_template_parms - = tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args, - complain); + = (lambda_tparms + ? lambda_tparms + : tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args, + complain)); bool class_p = false; tree inner = decl; @@ -14888,7 +14891,7 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) switch (TREE_CODE (t)) { case TEMPLATE_DECL: - r = tsubst_template_decl (t, args, complain, /*lambda*/NULL_TREE); + r = tsubst_template_decl (t, args, complain); break; case FUNCTION_DECL: @@ -20130,12 +20133,24 @@ tsubst_lambda_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl) ? DECL_TI_TEMPLATE (oldfn) : NULL_TREE); + tree tparms = NULL_TREE; + if (oldtmpl) + tparms = tsubst_template_parms (DECL_TEMPLATE_PARMS (oldtmpl), args, complain); + tree fntype = static_fn_type (oldfn); + + tree saved_ctp = current_template_parms; if (oldtmpl) - ++processing_template_decl; + { + ++processing_template_decl; + current_template_parms = tparms; + } fntype = tsubst (fntype, args, complain, in_decl); if (oldtmpl) - --processing_template_decl; + { + current_template_parms = saved_ctp; + --processing_template_decl; + } if (fntype == error_mark_node) r = error_mark_node; @@ -20151,7 +20166,8 @@ tsubst_lambda_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl) type_memfn_quals (fntype), type_memfn_rqual (fntype)); tree inst = (oldtmpl - ? tsubst_template_decl (oldtmpl, args, complain, fntype) + ? tsubst_template_decl (oldtmpl, args, complain, + fntype, tparms) : tsubst_function_decl (oldfn, args, complain, fntype)); if (inst == error_mark_node) { diff --git a/gcc/testsuite/g++.dg/cpp2a/lambda-generic-ttp1.C b/gcc/testsuite/g++.dg/cpp2a/lambda-generic-ttp1.C new file mode 100644 index 00000000000..876e5b6232a --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/lambda-generic-ttp1.C @@ -0,0 +1,11 @@ +// PR c++/109651 +// { dg-do compile { target c++20 } } + +template +void f() { + []() { + [] class TT>(TT) { }; + }; +} + +template void f(); diff --git a/gcc/testsuite/g++.dg/cpp2a/lambda-generic-ttp2.C b/gcc/testsuite/g++.dg/cpp2a/lambda-generic-ttp2.C new file mode 100644 index 00000000000..dc2029d7227 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/lambda-generic-ttp2.C @@ -0,0 +1,13 @@ +// PR c++/109651 +// { dg-do compile { target c++20 } } + +template +auto f() { + return [] class TT>(U, TT) { }; +} + +template struct A { }; + +int main() { + f()(0, A{}); +} -- 2.40.1.423.g2807bd2c10 > > > > > > > Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for > > trunk/13? > > > > PR c++/109651 > > > > gcc/cp/ChangeLog: > > > > * pt.cc (coerce_template_args_for_ttp): For level-lowered > > ttps with DECL_CONTEXT not set, obtain the outer template > > arguments via its DECL_TEMPLATE_PARMS. > > > > gcc/testsuite/ChangeLog: > > > > * g++.dg/template/ttp37.C: New test. > > --- > > gcc/cp/pt.cc | 5 +++++ > > gcc/testsuite/g++.dg/template/ttp37.C | 11 +++++++++++ > > 2 files changed, 16 insertions(+) > > create mode 100644 gcc/testsuite/g++.dg/template/ttp37.C > > > > diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc > > index 678cb7930e3..bbde61061f6 100644 > > --- a/gcc/cp/pt.cc > > +++ b/gcc/cp/pt.cc > > @@ -7872,6 +7872,11 @@ coerce_template_args_for_ttp (tree templ, tree arglist, > > tree outer = DECL_CONTEXT (templ); > > if (outer) > > outer = generic_targs_for (outer); > > + else if (TEMPLATE_TYPE_LEVEL (TREE_TYPE (templ)) > > + != TEMPLATE_TYPE_ORIG_LEVEL (TREE_TYPE (templ))) > > + /* This is a level-lowered template template parameter, for which > > + we don't consistently set DECL_CONTEXT (FIXME). */ > > + outer = template_parms_to_args (TREE_CHAIN (DECL_TEMPLATE_PARMS (templ))); > > else if (current_template_parms) > > { > > /* This is an argument of the current template, so we haven't set > > diff --git a/gcc/testsuite/g++.dg/template/ttp37.C b/gcc/testsuite/g++.dg/template/ttp37.C > > new file mode 100644 > > index 00000000000..876e5b6232a > > --- /dev/null > > +++ b/gcc/testsuite/g++.dg/template/ttp37.C > > @@ -0,0 +1,11 @@ > > +// PR c++/109651 > > +// { dg-do compile { target c++20 } } > > + > > +template > > +void f() { > > + []() { > > + [] class TT>(TT) { }; > > + }; > > +} > > + > > +template void f(); > > -- > > 2.40.1.423.g2807bd2c10 > > >