gcc/testsuite/ChangeLog:
* g++.dg/cpp1z/class-deduction67.C: Accept in C++23 mode.
* g++.dg/cpp23/class-deduction-inherited1.C: New test.
* g++.dg/cpp23/class-deduction-inherited2.C: New test.
* g++.dg/cpp23/class-deduction-inherited3.C: New test.
* g++.dg/cpp23/class-deduction-inherited4.C: New test.
---
gcc/cp/cp-tree.h | 2 +-
gcc/cp/pt.cc | 187 +++++++++++++++---
.../g++.dg/cpp1z/class-deduction67.C | 5 +-
.../g++.dg/cpp23/class-deduction-inherited1.C | 38 ++++
.../g++.dg/cpp23/class-deduction-inherited2.C | 26 +++
.../g++.dg/cpp23/class-deduction-inherited3.C | 16 ++
.../g++.dg/cpp23/class-deduction-inherited4.C | 32 +++
7 files changed, 273 insertions(+), 33 deletions(-)
create mode 100644 gcc/testsuite/g++.dg/cpp23/class-deduction-inherited1.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/class-deduction-inherited2.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/class-deduction-inherited3.C
create mode 100644 gcc/testsuite/g++.dg/cpp23/class-deduction-inherited4.C
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 7b0b7c6a17e..abc467fb290 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -7457,7 +7457,7 @@ extern tree fn_type_unification (tree,
tree, tree,
bool, bool);
extern void mark_decl_instantiated (tree, int);
extern int more_specialized_fn (tree, tree, int);
-extern bool type_targs_deducible_from (tree, tree);
+extern tree type_targs_deducible_from (tree, tree);
extern void do_decl_instantiation (tree, tree);
extern void do_type_instantiation (tree, tree, tsubst_flags_t);
extern bool always_instantiate_p (tree);
diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc
index 092e6fdfd36..5b982d1d641 100644
--- a/gcc/cp/pt.cc
+++ b/gcc/cp/pt.cc
@@ -223,6 +223,9 @@ static void instantiate_body (tree pattern, tree args, tree
d, bool nested);
static tree maybe_dependent_member_ref (tree, tree, tsubst_flags_t, tree);
static void mark_template_arguments_used (tree, tree);
static bool uses_outer_template_parms (tree);
+static tree alias_ctad_tweaks (tree, tree);
+static tree inherited_ctad_tweaks (tree, tree, tsubst_flags_t);
+static tree deduction_guides_for (tree, bool&, tsubst_flags_t);
/* Make the current scope suitable for access checking when we are
processing T. T can be FUNCTION_DECL for instantiated function
@@ -29736,8 +29739,6 @@ is_spec_or_derived (tree etype, tree tmpl)
return !err;
}
-static tree alias_ctad_tweaks (tree, tree);
-
/* Return a C++20 aggregate deduction candidate for TYPE initialized from
INIT. */
@@ -29842,7 +29843,13 @@ maybe_aggr_guide (tree tmpl, tree init, vec<tree,va_gc> *args)
}
/* UGUIDES are the deduction guides for the underlying template of alias
- template TMPL; adjust them to be deduction guides for TMPL. */
+ template TMPL; adjust them to be deduction guides for TMPL.
+
+ This routine also handles C++23 inherited CTAD, in which case TMPL is a
+ TREE_LIST representing a synthetic alias template whose TREE_PURPOSE is
+ the template parameter list of the alias template (equivalently, of the
+ derived class) and TREE_VALUE the defining-type-id (equivalently, the
+ base whose guides we're inheriting). UGUIDES are the base's guides. */
static tree
alias_ctad_tweaks (tree tmpl, tree uguides)
@@ -29886,13 +29893,27 @@ alias_ctad_tweaks (tree tmpl, tree uguides)
* The explicit-specifier of f' is the explicit-specifier of g (if
any). */
+ enum { alias, inherited } ctad_kind;
+ tree atype, fullatparms, utype;
+ if (TREE_CODE (tmpl) == TEMPLATE_DECL)
+ {
+ ctad_kind = alias;
+ atype = TREE_TYPE (tmpl);
+ fullatparms = DECL_TEMPLATE_PARMS (tmpl);
+ utype = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
+ }
+ else
+ {
+ ctad_kind = inherited;
+ atype = NULL_TREE;
+ fullatparms = TREE_PURPOSE (tmpl);
+ utype = TREE_VALUE (tmpl);
+ }
+
tsubst_flags_t complain = tf_warning_or_error;
- tree atype = TREE_TYPE (tmpl);
tree aguides = NULL_TREE;
- tree fullatparms = DECL_TEMPLATE_PARMS (tmpl);
tree atparms = INNERMOST_TEMPLATE_PARMS (fullatparms);
unsigned natparms = TREE_VEC_LENGTH (atparms);
- tree utype = DECL_ORIGINAL_TYPE (DECL_TEMPLATE_RESULT (tmpl));
for (ovl_iterator iter (uguides); iter; ++iter)
{
tree f = *iter;
@@ -29930,7 +29951,7 @@ alias_ctad_tweaks (tree tmpl, tree uguides)
/* Set current_template_parms as in build_deduction_guide. */
auto ctp = make_temp_override (current_template_parms);
- current_template_parms = copy_node (DECL_TEMPLATE_PARMS (tmpl));
+ current_template_parms = copy_node (fullatparms);
TREE_VALUE (current_template_parms) = gtparms;
j = 0;
@@ -30006,9 +30027,10 @@ alias_ctad_tweaks (tree tmpl, tree uguides)
/* Add a constraint that the return type matches the instantiation of
A with the same template arguments. */
ret = TREE_TYPE (TREE_TYPE (fprime));
- if (!same_type_p (atype, ret)
- /* FIXME this should mean they don't compare as equivalent. */
- || dependent_alias_template_spec_p (atype, nt_opaque))
+ if (ctad_kind == alias
+ && (!same_type_p (atype, ret)
+ /* FIXME this should mean they don't compare as equivalent.
*/
+ || dependent_alias_template_spec_p (atype, nt_opaque)))
{
tree same = finish_trait_expr (loc, CPTK_IS_DEDUCIBLE, tmpl, ret);
ci = append_constraint (ci, same);
@@ -30025,8 +30047,41 @@ alias_ctad_tweaks (tree tmpl, tree uguides)
/* For a non-template deduction guide, if the arguments of A aren't
deducible from the return type, don't add the candidate. */
non_template:
- if (!type_targs_deducible_from (tmpl, ret))
+ if (ctad_kind == alias
+ && !type_targs_deducible_from (tmpl, ret))
+ continue;
+ }
+
+ /* Rewrite the return type of the inherited guide in terms of the
+ derived class. This is specified as replacing the return type R
+ with typename CC<R>::type where the partially specialized CC maps a
+ base class specialization to a specialization of the derived class
+ having such a base (inducing substitution failure if no such derived
+ class exists).
+
+ As specified this mapping would be done at instantiation time using
+ non-dependent template arguments, but we do it ahead of time using
+ the generic arguments. This seems to be good enough since generic
+ deduction should succeed only if concrete deduction would. */
+ if (ctad_kind == inherited)
+ {
+ processing_template_decl_sentinel ptds (/*reset*/false);
+ if (TREE_CODE (fprime) == TEMPLATE_DECL)
+ ++processing_template_decl;
+
+ tree targs = type_targs_deducible_from (tmpl, ret);
+ if (!targs)
continue;
+
+ if (TREE_CODE (f) != TEMPLATE_DECL)
+ fprime = copy_decl (fprime);
+ tree fntype = TREE_TYPE (fprime);
+ ret = lookup_template_class (TPARMS_PRIMARY_TEMPLATE (atparms), targs,
+ in_decl, NULL_TREE, false, complain);
+ fntype = build_function_type (ret, TYPE_ARG_TYPES (fntype));
+ TREE_TYPE (fprime) = fntype;
+ if (TREE_CODE (fprime) == TEMPLATE_DECL)
+ TREE_TYPE (DECL_TEMPLATE_RESULT (fprime)) = fntype;
}
aguides = lookup_add (fprime, aguides);
@@ -30035,33 +30090,92 @@ alias_ctad_tweaks (tree tmpl, tree uguides)
return aguides;
}
-/* True iff template arguments for TMPL can be deduced from TYPE.
+/* CTOR is a using-declaration inheriting the constructors of some base of the
+ class template TMPL; adjust the base's guides be deduction guides for TMPL.
*/
+
+static tree
+inherited_ctad_tweaks (tree tmpl, tree ctor, tsubst_flags_t complain)
+{
+ /* [over.match.class.deduct]: In addition, if C is defined and inherits
+ constructors ([namespace.udecl]) from a direct base class denoted in the
+ base-specifier-list by a class-or-decltype B, let A be an alias template
+ whose template parameter list is that of C and whose defining-type-id is
+ B. If A is a deducible template ([dcl.type.simple]), the set contains the
+ guides of A with the return type R of each guide replaced with typename
+ CC::type given a class template
+
+ template <typename> class CC;
+
+ whose primary template is not defined and with a single partial
+ specialization whose template parameter list is that of A and whose
+ template argument list is a specialization of A with the template argument
+ list of A ([temp.dep.type]) having a member typedef type designating a
+ template specialization with the template argument list of A but with C as
+ the template. */
+
+ /* FIXME: Also recognize inherited constructors of the form 'using C::B::B',
+ which seem to be represented with TYPENAME_TYPE C::B as USING_DECL_SCOPE?
+ And recognize constructors inherited from a non-dependent base class,
which
+ seem to be missing from the overload set entirely? */
+ tree scope = USING_DECL_SCOPE (ctor);
+ if (!CLASS_TYPE_P (scope)
+ || !CLASSTYPE_TEMPLATE_INFO (scope))
+ return NULL_TREE;
+
+ tree t = build_tree_list (DECL_TEMPLATE_PARMS (tmpl), scope);
+ bool any_dguides_p;
+ tree uguides = deduction_guides_for (TYPE_TI_TEMPLATE (scope),
+ any_dguides_p, complain);
+ return alias_ctad_tweaks (t, uguides);
+}
+
+/* If template arguments for TMPL can be deduced from TYPE, return
+ the deduced arguments, otherwise return NULL_TREE.
Used to implement CPTK_IS_DEDUCIBLE for alias CTAD according to
[over.match.class.deduct].
This check is specified in terms of partial specialization, so the behavior
should be parallel to that of get_partial_spec_bindings. */
-bool
+tree
type_targs_deducible_from (tree tmpl, tree type)
{
- tree tparms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
+ tree tparms, ttype;
+ if (TREE_CODE (tmpl) == TEMPLATE_DECL)
+ {
+ /* If tmpl is a class template, this is trivial: it's deducible if TYPE
is a
+ specialization of TMPL. */
+ if (DECL_CLASS_TEMPLATE_P (tmpl))
+ {
+ if (CLASS_TYPE_P (type)
+ && CLASSTYPE_TEMPLATE_INFO (type)
+ && CLASSTYPE_TI_TEMPLATE (type) == tmpl)
+ return INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
+ else
+ return NULL_TREE;
+ }
+
+ /* Otherwise it's an alias template. */
+ tparms = DECL_INNERMOST_TEMPLATE_PARMS (tmpl);
+ ttype = TREE_TYPE (tmpl);
+ }
+ else
+ {
+ /* TMPL is a synthetic alias template represented as a TREE_LIST as
+ per alias_ctad_tweaks. */
+ tparms = INNERMOST_TEMPLATE_PARMS (TREE_PURPOSE (tmpl));
+ ttype = TREE_VALUE (tmpl);
+ tmpl = TI_TEMPLATE (TYPE_TEMPLATE_INFO_MAYBE_ALIAS (ttype));
+ }
+
int len = TREE_VEC_LENGTH (tparms);
tree targs = make_tree_vec (len);
bool tried_array_deduction = (cxx_dialect < cxx17);
- /* If tmpl is a class template, this is trivial: it's deducible if TYPE is a
- specialization of TMPL. */
- if (DECL_CLASS_TEMPLATE_P (tmpl))
- return (CLASS_TYPE_P (type)
- && CLASSTYPE_TEMPLATE_INFO (type)
- && CLASSTYPE_TI_TEMPLATE (type) == tmpl);
-
- /* Otherwise it's an alias template. */
again:
- if (unify (tparms, targs, TREE_TYPE (tmpl), type,
+ if (unify (tparms, targs, ttype, type,
UNIFY_ALLOW_NONE, false))
- return false;
+ return NULL_TREE;
/* We don't fail on an undeduced targ the second time through (like
get_partial_spec_bindings) because we're going to try defaults. */
@@ -30074,7 +30188,7 @@ type_targs_deducible_from (tree tmpl, tree type)
if (!tried_array_deduction
&& TREE_CODE (tparm) == TYPE_DECL)
{
- try_array_deduction (tparms, targs, TREE_TYPE (tmpl));
+ try_array_deduction (tparms, targs, ttype);
tried_array_deduction = true;
if (TREE_VEC_ELT (targs, i))
goto again;
@@ -30103,12 +30217,15 @@ type_targs_deducible_from (tree tmpl, tree type)
partial specialization can't have default targs. */
targs = coerce_template_parms (tparms, targs, tmpl, tf_none);
if (targs == error_mark_node)
- return false;
+ return NULL_TREE;
/* I believe we don't need the template_template_parm_bindings_ok_p call
because coerce_template_parms did coerce_template_template_parms. */
- return constraints_satisfied_p (tmpl, targs);
+ if (!constraints_satisfied_p (tmpl, targs))
+ return NULL_TREE;
+
+ return targs;
}
/* Return artificial deduction guides built from the constructors of class
@@ -30124,7 +30241,7 @@ ctor_deduction_guides_for (tree tmpl, tsubst_flags_t
complain)
for (ovl_iterator iter (CLASSTYPE_CONSTRUCTORS (type)); iter; ++iter)
{
- /* Skip inherited constructors. */
+ /* We handle C++23 inherited CTAD below. */
if (iter.using_p ())
continue;
@@ -30132,6 +30249,15 @@ ctor_deduction_guides_for (tree tmpl, tsubst_flags_t complain)
cands = lookup_add (guide, cands);
}
+ if (cxx_dialect >= cxx23)
+ for (tree ctor : ovl_range (CLASSTYPE_CONSTRUCTORS (type)))
+ if (TREE_CODE (ctor) == USING_DECL)
+ {
+ tree uguides = inherited_ctad_tweaks (tmpl, ctor, complain);
+ if (uguides)
+ cands = lookup_add (uguides, cands);
+ }
+
/* Add implicit default constructor deduction guide. */
if (!TYPE_HAS_USER_CONSTRUCTOR (type))
{
@@ -30181,7 +30307,10 @@ deduction_guides_for (tree tmpl, bool &any_dguides_p,
tsubst_flags_t complain)
}
/* Cache the deduction guides for a template. We also remember the result of
- lookup, and rebuild everything if it changes; should be very rare. */
+ lookup, and rebuild everything if it changes; should be very rare.
+
+ FIXME: Also rebuild if this is a class template that inherits guides from
a
+ base class, and lookup for the latter changed. */
tree_pair_p cache = NULL;
if (tree_pair_p &r
= hash_map_safe_get_or_insert<hm_ggc> (dguide_cache, tmpl))
diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction67.C
b/gcc/testsuite/g++.dg/cpp1z/class-deduction67.C
index 4624794c4b7..74f92325d7a 100644
--- a/gcc/testsuite/g++.dg/cpp1z/class-deduction67.C
+++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction67.C
@@ -1,5 +1,4 @@
-// Deduction from inherited constructors isn't supported yet, but we shouldn't
-// crash. It may well be supported in C++23.
+// Deduction from inherited constructors isn't supported before C++23.
//{ dg-do compile { target c++17 } }
@@ -17,5 +16,5 @@ int main()
{
B b = 42; // { dg-line init }
// { dg-prune-output "no matching function" }
- // { dg-error "class template argument deduction" "" { target *-*-* } init }
+ // { dg-error "class template argument deduction" "" { target c++23_down }
init }
}
diff --git a/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited1.C
b/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited1.C
new file mode 100644
index 00000000000..5fd1270e819
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited1.C
@@ -0,0 +1,38 @@
+// Modified example from P2582R1
+// { dg-do compile { target c++23 } }
+
+template <typename T> struct B {
+ B(T);
+};
+B(bool) -> B<char>;
+template <typename T> struct C : public B<T> {
+ using B<T>::B;
+};
+template <typename T> struct D : public B<T> {};
+
+C c(42); // OK, deduces C<int>
+using ty1 = decltype(c);
+using ty1 = C<int>;
+
+D d(42); // { dg-error "deduction|no match" }
+
+C c2(true); // OK, deduces C<char>
+using ty2 = decltype(c2);
+using ty2 = C<char>;
+
+template <typename T> struct E : public B<int> {
+ using B<int>::B;
+};
+
+E e(42); // { dg-error "deduction|no match" }
+
+template <typename T, typename U, typename V> struct F {
+ F(T, U, V);
+};
+template <typename T, typename U> struct G : F<U, T, int> {
+ using F<U, T, int>::F;
+};
+
+G g(true, 'a', 1); // OK, deduces G<char, bool>
+using ty3 = decltype(g);
+using ty3 = G<char, bool>;
diff --git a/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited2.C
b/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited2.C
new file mode 100644
index 00000000000..cb3c595f316
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited2.C
@@ -0,0 +1,26 @@
+// { dg-do compile { target c++23 } }
+
+template<class T, class U, class V> struct F {
+ F(T, U, V); // #1
+ F(T*, U*, V*); // #2
+ template<class W>
+ F(int, int, W); // #3
+};
+
+F(bool, bool, bool) -> F<bool*, void*, int>;
+
+template<class T, class U> struct G : F<U, T, int> {
+ using F<U, T, int>::F;
+};
+
+using ty1 = decltype(G(true, 'a', 1)); // uses #1
+using ty1 = G<char, bool>;
+
+using ty2 = decltype(G((bool*)0, (char*)0, (int*)0)); // uses #2
+using ty2 = G<char, bool>;
+
+using ty3 = decltype(G(0, 0, 0)); // uses #3
+using ty3 = G<int, int>;
+
+using ty4 = decltype(G(true, true, true)); // uses #4
+using ty4 = G<void*, bool*>;
diff --git a/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited3.C
b/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited3.C
new file mode 100644
index 00000000000..57e323b5124
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited3.C
@@ -0,0 +1,16 @@
+// { dg-do compile { target c++23 } }
+
+template<class T>
+struct A {
+ A(T);
+ template<class U> A(T, U);
+};
+
+template<class T>
+struct B : A<const T> {
+ using A<const T>::A;
+};
+
+using type = decltype(B(0));
+using type = decltype(B(0, 0));
+using type = B<int>;
diff --git a/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited4.C
b/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited4.C
new file mode 100644
index 00000000000..5e3a7f42919
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/class-deduction-inherited4.C
@@ -0,0 +1,32 @@
+// { dg-do compile { target c++23 } }
+
+template<class T>
+struct A { A(T); };
+
+template<class T>
+struct B : A<T> {
+ using B::A::A; // FIXME: we don't notice this inherited ctor
+};
+
+using ty1 = decltype(B(0)); // { dg-bogus "" "" { xfail *-*-* } }
+using ty1 = B<int>;
+
+template<class T=void>
+struct C : A<int> {
+ using A<int>::A; // FIXME: we don't notice this one either
+};
+
+using ty2 = decltype(C(0)); // { dg-bogus "" "" { xfail *-*-* } }
+using ty2 = C<void>;
+
+template<class T>
+struct D : A<T> {
+ using A<T>::A;
+};
+
+using ty3 = decltype(D(0));
+using ty3 = D<int>;
+
+A(int) -> A<char>; // FIXME: we need to rebuild the guides of D
+using ty4 = decltype(D(0));
+using ty4 = D<char>; // { dg-bogus "conflicting" "" { xfail *-*-* } }
