addressed jason comments.
no regression due to this, tested on x86_64 linux.
On Tue, Oct 27, 2020 at 11:09 PM Jason Merrill <[email protected]> wrote:
>
> On 10/22/20 1:31 PM, kamlesh kumar wrote:
> > Attaching the patch file.
> >
> > >>Instead of building a hash table, would it work to handle ambiguity by
> > >>checking whether one of the classes is a base of the other?
>
> > Fixing for cases like: struct B: A<int>,A<int,int> may not be cleaner
> > this way.
>
> Why not? Your patch does extra work even when there's no ambiguity.
>
> > On Thu, Oct 22, 2020 at 3:23 AM Jason Merrill <[email protected]
> > <mailto:[email protected]>> wrote:
> > >
> > > On 10/21/20 6:32 AM, kamlesh kumar wrote:
> > > > gcc/cp/ChangeLog
> > > > -----------------------------------
> > > >
> > > > 2020-10-21 Kamlesh Kumar <[email protected]
> > <mailto:[email protected]>>
> > > >
> > > > PR c++/97453
> > > > * pt.c (get_template_base): Implement DR2303,
> > > > Consider closest base while template
> > > > deduction when base of base also matches.
> > > >
> > > > gcc/testsuite/ChangeLog
> > > > ------------------------------------------
> > > >
> > > > 2020-10-21 Kamlesh Kumar <[email protected]
> > <mailto:[email protected]>>
> > > >
> > > > * g++.dg/Drs/dr2303.C: New Test
> > > >
> > > > --------------------------------------------------
> > > >
> > > > As part of this patch I Implemented fix for below defect report in cwg
> > > > https://wg21.cmeerw.net/cwg/issue2303 .
> > >
> > > Thanks!
> > >
> > > Please see https://gcc.gnu.org/contribute.html for guidance on email
> > > subject lines; for this patch I'd think something like
> > >
> > > [PATCH] c++: Implement DR2303 [PR97453]
> > >
> > > Also, your patch was corrupted by word wrap; the easiest way to avoid
> > > that is probably to attach the file rather than copy it into the message.
> > >
> > > > Reg tested on x86_64 and did not found any failure.
> > > > Patch summary: Remove base of base from list of bases
> > > >
> > > > created a hash_set from list of bases and then iterate over each
> > > > element of hash_set and find its list of bases and remove this from
> > > > hash_set if present.
> > > > and finally, deduction succeeds if in hash_set remains only single
> > > > element or it's empty.
> > > > otherwise deduction is ambiguous.
> > >
> > > Instead of building a hash table, would it work to handle ambiguity by
> > > checking whether one of the classes is a base of the other?
> > >
> > > > -------------------------------------------------------
> > > > diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
> > > > index dc664ec3798..7adf461e108 100644
> > > > --- a/gcc/cp/pt.c
> > > > +++ b/gcc/cp/pt.c
> > > > @@ -22643,8 +22643,9 @@ static enum template_base_result
> > > > get_template_base (tree tparms, tree targs, tree parm, tree arg,
> > > > bool explain_p, tree *result)
> > > > {
> > > > - tree rval = NULL_TREE;
> > > > + *result = NULL_TREE;
> > > > tree binfo;
> > > > + hash_set<tree> binfo_set;
> > > >
> > > > gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
> > > >
> > > > @@ -22659,31 +22660,51 @@ get_template_base (tree tparms, tree targs,
> > > > tree parm, tree arg,
> > > > /* Walk in inheritance graph order. The search order is not
> > > > important, and this avoids multiple walks of virtual bases. */
> > > > for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
> > > > - {
> > > > - tree r = try_class_unification (tparms, targs, parm,
> > > > - BINFO_TYPE (binfo), explain_p);
> > > > -
> > > > - if (r)
> > > > - {
> > > > - /* If there is more than one satisfactory baseclass, then:
> > > > -
> > > > - [temp.deduct.call]
> > > > + {
> > > > + tree r = try_class_unification (tparms, targs, parm,
> > > > + BINFO_TYPE (binfo), explain_p);
> > > > + if (r)
> > > > + {
> > > > + binfo_set.add(r);
> > > > + }
> > > > + }
> > > >
> > > > - If they yield more than one possible deduced A, the type
> > > > - deduction fails.
> > > > + /* If there is more than one satisfactory baseclass, then:
> > > > + [temp.deduct.call]
> > > > + If they yield more than one possible deduced A, the type
> > > > + deduction fails.
> > > > + However, if there is a class C that is a (direct or indirect)
> > > > base class of
> > > > + D and derived (directly or indirectly) from a class B and
> > that would be a
> > > > + valid deduced A, the deduced A cannot be B or pointer to B,
> > > > respectively. */
> > > > + for (hash_set<tree>::iterator it = binfo_set.begin();
> > > > + it != binfo_set.end(); ++it)
> > > > + {
> > > > + binfo = TYPE_BINFO (*it);
> > > > + for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN
> > (binfo))
> > > > + {
> > > > + tree r = try_class_unification (tparms, targs, parm,
> > > > + BINFO_TYPE (binfo), explain_p);
> > > > + if (r && binfo_set.contains(r))
> > > > + {
> > > > + binfo_set.remove(r);
> > > > + }
> > > > + }
> > > > + }
> > > >
> > > > - applies. */
> > > > - if (rval && !same_type_p (r, rval))
> > > > - {
> > > > - *result = NULL_TREE;
> > > > - return tbr_ambiguous_baseclass;
> > > > - }
> > > > + if (binfo_set.elements() > 1)
> > > > + {
> > > > + return tbr_ambiguous_baseclass;
> > > > + }
> > > >
> > > > - rval = r;
> > > > - }
> > > > + if (binfo_set.is_empty())
> > > > + {
> > > > + return tbr_success;
> > > > }
> > > >
> > > > - *result = rval;
> > > > + if (binfo_set.elements() == 1)
> > > > + {
> > > > + *result = *binfo_set.begin();
> > > > + }
> > > > return tbr_success;
> > > > }
> > > >
> > > > diff --git a/gcc/testsuite/g++.dg/DRs/dr2303.C
> > > > b/gcc/testsuite/g++.dg/DRs/dr2303.C
> > > > new file mode 100644
> > > > index 00000000000..b4c23332358
> > > > --- /dev/null
> > > > +++ b/gcc/testsuite/g++.dg/DRs/dr2303.C
> > > > @@ -0,0 +1,20 @@
> > > > +// DR 2303
> > > > +// PR c++/97453
> > > > +// { dg-do compile { target c++11 } }
> > > > +
> > > > +template <typename... T>
> > > > +struct A;
> > > > +template <>
> > > > +struct A<> {};
> > > > +template <typename T, typename... Ts>
> > > > +struct A<T, Ts...> : A<Ts...> {};
> > > > +struct B : A<int, int> {};
> > > > +
> > > > +template <typename... T>
> > > > +void f(const A<T...> &) {
> > > > + static_assert(sizeof...(T) == 2, "it should duduce to A<int,int>");
> > > > +}
> > > > +
> > > > +void g() {
> > > > + f(B{});
> > > > +}
> > > > --------------------------------
> > > >
> > > > ./kamlesh
> > > >
> > >
>
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index aa162d2a4f9..c8ce506ae61 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -22663,6 +22663,8 @@ get_template_base (tree tparms, tree targs, tree parm, tree arg,
{
tree rval = NULL_TREE;
tree binfo;
+ hash_set<tree> bases;
+ bool ambigious_p = false;
gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (arg)));
@@ -22683,24 +22685,50 @@ get_template_base (tree tparms, tree targs, tree parm, tree arg,
if (r)
{
- /* If there is more than one satisfactory baseclass, then:
-
- [temp.deduct.call]
-
- If they yield more than one possible deduced A, the type
- deduction fails.
-
- applies. */
if (rval && !same_type_p (r, rval))
{
- *result = NULL_TREE;
- return tbr_ambiguous_baseclass;
+ ambigious_p = true;
+ break;
}
rval = r;
}
}
+ /* [temp.deduct.call] :
+ If there is a class C that is a (direct or indirect) base class of D and
+ derived (directly or indirectly) from a class B and that would be a valid
+ deduced A, the deduced A cannot be B or pointer to B, respectively. */
+ if (ambigious_p)
+ {
+ binfo = TYPE_BINFO (complete_type (arg));
+ for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
+ {
+ tree r = try_class_unification (tparms, targs, parm,
+ BINFO_TYPE (binfo), explain_p);
+ bases.add (r);
+ }
+
+ for (hash_set<tree>::iterator it = bases.begin (); it != bases.end ();
+ ++it)
+ {
+ binfo = TYPE_BINFO (*it);
+ for (binfo = TREE_CHAIN (binfo); binfo; binfo = TREE_CHAIN (binfo))
+ {
+ tree r = try_class_unification (tparms, targs, parm,
+ BINFO_TYPE (binfo), explain_p);
+ if (bases.contains (r))
+ bases.remove (r);
+ }
+ }
+
+ if (bases.elements () > 1)
+ {
+ *result = NULL_TREE;
+ return tbr_ambiguous_baseclass;
+ }
+ rval = *bases.begin ();
+ }
*result = rval;
return tbr_success;
}
diff --git a/gcc/testsuite/g++.dg/DRs/dr2303.C b/gcc/testsuite/g++.dg/DRs/dr2303.C
new file mode 100644
index 00000000000..b6acb6e2197
--- /dev/null
+++ b/gcc/testsuite/g++.dg/DRs/dr2303.C
@@ -0,0 +1,37 @@
+// DR 2303
+// PR c++/97453
+// { dg-do compile { target c++11 } }
+
+template <typename... T> struct A;
+template <> struct A<>
+{
+};
+template <typename T, typename... Ts> struct A<T, Ts...> : A<Ts...>
+{
+};
+struct B : A<int, int>
+{
+};
+
+struct C : A<int, int>, A<int> // { dg-warning "direct base .A<int>. inaccessible in .C. due to ambiguity" }
+{
+};
+
+struct D : A<int>, A<int, int> // { dg-warning "direct base .A<int>. inaccessible in .D. due to ambiguity" }
+{
+};
+template <typename... T>
+void
+f (const A<T...> &)
+{
+ static_assert (sizeof...(T) == 2, "it should duduce to A<int,int>");
+}
+
+
+void
+g ()
+{
+ f (B{});
+ f (C{});
+ f (D{});
+}
