From d6587211c02c4e2566c4e545c09757f3fbb7adab Mon Sep 17 00:00:00 2001 From: Patrick Palka Date: Tue, 22 Sep 2020 16:26:52 -0400 Subject: [PATCH] c++: Return only in-scope tparms in keep_template_parm [PR95310] MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit In the testcase below, the dependent specializations iter_reference_t and iter_reference_t share the same tree due to specialization caching. So when find_template_parameters walks through the requires-expression (as part of normalization), it sees and includes the out-of-scope template parameter F in the list of template parameters it found within the requires-expression (along with Out and N). From a correctness perspective this is harmless since the parameter mapping routines only care about the level and index of each parameter, so F is no different from Out in that sense. And it's also harmless that two parameters in the parameter mapping have the same level and index. But having both Out and F in the parameter mapping means extra work for hash_atomic_constrant, tsubst_parameter_mapping and get_mapped_args; and it also means we print this irrelevant template parameter in the testcase's diagnostics (via pp_cxx_parameter_mapping): in requirements with ‘Out o’ [with N = (const int&)&a; F = const int*; Out = const int*] This patch makes keep_template_parm return only in-scope template parameters by looking into ctx_parms for the corresponding in-scope one, through a new helper function corresponding_template_parameter. (That we sometimes print irrelevant template parameters in diagnostics is also the subject of PR99 and PR66968, so the above diagnostic issue could likely be fixed in a more general way, but this targeted fix to keep_template_parm is perhaps worthwhile on its own.) gcc/cp/ChangeLog: PR c++/95310 * pt.c (corresponding_template_parameter): Define. (keep_template_parm): Use it to adjust the given template parameter to the corresponding in-scope one from ctx_parms. gcc/testsuite/ChangeLog: PR c++/95310 * g++.dg/concepts/diagnostic15.C: New test. --- gcc/cp/pt.c | 44 ++++++++++++++++++++ gcc/testsuite/g++.dg/concepts/diagnostic15.C | 16 +++++++ 2 files changed, 60 insertions(+) create mode 100644 gcc/testsuite/g++.dg/concepts/diagnostic15.C diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 69946da09bf..314bd038c6d 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -10243,6 +10243,42 @@ lookup_and_finish_template_variable (tree templ, tree targs, return convert_from_reference (templ); } +/* If the set of template parameters PARMS contains a template parameter + at the given LEVEL and INDEX, then return this parameter. Otherwise + return NULL_TREE. */ + +static tree +corresponding_template_parameter (tree parms, int level, int index) +{ + while (TMPL_PARMS_DEPTH (parms) > level) + parms = TREE_CHAIN (parms); + + if (TMPL_PARMS_DEPTH (parms) != level + || TREE_VEC_LENGTH (TREE_VALUE (parms)) <= index) + return NULL_TREE; + + tree t = TREE_VALUE (TREE_VEC_ELT (TREE_VALUE (parms), index)); + /* As in template_parm_to_arg. */ + if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL) + t = TREE_TYPE (t); + else + t = DECL_INITIAL (t); + + gcc_assert (TEMPLATE_PARM_P (t)); + return t; +} + +/* Return the template parameter from PARMS that positionally corresponds + to the template parameter PARM, or else return NULL_TREE. */ + +static tree +corresponding_template_parameter (tree parms, tree parm) +{ + int level, index; + template_parm_level_and_index (parm, &level, &index); + return corresponding_template_parameter (parms, level, index); +} + struct pair_fn_data { @@ -10549,6 +10585,14 @@ keep_template_parm (tree t, void* data) BOUND_TEMPLATE_TEMPLATE_PARM itself. */ t = TREE_TYPE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t)); + /* This template parameter might be an argument to a cached dependent + specalization that was formed earlier inside some other template, in + which case the parameter is not among the ones that are in-scope. + Look in CTX_PARMS to find the corresponding in-scope template + parameter, and use it instead. */ + if (tree in_scope = corresponding_template_parameter (ftpi->ctx_parms, t)) + t = in_scope; + /* Arguments like const T yield parameters like const T. This means that a template-id like X would yield two distinct parameters: T and const T. Adjust types to their unqualified versions. */ diff --git a/gcc/testsuite/g++.dg/concepts/diagnostic15.C b/gcc/testsuite/g++.dg/concepts/diagnostic15.C new file mode 100644 index 00000000000..3acd9f67968 --- /dev/null +++ b/gcc/testsuite/g++.dg/concepts/diagnostic15.C @@ -0,0 +1,16 @@ +// PR c++/95310 +// { dg-do compile { target concepts } } + +template +using iter_reference_t = decltype(*T{}); + +template +struct result { using type = iter_reference_t; }; + +template +concept indirectly_writable = requires(Out o) { // { dg-bogus "F =" } + iter_reference_t(*o) = N; +}; + +const int a = 0; +static_assert(indirectly_writable); // { dg-error "assert" } -- 2.30.2