[Bug c++/13590] New: unexpected overload resolution

[Bug c++/13590] New: unexpected overload resolution

[boris at kolpackov dot net]

$ cat >test.cpp
struct Edge
{
};

struct Node
{
  void f (Edge&);
};


struct AE : virtual Edge
{
};

struct AN : virtual Node
{
  void f (AE&);
  using Node::f;
};

struct BN : virtual Node
{
  using Node::f;
};

struct CN : virtual AN, virtual BN
{
};

void f ()
{
  AE e;
  CN n;
  n.f (e);
}

$ g++ --version
g++ (GCC) 3.3.3 20031229 (prerelease) (Debian)
$ g++ -c ./test.cpp
test.cpp: In function `void f()':
test.cpp:34: error: request for member `f' is ambiguous
test.cpp:7: error: candidates are: void Node::f(Edge&)
test.cpp:7: error:                 void Node::f(Edge&)
test.cpp:17: error:                 void AN::f(AE&)
$

-- 
           Summary: unexpected overload resolution
           Product: gcc
           Version: 3.3.3
            Status: UNCONFIRMED
          Severity: normal
          Priority: P2
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: boris at kolpackov dot net
                CC: gcc-bugs at gcc dot gnu dot org
 GCC build triplet: i386-gnu-lnux
  GCC host triplet: i386-gnu-lnux
GCC target triplet: i386-gnu-lnux


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] unexpected overload resolution

[bangerth at dealii dot org]

------- Additional Comments From bangerth at dealii dot org  2004-01-06 21:10 -------
I'm no expert in "using" things, but this really seems odd: 
------------------ 
struct Node { 
  void f (int); 
}; 
 
struct AN : virtual Node { 
  using Node::f; 
}; 
 
struct BN : virtual Node { 
  using Node::f; 
}; 
 
struct CN : virtual AN, virtual BN {}; 
 
void f () { 
  CN n; 
  n.f (1); 
} 
------------------------------- 
 
With all gcc versions since 3.2 I get this: 
g/x> /home/bangerth/bin/gcc-3.4-pre/bin/c++ -c x.cc 
x.cc: In function `void f()': 
x.cc:17: error: request for member `f' is ambiguous 
x.cc:2: error: candidates are: void Node::f(int) 
x.cc:2: error:                 void Node::f(int) 
 
On the other hand, gcc2.95 and icc accept the code. I have no idea 
who's right, though. 
 
W. 
 

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] unexpected overload resolution

[boris at kolpackov dot net]

------- Additional Comments From boris at kolpackov dot net  2004-01-06 21:55 -------
Subject: Re:  unexpected overload resolution

After some more thinking I tend to believe that the two examples 
above and the code below should at least behave in a consistent
manner (i.e. all fail or all compile):

namespace A
{
  void f (char);
}

namespace B
{
  void f (char);
}

namespace C
{
  void f (int);
}

void g ()
{
  using namespace A;
  using namespace B;
  using namespace C;

  int i;
  f (i);
}

GCC 3.3.3 compiles this example fine.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] unexpected overload resolution

[bangerth at dealii dot org]

------- Additional Comments From bangerth at dealii dot org  2004-01-06 23:00 -------
That's not a good example. The using directive for A::f and B::f create 
an ambiguity, but this only needs to be detected when you try to call 
one of the functions, i.e. during overload resolution, not when the 
using directive is parsed. However, you call f(int), and there is no 
ambiguity in this case. 
 
W. 

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] unexpected overload resolution

[boris at kolpackov dot net]

------- Additional Comments From boris at kolpackov dot net  2004-01-06 23:15 -------
Subject: Re:  unexpected overload resolution

> That's not a good example. The using directive for A::f and B::f create 
> an ambiguity, but this only needs to be detected when you try to call 
> one of the functions, i.e. during overload resolution, not when the 
> using directive is parsed. 

Agree.

> However, you call f(int), and there is no ambiguity in this case.

Doesn't the overload resolution happens when I call f(int) ? And
according to what you just said it should be flagged as an error.
 
And thus, I think, it's a very good example ;-)

What I was trying to say is that when the same processes (overload 
resolution) happens in similar situations (ambiguilty in class 
inheritance vs ambiguilty in using directive) it would be nice if 
it had the same result (consistency).


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] unexpected overload resolution

[bangerth at dealii dot org]

------- Additional Comments From bangerth at dealii dot org  2004-01-07 14:00 -------
There is no ambiguity in the call to f(int), because there is only 
one such function. That there might be an ambiguity for other argument 
types is irrelevant. 
 
There is also no ambiguity in my shortened example (and your original 
code): the base class is virtual, so there is exactly one copy and 
no ambiguity with what "this" pointer it has to be called. That doesn't 
mean, however, that a compiler is supposed to detect this special case 
of virtual base classes, though.  
 
W. 

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4 regression] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[giovannibajo at libero dot it]

------- Additional Comments From giovannibajo at libero dot it  2004-01-11 01:05 -------
Confirmed with Wolfgang testcase:
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590#c1

There is only one Node base class because of the virtual inheritance, so there 
is only one Node::f function. There is no ambiguity. When the lookup is 
performed, it should be noted that the two using declarations *do* refer to the 
same declaration on the same base object.

Boris, as Wolfgang explained, your other testcase is indeed non ambigous and 
correctly accepted by GCC since, at the point of call, there is only one and 
only one "best" overload.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
     Ever Confirmed|                            |1
           Keywords|                            |rejects-valid
   Last reconfirmed|0000-00-00 00:00:00         |2004-01-11 01:05:06
               date|                            |
            Summary|unexpected overload         |[3.3/3.4 regression] Non-
                   |resolution                  |existing ambiguity when
                   |                            |inhering through virtuals
                   |                            |two identical using
                   |                            |declarations.
   Target Milestone|---                         |3.4.0


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4 regression] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2004-01-11 01:13 -------
This has been failing since at least 2000-12-31, this is a regression from 2.95.3.

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/3.5 regression] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[nathan at gcc dot gnu dot org]

