Lines Matching full:template
7 template<typename R, typename A> void f(R (&)(A)) {}
15 template<typename T> void operator+(T, T);
27 template<typename T> void f() {
28 typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}}
30 class T::template operator+<int> b; // expected-error {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}}
31 enum T::template operator+<int> c; // expected-error {{expected identifier}} expected-error {{does not declare anything}}
32 enum T::template operator+<int>::E d; // expected-error {{qualified name refers into a specialization of function template 'T::template operator +'}} expected-error {{forward reference}}
33 enum T::template X<int>::E e;
34 T::template operator+<int>::foobar(); // expected-error {{qualified name refers into a specialization of function template 'T::template operator +'}}
35 T::template operator+<int>(0); // ok
38 template<typename T> class operator&<T*> {}; // expected-error +{{}}
39 template<typename T> class T::operator& {}; // expected-error +{{}}
40 template<typename T> class S::operator&<T*> {}; // expected-error +{{}}
105 template<typename T> struct X {};
115 template<typename T> using T1 = Y;
117 template<typename T> using T2 = Y;
123 template<typename T> using T2 = T;
127 z->~T1<int>(); // expected-error {{'T1' following the 'template' keyword does not refer to a template}} expected-error +{{}}
134 template<typename A> struct R {};
136 template<typename A> using R = Q::R<int>;
198 template<typename T> struct A {
199 template<typename U> struct B {};
201 template<typename T> struct C : public A<T>::template B<T> {
202 C() : A<T>::template B<T>() {}
245 template<typename> struct X {};
282 template<int> struct A {
283 template<int> struct B;
285 template<> template<> struct A<0>::B<0>;
288 template<> template<> struct N::A<0>::B<0> {};
290 template<typename T> void g(T t) { f(t); }
291 template void g(N::A<0>::B<0>);
294 template<typename> struct I { friend bool operator==(const I&, const I&); };
302 template<typename T> operator T&();
339 template<typename> struct C { A a; }; // expected-error {{incomplete}}
345 template<typename T> struct A : B {
378 template<typename T> void f() {
386 template void f<S>();
393 template<class T1> class A {
394 template<class T2> class B {
395 template<class T3> void mf1(T3);
399 template<> template<class X> class A<int>::B {};
400 template<> template<> template<class T> void A<int>::B<double>::mf1(T t) {} // expected-error {{does not match}}
401 template<class Y> template<> void A<Y>::B<double>::mf2() {} // expected-error {{does not refer into a class}}
404 template<class T1> class A {
405 template<class T2> class B {
406 template<class T3> void mf1(T3);
410 template<> template<class X> class A<int>::B {
411 template<class T> void mf1(T);
413 template<> template<> template<class T> void A<int>::B<double>::mf1(T t) {}
415 template<class Y> template<> void A<Y>::B<double>::mf2() {} // expected-error {{does not refer into a class}}
420 template<typename T> void f(T (*)[1]);
421 template<typename T> int &f(...);
435 template <int I> struct A { static const int value = I; };
440 template<class T> A<sizeof(xxx((T)0))> f(T) {} // expected-note {{candidate}}
452 template <class T> struct conv_int {
456 template <class T> bool conv_int2(A<sizeof(f(T()))> p);
458 template<typename T> A<sizeof(f(T()))> make_A();
498 template<typename T> struct A {
499 template<typename U> struct B {};
501 // FIXME: In these contexts, the 'template' keyword is optional.
502 template<typename T> struct C : public A<T>::B<T> { // expected-error {{use 'template'}}
503 C() : A<T>::B<T>() {} // expected-error {{use 'template'}}
520 template <class T> void f(T t) { typename T::X x; } // expected-error {{refers to non-type member 'X'}}
549 template <class T> operator T ***() {
560 template <class T> operator T ***() {
577 template<typename R, typename A> void foo(E, R (*)(A)); // expected-note 2{{couldn't infer template argument 'R'}}
580 template<typename T> void arg(T);
581 template<typename T> int arg(T) = delete; // expected-note {{here}} expected-error 0-1{{extension}}
596 foo<int, int>(e, &arg); // ok, uses non-template
601 template<int I> void f1(int (&)[I]);
602 template<int I> void f2(int (&)[I+1]); // expected-note {{couldn't infer}}
603 template<int I> void f3(int (&)[I+1], int (&)[I]);
612 template<int I> struct S {};
613 template<int I> void g1(S<I>);
614 template<int I> void g2(S<I+1>); // expected-note {{couldn't infer}}
615 template<int I> void g3(S<I+1>, S<I>);
624 template<typename T> void h1(T = 0); // expected-note {{couldn't infer}}
625 template<typename T> void h2(T, T = 0);
633 template<typename T> int tmpl(T);
634 template<typename R, typename A> void i1(R (*)(A)); // expected-note 3{{couldn't infer}}
635 template<typename R, typename A> void i2(R, A, R (*)(A)); // expected-note {{not viable}}
654 template<typename T> struct is_int;
655 template<> struct is_int<int> {};
658 template<typename T> int f(T (*p)(T)) { is_int<T>(); }
665 template<typename T> int f(T, T (*p)(T)) { is_int<T>(); }
672 template <class T> int f(T, T (*p)(T)) { is_int<T>(); }
674 template <class T> T g(T);
679 template<int I> class A {};
680 template<int I> void g(A<I+1>); // expected-note {{couldn't infer}}
681 template<int I> void f(A<I>, A<I+1>);
696 template<int*> struct ptr {}; // expected-note 0-4{{here}}
718 template<int*> int both();
719 template<int> int both();
728 template<int S::*> struct ptr_mem {}; // expected-note 0-4{{here}}
758 template<typename T> struct A {
761 template<typename T> void A<T>::f() {} // expected-error {{does not match}}
764 template<typename T> void f();
766 template<typename T> void B::f() const {} // expected-error {{does not match}}
835 template<typename T, T> struct S {}; // expected-note {{here}}
836 template<typename T> int f(S<T, T()> *); // expected-error {{function type}}
837 //template<typename T> int g(S<T, (T())> *); // FIXME: crashes clang
838 template<typename T> int g(S<T, true ? T() : T()> *); // expected-note {{cannot have type 'dr368::X'}}
847 template<typename T> struct X {
851 template<typename T> struct Y {};
855 template<typename T,
856 template<typename> class T1,
857 template<typename> class T2> struct Z1 :
861 template<typename T,
862 template<typename> class T1,
863 template<typename> class T2> struct Z2 :
876 template<typename T> struct A {
888 template<typename T> struct B {};
889 template<typename U> struct C : U, B<typename U::N> {}; // expected-error {{protected}}
890 template<typename U> struct D : B<typename U::N>, U {}; // expected-error {{protected}}
927 template<typename T> void f();
928 template<typename T> struct A { void f(); };
930 template<> void N::f<char>() {}
931 template<> void N::A<char>::f() {}
932 template<> struct N::A<int> {};
976 // expected-error@-3 {{occurs outside of a template}}
977 // expected-error@-3 {{occurs outside of a template}}
992 template<typename T> struct Base {};
993 template<typename T> struct X {
1003 template<typename T> int *operator+(T, unsigned);
1026 template<typename T> class number {
1039 template <typename T> class number {
1062 template<typename> struct T {};
1083 // This has linkage even though its template argument does not.
1101 typedef T<WithoutLinkage1> BadArg1; // expected-error{{template argument uses}}
1102 typedef T<WithoutLinkage2> BadArg2; // expected-error{{template argument uses}}
1103 typedef T<WithoutLinkage3> BadArg3; // expected-error{{template argument uses}}
1104 typedef T<WithoutLinkage4> BadArg4; // expected-error{{template argument uses}}
1105 typedef T<WithoutLinkage5> BadArg5; // expected-error{{template argument uses}}
1168 template<typename T>
1174 template<typename T> A<T>::~A() { T::error; } // expected-error {{cannot be used prior to}}
1175 template<typename T> void A<T>::f() { T::error; } // ok, not odr-used
1197 template<typename T>
1210 template <typename T, int N>(&operator T())[N]; // expected-error {{cannot specify any part of a return type}}
1211 template <typename T, int N> operator(T (&)[N])(); // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error +{{}}
1212 template <typename T> operator T *() const { return 0; }
1213 template <typename T, typename U> operator T U::*() const { return 0; }
1214 template <typename T, typename U> operator T (U::*)()() const { return 0; } // expected-error +{{}}
1218 template <class T, class U> struct ptr_mem_fun_t {
1222 template <class T, class U>
1229 template <typename T> using id = T; // expected-error 0-1{{extension}}
1232 template <typename T, int N> operator id<T[N]> &();
1233 template <typename T, typename U> operator id<T (U::*)()>() const;
1237 template<class T, class U> using ptr_mem_fun_t = T (U::*)(); // expected-error 0-1{{extension}}
1238 template<class T, class U> operator ptr_mem_fun_t<T, U>() const { return 0; };
1261 template <int N> struct X {};
1262 template <typename T> void f(X<T::I> *) {}
1263 template <typename T> void f(X<T::J> *) {}
1268 template <int I> struct X {};
1269 template <template <class T> class> struct Z {};
1270 template <class T> void f(typename T::Y *) {} // expected-note 2{{substitution failure}}
1271 template <class T> void g(X<T::N> *) {} // expected-note {{substitution failure}}
1272 template <class T> void h(Z<T::template TT> *) {} // expected-note {{substitution failure}}
