Lines Matching full:template
7 template<const char *> struct A {}; // expected-note 0-1{{declared here}}
8 template<const char (&)[4]> struct B {}; // expected-note 0-1{{declared here}}
28 template<typename T> T f(T a, T b) { return a + b; } // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
34 template B::S A::f(B::S, B::S); // expected-note {{in instantiation of}}
59 template<typename T> struct A {
64 template<> struct A<int>::B { int X; };
68 struct A { template<typename T> void f(T); };
69 template<typename T> struct B : T {
70 using T::template f; // expected-error {{using declaration cannot refer to a template}}
71 void g() { this->f<int>(123); } // expected-error {{use 'template'}}
90 template<const volatile T*> struct X {};
118 template<typename T> void f(T);
124 template<typename T> int f(T); // expected-note +{{}}
125 template<typename T> int g(T); // expected-note +{{}}
126 template<typename T> int g(T, int); // expected-note +{{}}
143 template<typename T> static int f(T);
144 template<typename T> static int g(T);
145 template<typename T> static int g(T, int);
163 template<typename T> int f(T);
164 template<typename T> int g(T);
165 template<typename T> int g(T, int);
183 // Special case kicks in only if a template argument list is specified.
184 template<typename T=int> void with_default(); // expected-note +{{}}
197 template<int> struct A {};
198 template<int N> void f(A<N>) {} // expected-note {{previous}}
199 template<int M> void f(A<M>) {} // expected-error {{redefinition}}
200 template<typename T> void f(A<sizeof(T)>) {} // expected-note {{previous}}
201 template<typename U> void f(A<sizeof(U)>) {} // expected-error {{redefinition}}
211 template<typename T> struct Y {};
213 template<typename T> struct Z {
221 template<typename T> void f();
321 template<typename T> struct A {
449 template<typename T> void f();
450 template<typename T> struct S { int n; };
452 template<typename T> void f();
453 template<typename T> struct S {};
467 template<typename T> struct C {
470 t.f<int>(); // expected-error {{use 'template'}}
481 template<typename T> void S();
539 template<typename> struct A {
540 template<typename T> A(T);
543 template<> template<> A<int>::A<int>(int) {} // expected-error {{out-of-line constructor for 'A' cannot have template arguments}}
552 template<typename> struct A {
553 template<typename T> A(T);
556 template<> A<int>::A<int>(A<int>::a); // expected-error {{is a constructor}}
664 template <class T> int g(T t) { return f(t); }
686 template<typename T> int f(T t) { return t.n; }
688 template<typename T> int h(T t) { return t.n; } // expected-error {{private}}
704 template int f(A::X);
706 template int h(A::X); // expected-note {{instantiation}}
723 template<typename> struct A { int n; };
725 template<typename> struct C;
726 template<typename> void f();
727 template<typename> static int n; // expected-error 0-1{{extension}}
731 using B::C<int>; // expected-error {{using declaration cannot refer to a template specialization}}
732 using B::f<int>; // expected-error {{using declaration cannot refer to a template specialization}}
733 using B::n<int>; // expected-error {{using declaration cannot refer to a template specialization}}
796 template<typename T> class Y;
797 template<> class Y<int> {
804 template<typename T> struct Base {}; // expected-note 2{{found}}
805 template<typename T> struct Derived : public Base<T> {
807 typedef typename Derived::template Base<T> A;
811 template struct Derived<int>;
813 template<typename T> struct Derived2 : Base<int>, Base<char> {
818 template<typename T> class X { // expected-note {{here}}
822 dr176::X *p4; // expected-error {{requires template arguments}}
855 template<typename T> struct X : T, T::some_base {
866 template <template X<class T> > struct A { }; // expected-error +{{}}
867 template <template X<class T> > void f(A<X>) { } // expected-error +{{}}
871 template <template <class T> class X> struct A { };
872 template <template <class T> class X> void f(A<X>) { }
877 template <class T> struct C {
882 template <class T> void C<T>::f() {}
883 template <class T> void C<T>::g() {}
890 template void C<A::B>::f();
891 template <> void C<A::B>::g(); // expected-error {{private}}
900 template<typename T> struct A {};
901 template<typename T> struct B {
904 template<> struct A<int> {
910 template<typename T = float> struct B {};
912 template<template<typename TT = float> class T> struct A {
917 template<template<typename TT> class T> void A<T>::f() { // expected-note {{here}}
918 T<> t; // expected-error {{too few template arguments}}
921 template<template<typename TT = char> class T> void A<T>::g() {
934 template<int X = Z, int Z = X> struct A;
971 template <class T> void g(T t) {
