[Bug c++/17122] Unable to compile friend operator within template

[Bug c++/17122] Unable to compile friend operator within template

[redi at gcc dot gnu.org]

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

--- Comment #13 from Jonathan Wakely <redi at gcc dot gnu.org> 2012-04-12 12:44:13 UTC ---
Are any of the examples in this PR actually valid?

I think G++ is correct to reject them.

foo ::operator+ is parsed the same as foo::operator+ so still finds the member
function, the parentheses prevent that.

[Bug c++/17122] Unable to compile friend operator within template

[manu at gcc dot gnu.org]

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

Manuel López-Ibáñez <manu at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |manu at gcc dot gnu.org

--- Comment #14 from Manuel López-Ibáñez <manu at gcc dot gnu.org> 2012-04-12 13:05:16 UTC ---
(In reply to comment #13)
> Are any of the examples in this PR actually valid?
> 
> I think G++ is correct to reject them.
> 
> foo ::operator+ is parsed the same as foo::operator+ so still finds the member
> function, the parentheses prevent that.

Maybe g++ is correct to reject them, but the diagnostics printed are awful.
They are actually worse than saying:

error: Something is wrong somewhere, Please fix it.

template <class blah>                                                           
class foo;                                                                      

template <class blah>                                                           
void operator+(int, foo<blah>);                                                 

template <class blah>                                                           
void operator-(int, foo<blah>);                                                 

template <class blah>                                                           
class foo                                                                       
{                                                                               
public:                                                                         
  void operator+(int){}                                                         
  friend void operator+<>(int, foo);//eliminating <> generates warning to add 
                                    //them                                      
  friend void operator-(int, foo);//eliminating <> generates warning to add 
                                    //them                                      

};                                                                              
template <class blah>                                                           
void operator+(int, foo<blah>){}                                                

template <class blah>                                                           
void operator-(int, foo<blah>){}                                                

int main()                                                                      
{                                                                               
  foo<double> inst;                                                             
  inst+1;                                                                       
  1+inst;                                                                       
};

pr17122.C:15:23: error: declaration of ‘operator+’ as non-function
   friend void operator+<>(int, foo);//eliminating <> generates warning to add 
                       ^
pr17122.C:15:23: error: expected ‘;’ at end of member declaration
   friend void operator+<>(int, foo);//eliminating <> generates warning to add 
                       ^
pr17122.C:15:24: error: expected unqualified-id before ‘<’ token
   friend void operator+<>(int, foo);//eliminating <> generates warning to add 
                        ^
pr17122.C:17:33: warning: friend declaration ‘void operator-(int, foo<blah>)’
declares a non-template function [-Wnon-template-friend]
   friend void operator-(int, foo);//eliminating <> generates warning to add 
                                 ^
pr17122.C:17:33: note: (if this is not what you intended, make sure the
function template has already been declared and add <> after the function name
here) 
   friend void operator-(int, foo);//eliminating <> generates warning to add 
                                 ^

[Bug c++/17122] Unable to compile friend operator within template

[redi at gcc dot gnu.org]

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

--- Comment #15 from Jonathan Wakely <redi at gcc dot gnu.org> 2012-04-12 14:07:00 UTC ---

> pr17122.C:17:33: warning: friend declaration ‘void operator-(int, foo<blah>)’
> declares a non-template function [-Wnon-template-friend]
>    friend void operator-(int, foo);//eliminating <> generates warning to add 
>                                  ^
> pr17122.C:17:33: note: (if this is not what you intended, make sure the
> function template has already been declared and add <> after the function name
> here) 
>    friend void operator-(int, foo);//eliminating <> generates warning to add 
>                                  ^

Well at least this warning is correct.  For operator- it's 100% correct.  It
causes a problem for operator+ because that clashes with the name of a member
function, so the hint is right but not sufficient to tell you how to make the
code compile, because there's still another error.  You also need to prevent
name lookup from finding the member with the same name.


The example can be reduced to this, replacing operators with named functions:

template <class blah>
struct foo;

template <class blah>
void f(int, foo<blah>) { }

template <class blah>
void g(int, foo<blah>) { }

template <class blah>
struct foo
{
  void f(int) {}

  friend void f<>(int, foo);

  friend void g(int, foo);
};

The warning about 'g' is correct.  The error for 'f' is different now, giving
the "declared void" instead of "as non-function"

[Bug c++/17122] Unable to compile friend operator within template

[redi at gcc dot gnu.org]

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

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |tkapela at poczta dot fm

--- Comment #16 from Jonathan Wakely <redi at gcc dot gnu.org> 2012-04-12 14:55:08 UTC ---
*** Bug 30431 has been marked as a duplicate of this bug. ***

[Bug c++/17122] Unable to compile friend operator within template

[sixenin at hotmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=17122

Michael Chase <sixenin at hotmail dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |sixenin at hotmail dot com

--- Comment #17 from Michael Chase <sixenin at hotmail dot com> ---
gcc version 4.8.3 (Gentoo 4.8.3 p1.1, pie-0.5.9) 

I spent about 1.5 hours this morning trying to determine why I couldn't use a
friend operator in a class only to stumble upon this ancient bug. If the bug is
inviolation of the standard, can we please get it escalated?

[Bug c++/17122] Unable to compile friend operator within template

[relf at os2 dot ru]

------- Comment #12 from relf at os2 dot ru  2006-03-12 04:14 -------
(In reply to comment #11)

>   friend foo ::operator+ <>(int, foo);

I have changed it to

   friend foo (::operator+ <>) (int, foo);

and now it's being compiled fine.


-- 


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

[Bug c++/17122] Unable to compile friend operator within template

[relf at os2 dot ru]

------- Comment #11 from relf at os2 dot ru  2006-01-24 02:38 -------
Let's change returning type of friend operator+ in the original example to
foo<blah>, i.e.,

=====
template <class blah>                                                           
class foo;                                                                      

template <class blah>                                                           
foo<blah> operator+(int, foo<blah>);

template <class blah>                                                           
class foo {
public:                                                                         
  void operator+(int){}                                                         
  friend foo ::operator+ <>(int, foo);
};                                                                              
template <class blah>                                                           
foo<blah> operator+(int, foo<blah>){}

int main()                                                                      
{                                                                               
  foo<double> inst;                                                             
  inst+1;                                                                       
  1+inst;                                                                       
};
=====

Then g++ 4.0.3 reports weird error:\

a.cpp:11: error: non-template 'operator+' used as template
a.cpp:11: note: use 'foo<blah>::template operator+' to indicate that it is a
template
a.cpp:11: error: declaration of 'operator+' as non-function

What is wrong here? Should this behavior be filed as a separate bugreport?


-- 


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

[Bug c++/17122] Unable to compile friend operator within template

[relf at os2 dot ru]

------- Comment #10 from relf at os2 dot ru  2006-01-22 04:15 -------
Works fine on g++ 3.3.6 but fails on g++ 3.4.5 and 4.0.3.
Must be a regression.


-- 


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

[Bug c++/17122] Unable to compile friend operator within template

[pinskia at gcc dot gnu dot org]

------- Comment #9 from pinskia at gcc dot gnu dot org  2006-01-20 04:39 -------
*** Bug 25867 has been marked as a duplicate of this bug. ***


-- 

pinskia at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |relf at os2 dot ru


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

[Bug c++/17122] Unable to compile friend operator within template

[lerdsuwa at gcc dot gnu dot org]

------- Comment #8 from lerdsuwa at gcc dot gnu dot org  2005-10-22 13:58 -------
Won't work on it for a long while.


-- 

lerdsuwa at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         AssignedTo|lerdsuwa at gcc dot gnu dot |unassigned at gcc dot gnu
                   |org                         |dot org
             Status|ASSIGNED                    |NEW


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

[Bug c++/17122] Unable to compile friend operator within template

[pinskia at gcc dot gnu dot org]

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |rejects-valid
   Last reconfirmed|2004-08-20 15:20:16         |2005-01-16 01:26:56
               date|                            |


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

[Bug c++/17122] Unable to compile friend operator within template

[lerdsuwa at gcc dot gnu dot org]

------- Additional Comments From lerdsuwa at gcc dot gnu dot org  2004-10-17 15:21 -------
Will look at it while fixing friend class lookup.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
         AssignedTo|unassigned at gcc dot gnu   |lerdsuwa at gcc dot gnu dot
                   |dot org                     |org
             Status|REOPENED                    |ASSIGNED


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

[Bug c++/17122] Unable to compile friend operator within template

[lerdsuwa at gcc dot gnu dot org]

------- Additional Comments From lerdsuwa at gcc dot gnu dot org  2004-10-17 15:19 -------
Reopen this bug since friend class and friend function bugs
will be addressed separately.  PR1016 is likely to be fixed before
this one.

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|RESOLVED                    |REOPENED
         Resolution|DUPLICATE                   |


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

[Bug c++/17122] Unable to compile friend operator within template

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2004-08-23 18:35 -------
We have already a PR about DR 166 is closing as a dup of that bug.

*** This bug has been marked as a duplicate of 1016 ***

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |RESOLVED
         Resolution|                            |DUPLICATE


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

[Bug c++/17122] Unable to compile friend operator within template

[ron at vaniwaarden dot org]

------- Additional Comments From ron at vaniwaarden dot org  2004-08-23 18:30 -------
(In reply to comment #2)
> Note that this works though:
> friend void ::operator+<>(int, foo);
> 
> I think this is correct as Comeau C++ also rejects the code and accepts the above.

Here is some additional information from the C++ standards committee:
http://std.dkuug.dk/jtc1/sc22/wg21/docs/cwg_defects.html#166

>From my point of view, I would consider this resolved.

--Ron

-- 


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

[Bug c++/17122] Unable to compile friend operator within template

[ron at vaniwaarden dot org]

------- Additional Comments From ron at vaniwaarden dot org  2004-08-20 16:35 -------
(In reply to comment #2)
> Note that this works though:
> friend void ::operator+<>(int, foo);
> 
> I think this is correct as Comeau C++ also rejects the code and accepts the above.

Interesting.  Well, I learn something every day because if the return type is
int rather than void, the code must be

int friend ::operator+<>(int foo)

and I never knew the 'friend' went anywhere other than at the begining of the
line...

-- 


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

[Bug c++/17122] Unable to compile friend operator within template

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2004-08-20 15:53 -------
Note that this works though:
friend void ::operator+<>(int, foo);

I think this is correct as Comeau C++ also rejects the code and accepts the above.

-- 


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

[Bug c++/17122] Unable to compile friend operator within template

[bangerth at dealii dot org]

------- Additional Comments From bangerth at dealii dot org  2004-08-20 15:20 -------
Confirmed. 
W. 

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
     Ever Confirmed|                            |1
   Last reconfirmed|0000-00-00 00:00:00         |2004-08-20 15:20:16
               date|                            |


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