On 11/2/20 10:10 AM, kamlesh kumar wrote:
addressed jason comments.
no regression due to this, tested on x86_64 linux.
On Tue, Oct 27, 2020 at 11:09 PM Jason Merrill <ja...@redhat.com> 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 <ja...@redhat.com
<mailto:ja...@redhat.com>> wrote:
>
> On 10/21/20 6:32 AM, kamlesh kumar wrote:
> > gcc/cp/ChangeLog
> > -----------------------------------
> >
> > 2020-10-21 Kamlesh Kumar <kamleshbha...@gmail.com
<mailto:kamleshbha...@gmail.com>>
> >
> > 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 <kamleshbha...@gmail.com
<mailto:kamleshbha...@gmail.com>>
> >
> > * 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?
This is what I had in mind; it seems clearer to me. Do you see a reason
this wouldn't work?
Also, I notice that you still don't seem to have a copyright assignment
on file with the FSF. I and Jonathan Wakely both asked about it last
year; has there been any progress on that? Your patch is too large to
go in without a copyright assignment, so it's probably simplest to go
ahead with mine.
Thanks,
Jason
commit 6b0fc692d57f38ec69ea739117ac3d4552cd0d23
Author: kamlesh kumar <kamleshbha...@gmail.com>
Date: Mon Nov 2 20:40:21 2020 +0530
c++: Implement DR2303 [PR97453]
gcc/cp/ChangeLog
2020-10-21 Kamlesh Kumar <kamleshbha...@gmail.com>
Jason Merrill <ja...@redhat.com>
PR c++/97453
DR2303
* 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 <kamleshbha...@gmail.com>
g++.dg/DRs/dr2303.C: New test.
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index f31a1a70473..245b7a83a92 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -22693,8 +22693,20 @@ get_template_base (tree tparms, tree targs, tree parm, tree arg,
applies. */
if (rval && !same_type_p (r, rval))
{
- *result = NULL_TREE;
- return tbr_ambiguous_baseclass;
+ /* [temp.deduct.call]/4.3: 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 (DERIVED_FROM_P (r, rval))
+ /* Ignore r. */
+ continue;
+ else if (DERIVED_FROM_P (rval, r))
+ /* Discard rval. */;
+ else
+ {
+ *result = NULL_TREE;
+ return tbr_ambiguous_baseclass;
+ }
}
rval = r;
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{});
+}
