From: Patrick Palka Date: Thu, 15 Dec 2022 23:50:16 +0000 (-0500) Subject: c++: variadic using-decl with parm pack in terminal name [PR102104] X-Git-Tag: basepoints/gcc-14~2473 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e79d51963378b10ab90544a7d8eeb6266e9a57f6;p=thirdparty%2Fgcc.git c++: variadic using-decl with parm pack in terminal name [PR102104] There's a curious corner case with variadic member using-decls: the terminal name can also contain a parameter pack, and only through naming a conversion function, e.g. using A::operator Ts...; We currently only handle parameter packs appearing in the qualifying scope of a variadic using-decl; this patch adds support for the above case as well, representing such a using-decl via two pack expansions, one for the qualifying scope and one for the terminal name (despite logically there being just one). Then at instantiation time we manually merge them. PR c++/102104 PR c++/108090 gcc/cp/ChangeLog: * error.cc (dump_decl) : Look through a pack expansion in the name as well. * parser.cc (cp_parser_using_declaration): Handle a parameter pack appearing in the terminal name of a variadic using-decl. * pt.cc (tsubst_decl) : Likewise. Combine the handling of variadic and non-variadic using-decls. gcc/testsuite/ChangeLog: * g++.dg/cpp1z/using-variadic1.C: New test. * g++.dg/cpp1z/using-variadic1a.C: New test. * g++.dg/cpp1z/using-variadic1b.C: New test. * g++.dg/cpp1z/using-variadic1c.C: New test. * g++.dg/cpp1z/using-variadic2.C: New test. * g++.dg/cpp1z/using-variadic3.C: New test. --- diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc index 12b28e8ee5b6..e7f60335cc06 100644 --- a/gcc/cp/error.cc +++ b/gcc/cp/error.cc @@ -1477,11 +1477,20 @@ dump_decl (cxx_pretty_printer *pp, tree t, int flags) if (!(flags & TFF_UNQUALIFIED_NAME)) { tree scope = USING_DECL_SCOPE (t); + tree name = DECL_NAME (t); if (PACK_EXPANSION_P (scope)) { scope = PACK_EXPANSION_PATTERN (scope); variadic = true; } + if (identifier_p (name) + && IDENTIFIER_CONV_OP_P (name) + && PACK_EXPANSION_P (TREE_TYPE (name))) + { + name = make_conv_op_name (PACK_EXPANSION_PATTERN + (TREE_TYPE (name))); + variadic = true; + } dump_type (pp, scope, flags); pp_cxx_colon_colon (pp); } diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 1d59ccd9de83..bfd8aeae39f6 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -21708,7 +21708,36 @@ cp_parser_using_declaration (cp_parser* parser, pedwarn (ell->location, OPT_Wc__17_extensions, "pack expansion in using-declaration only available " "with %<-std=c++17%> or %<-std=gnu++17%>"); - qscope = make_pack_expansion (qscope); + + /* A parameter pack can appear in the qualifying scope, and/or in the + terminal name (if naming a conversion function). Logically they're + part of a single pack expansion of the overall USING_DECL, but we + express them as separate pack expansions within the USING_DECL since + we can't create a pack expansion over a USING_DECL. */ + bool saw_parm_pack = false; + if (uses_parameter_packs (qscope)) + { + qscope = make_pack_expansion (qscope); + saw_parm_pack = true; + } + if (identifier_p (identifier) + && IDENTIFIER_CONV_OP_P (identifier) + && uses_parameter_packs (TREE_TYPE (identifier))) + { + identifier = make_conv_op_name (make_pack_expansion + (TREE_TYPE (identifier))); + saw_parm_pack = true; + } + if (!saw_parm_pack) + { + /* Issue an error in terms using a SCOPE_REF that includes both + components. */ + tree name + = build_qualified_name (NULL_TREE, qscope, identifier, false); + make_pack_expansion (name); + gcc_assert (seen_error ()); + qscope = identifier = error_mark_node; + } } /* The function we call to handle a using-declaration is different diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index b9933ec6e069..bc566ab702b8 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -14962,43 +14962,81 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) if (DECL_DEPENDENT_P (t) || uses_template_parms (USING_DECL_SCOPE (t))) { + /* True iff this using-decl was written as a pack expansion + (and a pack appeared in its scope or name). If a pack + appeared in both, we expand the packs separately and + manually merge them. */ + bool variadic_p = false; + tree scope = USING_DECL_SCOPE (t); - tree name = tsubst_copy (DECL_NAME (t), args, complain, in_decl); if (PACK_EXPANSION_P (scope)) { - tree vec = tsubst_pack_expansion (scope, args, complain, in_decl); - int len = TREE_VEC_LENGTH (vec); - r = make_tree_vec (len); - for (int i = 0; i < len; ++i) + scope = tsubst_pack_expansion (scope, args, complain, in_decl); + variadic_p = true; + } + else + scope = tsubst_copy (scope, args, complain, in_decl); + + tree name = DECL_NAME (t); + if (IDENTIFIER_CONV_OP_P (name) + && PACK_EXPANSION_P (TREE_TYPE (name))) + { + name = tsubst_pack_expansion (TREE_TYPE (name), args, + complain, in_decl); + if (name == error_mark_node) { - tree escope = TREE_VEC_ELT (vec, i); - tree elt = do_class_using_decl (escope, name); - if (!elt) - { - r = error_mark_node; - break; - } - else - { - TREE_PROTECTED (elt) = TREE_PROTECTED (t); - TREE_PRIVATE (elt) = TREE_PRIVATE (t); - } - TREE_VEC_ELT (r, i) = elt; + r = error_mark_node; + break; } + for (tree& elt : tree_vec_range (name)) + elt = make_conv_op_name (elt); + variadic_p = true; } else + name = tsubst_copy (name, args, complain, in_decl); + + int len; + if (!variadic_p) + len = 1; + else if (TREE_CODE (scope) == TREE_VEC + && TREE_CODE (name) == TREE_VEC) { - tree inst_scope = tsubst_copy (USING_DECL_SCOPE (t), args, - complain, in_decl); - r = do_class_using_decl (inst_scope, name); - if (!r) - r = error_mark_node; - else + if (TREE_VEC_LENGTH (scope) != TREE_VEC_LENGTH (name)) { - TREE_PROTECTED (r) = TREE_PROTECTED (t); - TREE_PRIVATE (r) = TREE_PRIVATE (t); + error ("mismatched argument pack lengths (%d vs %d)", + TREE_VEC_LENGTH (scope), TREE_VEC_LENGTH (name)); + r = error_mark_node; + break; } + len = TREE_VEC_LENGTH (scope); } + else if (TREE_CODE (scope) == TREE_VEC) + len = TREE_VEC_LENGTH (scope); + else /* TREE_CODE (name) == TREE_VEC */ + len = TREE_VEC_LENGTH (name); + + r = make_tree_vec (len); + for (int i = 0; i < len; ++i) + { + tree escope = (TREE_CODE (scope) == TREE_VEC + ? TREE_VEC_ELT (scope, i) + : scope); + tree ename = (TREE_CODE (name) == TREE_VEC + ? TREE_VEC_ELT (name, i) + : name); + tree elt = do_class_using_decl (escope, ename); + if (!elt) + { + r = error_mark_node; + break; + } + TREE_PROTECTED (elt) = TREE_PROTECTED (t); + TREE_PRIVATE (elt) = TREE_PRIVATE (t); + TREE_VEC_ELT (r, i) = elt; + } + + if (!variadic_p && r != error_mark_node) + r = TREE_VEC_ELT (r, 0); } else { diff --git a/gcc/testsuite/g++.dg/cpp1z/using-variadic1.C b/gcc/testsuite/g++.dg/cpp1z/using-variadic1.C new file mode 100644 index 000000000000..7a8bcbbe3729 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/using-variadic1.C @@ -0,0 +1,29 @@ +// PR c++/102104 +// { dg-do compile { target c++17 } } + +struct A { + using target_type = bool*; + operator bool*(); +}; + +struct B { + using target_type = long*; + operator long*(); +}; + +template +struct cls : private Bases... { + using Bases::operator typename Bases::target_type...; +}; + +cls v1; +bool* a1 = v1; +long* b1 = v1; + +cls v2; +bool* a2 = v2; // { dg-error "cannot convert" } +long* b2 = v2; + +cls v3; +bool* a3 = v3; +long* b3 = v3; // { dg-error "cannot convert" } diff --git a/gcc/testsuite/g++.dg/cpp1z/using-variadic1a.C b/gcc/testsuite/g++.dg/cpp1z/using-variadic1a.C new file mode 100644 index 000000000000..0393cab6ace1 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/using-variadic1a.C @@ -0,0 +1,34 @@ +// PR c++/102104 +// A version of using-variadic1.C where the qualifying scope and the +// terminal name of the using-declaration use different parameter packs. +// { dg-do compile { target c++17 } } + +struct A { + using target_type = bool*; + operator bool*(); +}; + +struct B { + using target_type = long*; + operator long*(); +}; + +template +struct cls { + template + struct nested : private Bases... { + using Bases::operator typename Ts::target_type...; + }; +}; + +cls::nested v1; +bool* a1 = v1; +long* b1 = v1; + +cls::nested v2; +bool* a2 = v2; // { dg-error "cannot convert" } +long* b2 = v2; + +cls::nested v3; +bool* a3 = v3; +long* b3 = v3; // { dg-error "cannot convert" } diff --git a/gcc/testsuite/g++.dg/cpp1z/using-variadic1b.C b/gcc/testsuite/g++.dg/cpp1z/using-variadic1b.C new file mode 100644 index 000000000000..fd3a41718b6c --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/using-variadic1b.C @@ -0,0 +1,37 @@ +// PR c++/102104 +// A version of using-variadic1.C where only the qualifying scope +// uses a parameter pack. +// { dg-do compile { target c++17 } } + +struct A { + using target_type = bool*; +}; + +struct B { + using target_type = long*; +}; + +struct C { + operator bool*(); + operator long*(); +}; + +template +struct cls { + template + struct nested : private Base { + using Base::operator typename Ts::target_type...; + }; +}; + +cls::nested v1; +bool* a1 = v1; +long* b1 = v1; + +cls::nested v2; +bool* a2 = v2; // { dg-error "inaccessible|not an accessible" } +long* b2 = v2; + +cls::nested v3; +bool* a3 = v3; +long* b3 = v3; // { dg-error "inaccessible|not an accessible" } diff --git a/gcc/testsuite/g++.dg/cpp1z/using-variadic1c.C b/gcc/testsuite/g++.dg/cpp1z/using-variadic1c.C new file mode 100644 index 000000000000..aa86b28fd2e0 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/using-variadic1c.C @@ -0,0 +1,33 @@ +// PR c++/102104 +// A version of of using-variadic1.C where only the terminal name +// uses a parameter pack. +// { dg-do compile { target c++17 } } + +struct A { + operator bool*(); +}; + +struct B { + operator bool*(); +}; + +struct C { + using target_type = bool*; +}; + +template +struct cls { + template + struct nested : private Bases... { + using Bases::operator typename T::target_type...; + }; +}; + +cls::nested v1; +bool* a1 = v1; // { dg-error "ambiguous" } + +cls::nested v2; +bool* a2 = v2; + +cls::nested v3; +bool* a3 = v3; diff --git a/gcc/testsuite/g++.dg/cpp1z/using-variadic2.C b/gcc/testsuite/g++.dg/cpp1z/using-variadic2.C new file mode 100644 index 000000000000..1d68ceece8a5 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/using-variadic2.C @@ -0,0 +1,24 @@ +// PR c++/102104 +// A version of using-variadic1a.C where the argument packs have +// different lengths. +// { dg-do compile { target c++17 } } + +struct A { + using target_type = bool*; + operator bool*(); +}; + +struct B { + using target_type = long*; + operator long*(); +}; + +template +struct cls { + template + struct nested : private Bases... { + using Bases::operator typename Ts::target_type...; // { dg-error "lengths" } + }; +}; + +cls::nested v1; // { dg-message "required from here" } diff --git a/gcc/testsuite/g++.dg/cpp1z/using-variadic3.C b/gcc/testsuite/g++.dg/cpp1z/using-variadic3.C new file mode 100644 index 000000000000..4e1d6894e561 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/using-variadic3.C @@ -0,0 +1,8 @@ +// PR c++/108090 +// { dg-do compile { target c++17 } } + +template struct As { operator T(); }; +template struct AsAll : As... { + using As::operator T...; +}; +AsAll x;