[Bug c++/13616] New: fails to look up template specialization of template template parameter involving own template parameters

[Bug c++/13616] New: fails to look up template specialization of template template parameter involving own template parameters

[hetadres at email dot com]

gcc fails to look up a template specialization of a template template parameter 
with a template class, instanciated with one of its own template parameters.

Following code compiles fine, but produces "general" as output, where 
"specialization" would be expected. I did not include a preprocessed version of 
the code, because <iostream> is only used to show wich version of class C is 
instanciated.

Compiled on:
Gentoo Linux 1.4
gcc version 3.2.3 20030422

code:

#include <iostream>

template <
	class T,
	class P
> class PPImpl { };

template<class P> struct PP {
	template<class T> class Type : PPImpl<T, P> { };
};



template <
	class P, 
	template <class> class Q
> class C {
public:
	C() { std::cout << "general\n"; }
};

template <
	class P
> class C <P, PP<P>::Type > {
public:
	C() { std::cout << "specialization\n"; }
};



int main() {
	C<double, PP<double>::Type>c;
}

-- 
           Summary: fails to look up template specialization of template
                    template parameter involving own template parameters
           Product: gcc
           Version: 3.2.3
            Status: UNCONFIRMED
          Severity: normal
          Priority: P2
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: hetadres at email dot com
                CC: gcc-bugs at gcc dot gnu dot org
 GCC build triplet: i686-pc-linux-gnu
  GCC host triplet: i686-pc-linux-gnu
GCC target triplet: i686-pc-linux-gnu


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

[Bug c++/13616] fails to look up template specialization of template template parameter involving own template parameters

[pinskia at gcc dot gnu dot org]

------- Additional Comments From pinskia at gcc dot gnu dot org  2004-01-08 18:21 -------
3.4 produces the following error message (which I think is wrong and I think there is a dup of that 
bug somewhere):
pr13616.cc:24: error: type/value mismatch at argument 2 in template parameter list for 
`template<class P, template<class> class Q> class C'
pr13616.cc:24: error:   expected a class template, got `typename PP<P>::Type'

-- 


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

[Bug c++/13616] fails to look up template specialization of template template parameter involving own template parameters

[bangerth at dealii dot org]

------- Additional Comments From bangerth at dealii dot org  2004-01-08 18:41 -------
This is fixed already. First, you need to say 
  class C <P, PP<P>::template Type > { 
in the specialization. Note the "template" keyword here. Then the 
code also yields what you expected with 3.3.3 (and, yes, this 
is indeed very confusing that it yields the right thing with the 
right syntax, and the wrong thing with an invalid syntax). 
 
Present mainline only accepts the correct syntax, and prints the correct 
message in this case. 
 
W. 

-- 
           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|                            |FIXED
   Target Milestone|---                         |3.4.0


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

[Bug c++/13616] fails to look up template specialization of template template parameter involving own template parameters

[bangerth at dealii dot org]

------- Additional Comments From bangerth at dealii dot org  2004-01-08 18:45 -------
Just for completeness, if someone wants to make a testcase for this: 
take this code 
------------------------ 
template<class P> struct O { 
    template<class T> class I { }; 
}; 
 
template <class, template <class> class> struct A; 
template <class P> struct A <P, O<P>::I> {}; 
 
template <class, template <class> class> struct B; 
template <class P> struct B <P, O<P>::template I> {}; 
 
int main() { 
  A<double, O<double>::I> a; 
  B<double, O<double>::I> b; 
} 
------------------------- 
3.3.x accepts the specializations, but whines when declaring "a" 
that we use an incomplete type. It doesn't do so for B, though. 
 
Present mainline doesn't accept the specialization right away. That's 
the correct behavior. 
 
W. 

-- 


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