[Bug c++/45012] New: Invalid ambiguity on partial class specialization matching

[Bug c++/45012] New: Invalid ambiguity on partial class specialization matching

[rodolfo at rodsoft dot org]

The following code doesn't compile unless variable RUNTIME is defined as a
"static const int" instead of an "enum":

#include <type_traits>

enum { RUNTIME = 0 };
// it compiles with the previous line commented out and the next commented in
// static const int RUNTIME=0;

template <class T, class U, class EN=void> struct foo;

template <template<int> class V, int M>
struct foo<V<M>,V<M>, typename std::enable_if<M==RUNTIME || M==2>::type> {};

template <template<int> class V1, template<int> class V2, int M>
struct foo<V1<M>,V2<M>, typename std::enable_if<M==RUNTIME || M==2>::type> {};

template <int M> struct bar {};

foo<bar<2>,bar<2>> x;


-- 
           Summary: Invalid ambiguity on partial class specialization
                    matching
           Product: gcc
           Version: 4.5.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: rodolfo at rodsoft dot org
 GCC build triplet: x86_64-pc-linux-gnu
  GCC host triplet: x86_64-pc-linux-gnu
GCC target triplet: x86_64-pc-linux-gnu


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

[Bug c++/45012] Invalid ambiguity on partial class specialization matching

[rodolfo at rodsoft dot org]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1338 bytes --]



------- Comment #1 from rodolfo at rodsoft dot org  2010-07-21 02:49 -------
The code I posted was meant to be compiled in c++0x mode, but if we write
directly the definition of std::enable_if, it also happens in c++03 mode.
So, instead of #include <type_traits>, one should write:

template <bool B, class T=void> struct enable_if;

template <class T>
struct enable_if<true,T> 
{  
    typedef T type;
};

Of course, I forgot to add the error messages:

teste.cpp:30: error: ambiguous class template instantiation for ‘struct
foo<bar<2>, bar<2>, void>’
teste.cpp:19: error: candidates are: struct foo<V<M>, V<M>, typename
enable_if<((M == RUNTIME) || (M == 2)), void>::type>
teste.cpp:25: error:                 struct foo<V1<M>, V2<M>, typename
enable_if<((M == RUNTIME) || (M == 2)), void>::type>
teste.cpp:30: error: aggregate ‘foo<bar<2>, bar<2>, void> x’ has incomplete
type and cannot be defined


-- 

rodolfo at rodsoft dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |rodolfo at rodsoft dot org
           Keywords|                            |rejects-valid
      Known to fail|                            |4.4.3 4.5.0


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

Re: [Bug c++/45012] New: Invalid ambiguity on partial class specialization matching

[Andrew Pinski]

On Jul 20, 2010, at 7:43 PM, "rodolfo at rodsoft dot org" <gcc-bugzilla@gcc.gnu.org 
 > wrote:

> The following code doesn't compile unless variable RUNTIME is  
> defined as a
> "static const int" instead of an "enum":
>

This enum value has an anonymous type which is not valid in the  
context of templates in C++03/98. It is valid in the current draft of C 
++0x though. But I cannot remember if 4.5 implements that rule for - 
std=gnu++0x (-std=c++0x).



> #include <type_traits>
>
> enum { RUNTIME = 0 };
> // it compiles with the previous line commented out and the next  
> commented in
> // static const int RUNTIME=0;
>
> template <class T, class U, class EN=void> struct foo;
>
> template <template<int> class V, int M>
> struct foo<V<M>,V<M>, typename std::enable_if<M==RUNTIME ||  
> M==2>::type> {};
>
> template <template<int> class V1, template<int> class V2, int M>
> struct foo<V1<M>,V2<M>, typename std::enable_if<M==RUNTIME ||  
> M==2>::type> {};
>
> template <int M> struct bar {};
>
> foo<bar<2>,bar<2>> x;
>
>
> -- 
>           Summary: Invalid ambiguity on partial class specialization
>                    matching
>           Product: gcc
>           Version: 4.5.0
>            Status: UNCONFIRMED
>          Severity: normal
>          Priority: P3
>         Component: c++
>        AssignedTo: unassigned at gcc dot gnu dot org
>        ReportedBy: rodolfo at rodsoft dot org
> GCC build triplet: x86_64-pc-linux-gnu
>  GCC host triplet: x86_64-pc-linux-gnu
> GCC target triplet: x86_64-pc-linux-gnu
>
>
> http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45012
>

[Bug c++/45012] Invalid ambiguity on partial class specialization matching

[pinskia at gmail dot com]

------- Comment #2 from pinskia at gmail dot com  2010-07-21 02:53 -------
Subject: Re:   New: Invalid ambiguity on partial class specialization matching



On Jul 20, 2010, at 7:43 PM, "rodolfo at rodsoft dot org"
<gcc-bugzilla@gcc.gnu.org 
 > wrote:

> The following code doesn't compile unless variable RUNTIME is  
> defined as a
> "static const int" instead of an "enum":
>

This enum value has an anonymous type which is not valid in the  
context of templates in C++03/98. It is valid in the current draft of C 
++0x though. But I cannot remember if 4.5 implements that rule for - 
std=gnu++0x (-std=c++0x).



> #include <type_traits>
>
> enum { RUNTIME = 0 };
> // it compiles with the previous line commented out and the next  
> commented in
> // static const int RUNTIME=0;
>
> template <class T, class U, class EN=void> struct foo;
>
> template <template<int> class V, int M>
> struct foo<V<M>,V<M>, typename std::enable_if<M==RUNTIME ||  
> M==2>::type> {};
>
> template <template<int> class V1, template<int> class V2, int M>
> struct foo<V1<M>,V2<M>, typename std::enable_if<M==RUNTIME ||  
> M==2>::type> {};
>
> template <int M> struct bar {};
>
> foo<bar<2>,bar<2>> x;
>
>
> -- 
>           Summary: Invalid ambiguity on partial class specialization
>                    matching
>           Product: gcc
>           Version: 4.5.0
>            Status: UNCONFIRMED
>          Severity: normal
>          Priority: P3
>         Component: c++
>        AssignedTo: unassigned at gcc dot gnu dot org
>        ReportedBy: rodolfo at rodsoft dot org
> GCC build triplet: x86_64-pc-linux-gnu
>  GCC host triplet: x86_64-pc-linux-gnu
> GCC target triplet: x86_64-pc-linux-gnu
>
>
> http://gcc.gnu.org/bugzilla/show_bug.cgi?id=45012
>


-- 


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

[Bug c++/45012] Invalid ambiguity on partial class specialization matching

[rodolfo at rodsoft dot org]

------- Comment #3 from rodolfo at rodsoft dot org  2010-07-21 03:03 -------
(In reply to comment #2)
> This enum value has an anonymous type which is not valid in the  
> context of templates in C++03/98. It is valid in the current draft of C 
> ++0x though. But I cannot remember if 4.5 implements that rule for - 
> std=gnu++0x (-std=c++0x).

But I'm not using that anonymous type for template argument deduction (i.e.:
foo<bar<RUNTIME>,bar<RUNTIME>>), I'm just using in a comparison with an int.
But even if I turn it into a named type (i.e.: enum value_t { RUNTIME=-1 };),
it doesn't compile.


-- 


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