From: Jason Merrill Date: Fri, 3 Apr 2020 03:40:46 +0000 (-0400) Subject: c++: alias template and parameter packs (PR91966). X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=bcafd8748cf9eb83a9e71bf67c4e2a7c5c8f513c;p=gcc.git c++: alias template and parameter packs (PR91966). In this testcase, when we do a pack expansion of count_better_mins, nums appears both in the definition of count_better_mins and as its template argument. The intent is that we get a expansion over pairs of elements of the pack, i.e. less<2,2>, less<2,7>, less<7,2>, .... But if we substitute into the definition of count_better_mins when parsing the template, we end up with sum...>, which never gives us less<2,7>. We could deal with this by somehow marking up the use of 'nums' as an argument for 'num', but it's simpler to mark the alias as complex, so we need to instantiate it later with all its arguments rather than replace it early with its expansion. gcc/cp/ChangeLog 2020-04-03 Jason Merrill PR c++/91966 * pt.c (complex_pack_expansion_r): New. (complex_alias_template_p): Use it. --- diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 3b522e8278c..d0b0cb1cac5 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,9 @@ +2020-04-03 Jason Merrill + + PR c++/91966 + * pt.c (complex_pack_expansion_r): New. + (complex_alias_template_p): Use it. + 2020-03-31 Jason Merrill PR c++/94205 diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index bd30c96a12a..b602f9f82c7 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -6351,6 +6351,33 @@ uses_all_template_parms_r (tree t, void *data_) return 0; } +/* for_each_template_parm any_fn callback for complex_alias_template_p. */ + +static int +complex_pack_expansion_r (tree t, void *data_) +{ + /* An alias template with a pack expansion that expands a pack from the + enclosing class needs to be considered complex, to avoid confusion with + the same pack being used as an argument to the alias's own template + parameter (91966). */ + if (!PACK_EXPANSION_P (t)) + return 0; + struct uses_all_template_parms_data &data + = *(struct uses_all_template_parms_data*)data_; + for (tree pack = PACK_EXPANSION_PARAMETER_PACKS (t); pack; + pack = TREE_CHAIN (pack)) + { + tree parm_pack = TREE_VALUE (pack); + if (!TEMPLATE_PARM_P (parm_pack)) + continue; + int idx, level; + template_parm_level_and_index (parm_pack, &level, &idx); + if (level < data.level) + return 1; + } + return 0; +} + static bool complex_alias_template_p (const_tree tmpl) { @@ -6371,7 +6398,9 @@ complex_alias_template_p (const_tree tmpl) for (int i = 0; i < len; ++i) data.seen[i] = false; - for_each_template_parm (pat, uses_all_template_parms_r, &data, NULL, true); + if (for_each_template_parm (pat, uses_all_template_parms_r, &data, + NULL, true, complex_pack_expansion_r)) + return true; for (int i = 0; i < len; ++i) if (!data.seen[i]) return true; diff --git a/gcc/testsuite/g++.dg/cpp0x/variadic-alias2.C b/gcc/testsuite/g++.dg/cpp0x/variadic-alias2.C new file mode 100644 index 00000000000..ab64866d35f --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/variadic-alias2.C @@ -0,0 +1,103 @@ +// PR c++/91966 +// { dg-do compile { target c++11 } } + +// Reduced to this include-free example. Further reduction is hard: Either +// the bug(?) disappears, or the program becomes meaningless. + +template +struct list {}; + +struct nil; + +//////////////////////////////////////////////////////////////////////////////// + +template +struct number { + constexpr /*implicit*/ operator int() const { return n; } + using type = number; +}; + +using false_ = number<0>; +using true_ = number<1>; + +static_assert(!false_{}, ""); +static_assert(true_{}, ""); + +template using numbers = list...>; + +//////////////////////////////////////////////////////////////////////////////// + +template +struct less_impl; + +template +struct less_impl, number> + : number<(lhs < rhs)> {}; + +template using less = typename less_impl::type; + +//////////////////////////////////////////////////////////////////////////////// + +template +struct sum_impl { + static_assert(sizeof...(vs) == 0, "see specialization"); + using type = v0; +}; + +template +struct sum_impl, number, vs...> + : sum_impl, vs...> {}; + +template using sum = typename sum_impl::type; + +//////////////////////////////////////////////////////////////////////////////// + +template +struct conditional_impl { + static_assert(num{}, "see specialization"); + + template + using type = T; +}; + +template<> +struct conditional_impl { + template + using type = F; +}; + +template +using conditional = typename conditional_impl::template type; + +//////////////////////////////////////////////////////////////////////////////// + +template +struct min_filter_impl; + +template +struct min_filter_impl> { + template + using count_better_mins = sum...>; + + using type = list, nil, nums>...>; + +//using debug = list, nil, void>...>; + +// error: expansion pattern 'conditional...>::type, nil, void>' contains no parameter packs + +}; + +template using min_filter = typename min_filter_impl::type; + +//////////////////////////////////////////////////////////////////////////////// + +void test_min_filter() { + using computed = min_filter>; + using expected = list, nil, number<2>>; + (void)(computed{} = expected{});// compiles for identical types + +// error: no match for 'operator=' (operand types are 'computed' {aka 'list, number<7>, number<2> >'} and 'expected' {aka 'list, nil, number<2> >'}) + +} + +int main() {}