Lines Matching full:template
12 // When H is hidden, it should make X hidden, even if the template argument
16 template<H *T>
26 template<typename T>
28 template<typename U>
61 template<typename T>
65 template<typename T>
67 template struct foo<int>;
87 // template. Note that is a case where we disagree with gcc, it produces
94 template<foo *z>
123 template<typename T>
130 template<>
239 template <A&> struct Aref {
358 template <class T> struct Temp {
372 template <class T> struct A : virtual Base1, Base2 {
375 extern template struct A<char>;
419 template <class T> struct HIDDEN A {
476 template <class T> void foo() {
485 // Various things with class template specializations.
487 template <unsigned> struct HIDDEN A {};
490 // the template.
491 template <> struct A<0> {
505 template <> struct DEFAULT A<1> {
520 // explicit visibility settings of the template.
521 template <class T> struct B {
540 template<En> struct A {
545 template void A<en>::foo();
554 template <class T> struct B {};
555 template <> struct DEFAULT B<A1> {
559 template <> struct B<A2> {
582 template<typename T>
587 template class foo::bar<char>;
593 template class foo::bar<zed>;
599 template<class T> struct Class {
603 template class DEFAULT Class<char>;
607 template<class T> void Method() {}
608 template DEFAULT void Method<char>();
616 template<typename T1, typename T2 = bar>
624 template class foo::zed<baz>;
630 // Having a template argument that is explicitly visible should not make
631 // the template instantiation visible.
632 template <typename T>
649 template <typename P1>
666 template <typename T>
679 template<typename T>
684 template<>
717 template<typename T>
723 template class DEFAULT foo<zed>;
731 template<class T>
733 template DEFAULT void bar<foo>();
744 template<typename T>
749 template class foo<zed>;
757 template<typename T1, typename T2>
763 template class foo<S1, S2>;
771 template<class T>
773 template DEFAULT void bar<foo>();
779 template<typename T>
785 template class foo<zed>;
793 template <class T> class A {
794 template <class U> class B {
797 template <class V> void temp() {}
800 template class DEFAULT A<hidden_t>;
801 template class DEFAULT A<hidden_t>::B<hidden_t>;
802 template void A<hidden_t>::B<hidden_t>::temp<default_t>();
803 template void A<hidden_t>::B<hidden_t>::temp<hidden_t>();
823 template <class P>
826 template <>
839 template <class P>
842 template <>
850 template <typename T>
857 template struct DEFAULT foo<bar>;
864 template <typename T>
866 template <typename T2>
874 template struct DEFAULT foo<int>::bar<zed>;
881 template <typename T>
887 template DEFAULT void foo<bar>();
897 template <typename T>
904 template DEFAULT void foo::bar<zed>();
914 // template. Note that is a case where we disagree with gcc, it produces
923 template<foo *z>
928 template void bar::zed<&x>();
935 // template. Note that is a case where we disagree with gcc, it produces
941 template<foo *z>
946 template void bar<&x>::zed();
953 // template. Note that is a case where we disagree with gcc, it produces
959 template<foo *z>
962 template void zed<&x>();
969 // template. Note that is a case where we disagree with gcc, it produces
976 template<foo *x>
987 template<typename _Tp > struct vector {
995 template<>
1014 template <class T>
1031 template <class T>
1035 template <class T> struct foo;
1044 template <class T> struct foo;
1045 template <class T>
1058 template <class T>
1061 template <class T>
1076 template<typename T>
1093 template<foo x, foo y>
1107 template<int i>
1109 template<int i>
1111 template<template<int> class x, template<int> class y>
1125 template <typename T1>
1131 template<>
1143 template class HIDDEN Class1<int>;
1147 template <typename T1>
1153 template<>
1162 template class HIDDEN Class1<int>;
1171 template <E> static void foo() {}
1173 template <E> struct B {
1186 // Don't ignore the visibility of template arguments just because we
1190 template <class P> struct B {
1194 template class B<A>;
1200 template <class T> struct B {
1202 template <class U> static void funcT1();
1203 template <class U> static void funcT2();
1205 template <class U> class InnerT {};
1207 template <template <class T> class Temp> struct C {
1212 template <> DEFAULT void B<A>::func() {}
1215 template <> template <> DEFAULT void B<A>::funcT2<A>() {}
1219 template <> template <class T> DEFAULT void B<A>::funcT1() {}
1222 template <> struct DEFAULT B<A>::Inner {
1228 template <> template <class U> struct DEFAULT B<A>::InnerT {
1240 template class C<B<A>::InnerT>;
1244 template <typename T>
1250 template struct barT<foo>;
1254 template <int* I>
1260 template struct barI<&I>;
1265 template<fType F>
1271 template struct barF<F>;
1277 template <typename T>
1288 template struct bar<foo>;