------- Additional Comments From nathan at gcc dot gnu dot org  2004-03-05 14:44 -------
I am not conviced this code is valid. [10.2] describes member name lookup
in an MI lattice, and says that 'each declaration that was introduced by a
using-declaration is considered to be from each subobject of C that is of the
type containg the declaration descignated by the using declaration'. ... 'if the
resulting set of declarations are not all from sbobjects of the same type ...
there is an ambiguity'.  Whilst those rules make sense for data members, they do
not for function members.  The set of overloaded functions can include some from
a base, brought in by a using declaration, and some declared in the class
containing the using declaration [7.3.3]/12   If those from the base were
considered to actually be from the base, then we'd have a set from differnt
types, so be ambiguous.

Thus, I think we have to consider overloaded functions to be from the class
containing the using declaration (and not the class being used).  If that is the
case, then the code is ill-formed, even though both using declarations refer to
the same unambiguous base object.

The original testcase had added an overload on one path through the graph, if we
augment the case with an additional overload on the other path, it quite clearly
must be ambiguous (because it would be without the using declarations).

Wolfgang's reduced test case, with just using declarations it the other
interesting example.  If we treat this as ambiguous, then it appears that (in
other useages), we could use using declarations to resolve inherited member
ambiguities -- something expressly forbidden by [10.2] (footnote 96).  So this
argues that the reduced case should be well formed.

But, now we have some strangeness.  Whether a function using declaration's
naming class is the class of the using declaration of the class of the used
declaration depends on whether there are any additional overloads.

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/3.5 regression] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[giovannibajo at libero dot it]

------- Additional Comments From giovannibajo at libero dot it  2004-03-05 14:56 -------
Nathan, can you raise this issue with the CWG? Maybe we can have some lights 
shed on this eventually. If you do that, we can suspend this bug until there is 
a clear position on the matter.


-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |nathan at gcc dot gnu dot
                   |                            |org


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/3.5 regression] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[mmitchel at gcc dot gnu dot org]

------- Additional Comments From mmitchel at gcc dot gnu dot org  2004-03-09 07:40 -------
We're not even convinced yet that this is a bug, so I'm postponing this until 3.4.1.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|3.4.0                       |3.4.1


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/3.5 regression] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[jason at gcc dot gnu dot org]

------- Additional Comments From jason at gcc dot gnu dot org  2004-06-10 20:10 -------
This is a bug in the standard, which the CWG has been working on fixing for
quite a while:

http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#39


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/3.5 regression] [DR39] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2004-06-10 22:19 -------
Suspending as the DR report is in review.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|WAITING                     |SUSPENDED
            Summary|[3.3/3.4/3.5 regression]    |[3.3/3.4/3.5 regression]
                   |Non-existing ambiguity when |[DR39] Non-existing
                   |inhering through virtuals   |ambiguity when inhering
                   |two identical using         |through virtuals two
                   |declarations.               |identical using
                   |                            |declarations.


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/3.5 regression] [DR39] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[mmitchel at gcc dot gnu dot org]

------- Additional Comments From mmitchel at gcc dot gnu dot org  2004-06-18 23:46 -------
Postponed until GCC 3.4.2.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|3.4.1                       |3.4.2


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/3.5 regression] [DR39] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[boris at kolpackov dot net]

------- Additional Comments From boris at kolpackov dot net  2004-08-03 14:31 -------
Just found a non-academic example when this really hurts:

template<typename x>
struct base
{
  void f ();
};


template <typename x>
struct a : virtual base<x>
{
  using base<x>::f;  // which f

  void g ()
  {
    f ();
  }
};

template <typename x>
struct b : virtual base<x>
{
  using base<x>::f; // which f

  void g ()
  {
    f ();
  }
};

struct c : a<int>, b<int> {};

void
f ()
{
  c c_;
  c_.f ();
}

Here I use using-declaration to hind the compiler which f() I am using since it
does not depend on template parameter in any way. The result - call to c_.f ()
is ambiguous - IMO, is ridiculous.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/3.5 regression] [DR39] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[pinskia at gcc dot gnu dot org]

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|3.4.2                       |3.5.0


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [3.3/3.4/4.0 regression] [DR39] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2004-10-19 11:37 -------
Unsetting the target milestone as there is a stil opened DR about this.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
      Known to fail|3.4.1 4.0                   |3.4.1 4.0.0
   Target Milestone|4.0.0                       |---


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [DR39] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[redi at gcc dot gnu dot org]

------- Additional Comments From redi at gcc dot gnu dot org  2005-08-31 19:27 -------
As DR39 has been ruled a defect, this should be re-opened.

-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [DR39] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[pinskia at gcc dot gnu dot org]

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|SUSPENDED                   |NEW
   Last reconfirmed|2005-07-12 22:07:51         |2005-08-31 19:34:41
               date|                            |


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590

[Bug c++/13590] [DR39] Non-existing ambiguity when inhering through virtuals two identical using declarations.

[gcc-bugzilla at kayari dot org]

------- Comment #19 from gcc-bugzilla at kayari dot org  2005-12-10 13:17 -------
would the summary be clarified by changing "Non-existing ambiguity when
inhering through virtuals two identical using declarations" to "Ambiguity due
to two using declarations for same member of virtual base" ?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=13590