| /external/clang/test/CXX/temp/temp.decls/temp.fct/temp.over.link/ |
| p4.cpp | 5 template<typename T> void f0(T) { }
6 template<typename T, typename U> void f0(T) { }
7 template<typename T, typename U> void f0(U) { }
9 template<typename T> void f0(T*);
11 template<int I> void f0();
12 template<typename T> void f0();
|
| /external/clang/test/CXX/temp/temp.param/ |
| p7.cpp | 3 // A non-type template-parameter shall not be declared to have
7 template<double d> class X; // expected-error{{cannot have type}}
8 template<double* pd> class Y; //OK
9 template<double& rd> class Z; //OK
11 template<A a> class X0; // expected-error{{cannot have type}}
14 template<VOID a> class X01; // expected-error{{cannot have type}}
|
| /external/clang/test/SemaObjCXX/ |
| pseudo-destructor.mm | 10 template <class T> void destroyPointer(T *t) {
14 template <class T> void destroyReference(T &t) {
18 template void destroyPointer<Root*>(Root **);
19 template void destroyReference<Root*>(Root *&);
22 template void destroyPointer<Forward*>(Forward **);
23 template void destroyReference<Forward*>(Forward *&);
|
| /external/clang/test/SemaTemplate/ |
| alias-template-template-param.cpp | 4 template<template<typename> class D> using C = D<int>;
6 // Substitution of the alias template transforms the TemplateSpecializationType
7 // 'D<int>' into the DependentTemplateSpecializationType 'T::template U<int>'.
8 template<typename T> void f(C<T::template U>);
|
| instantiation-backtrace.cpp | 2 template<typename T> struct A; // expected-note 4{{template is declared here}}
4 template<typename T> struct B : A<T*> { }; // expected-error{{implicit instantiation of undefined template}} \
5 // expected-error{{implicit instantiation of undefined template 'A<X *>'}}
7 template<typename T> struct C : B<T> { } ; // expected-note{{instantiation of template class}}
9 template<typename T> struct D : C<T> { }; // expected-note{{instantiation of template class}}
11 template<typename T> struct E : D<T> { }; // expected-note{{instantiation of template class}
[all...] |
| class-template-spec.cpp | 2 template<typename T, typename U = int> struct A; // expected-note {{template is declared here}} \
5 template<> struct A<double, double>; // expected-note{{forward declaration}}
7 template<> struct A<float, float> { // expected-note{{previous definition}}
11 template<> struct A<float> { // expected-note{{previous definition}}
23 (void)a2->x; // expected-error{{implicit instantiation of undefined template 'A<double, int>'}}
28 template<> struct A<float, FLOAT>;
30 template<> struct A<FLOAT, float> { }; // expected-error{{redefinition}}
32 template<> struct A<float, int> { }; // expected-error{{redefinition}}
34 template<typename T, typename U = int> struct X
[all...] |
| instantiate-objc-1.mm | 4 template <typename T> struct StringTest {
10 template struct StringTest<int>;
11 template struct StringTest<double>;
14 template <typename T> struct SelectorTest {
23 template struct SelectorTest<int>;
24 template struct SelectorTest<double>;
30 template <typename T> struct ProtocolTest {
36 template struct ProtocolTest<int>;
37 template struct ProtocolTest<double>;
40 template <typename T> struct EncodeTest
[all...] |
| temp_explicit_cxx0x.cpp | 4 template<typename T> struct X0 { }; // expected-note{{here}}
7 template<typename T> struct X1 { };
10 template struct X0<int>;
11 template struct Inner::X1<int>;
14 template<typename T> struct X2 { }; // expected-note{{here}}
16 template struct ::N1::Inner::X1<float>;
21 template struct X0<double>; // expected-error{{must occur in namespace 'N1'}}
23 template struct X2<float>; // expected-error{{at global scope}}
|
| destructor-template.cpp | 3 template<typename A> class s0 {
5 template<typename B> class s1 : public s0<A> {
14 template<typename T>
19 template void destroy_me(Incomplete*);
22 template<typename T> struct X { void f(); };
23 template<typename T> struct Y { };
24 template<typename T>
27 y->template Y<T>::~Y();
28 y->template Y<T>::~Y<T>();
32 template struct X<int>
[all...] |
| /external/clang/test/CXX/temp/temp.decls/temp.mem/ |
| p1.cpp | 4 template <class T> struct A {
7 template <class U> struct B {
20 template<typename T>
22 template<typename Y>
26 template<>
28 template<typename Y>
32 template<typename T, typename U>
33 struct Z : public X<T>::template Y1<U> { };
|
| /external/clang/test/CXX/temp/temp.spec/temp.expl.spec/ |
| p13.cpp | 3 template<typename T> void f(T);
5 template<> void f(int) { }
|
| p21.cpp | 3 template<typename T>
6 template<typename U> void mf2(T, U); // expected-note{{previous}}
9 template<>
14 template<> template<>
18 template<> template<typename U>
23 template<>
|
| /external/clang/test/Index/Inputs/ |
| redeclarations.h | 7 template <typename T1, typename T2>
12 template <class T>
|
| /external/clang/test/Modules/Inputs/ |
| cxx-templates-c.h | 0 template<typename> struct MergeSpecializations;
2 template<typename T> struct MergeSpecializations<T[]> {
5 template<> struct MergeSpecializations<bool> {
9 template<typename T> struct MergeTemplateDefinitions {
13 template<typename T> constexpr int MergeTemplateDefinitions<T>::g() { return 2; }
15 template<typename T1 = int>
22 template<typename T> struct DontWalkPreviousDeclAfterMerging { struct Inner { typedef T type; }; };
26 template<typename T> struct X { X(); };
|
| /external/clang/test/Modules/Inputs/initializer_list/ |
| direct.h | 4 template<typename T> struct initializer_list {
8 template<typename T> int min(initializer_list<T>);
|
| /external/clang/test/Modules/Inputs/template-specialization-visibility/ |
| a.h | 3 template<typename T> struct S;
4 template<typename U> struct T {
|
| /external/clang/test/PCH/ |
| cxx-variadic-templates.h | 2 template<typename _Tp>
5 template<class _Alloc, class ..._Args>
11 template<class _Tp>
12 template<class _Alloc, class ..._Args>
20 template<typename...Ts> struct outer {
21 template<Ts...Vs, template<Ts> class ...Cs> struct inner {
25 template struct outer<int, int>;
|
| /external/clang/test/SemaCXX/ |
| PR9908.cpp | 4 template <class _Tp, class _Up>
7 typedef typename _Tp::template rebind<_Up>::other type;
10 template <class Alloc>
14 template <class T> using rebind_alloc = typename
16 template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
19 template <class T>
22 template <class T>
27 template <class U> struct rebind {typedef ReboundA<U> other;};
|
| many-template-parameter-lists.cpp | 5 template <class T>
7 template <class U>
9 template <class V>
11 template <class W>
13 template <class X>
15 template <class Y>
17 template <class Z>
25 template <class U>
26 template <class V>
27 template <class W
[all...] |
| /external/clang/test/CXX/basic/basic.scope/basic.scope.pdecl/ |
| p9.cpp | 4 // Template type parameters.
6 template<typename T = T> struct X0 { };
7 template<> struct X0<unsigned char> { static const bool value = true; };
10 // Non-type template parameters.
12 template<int N = N> struct X1 { };
13 template<> struct X1<17> { static const bool value = true; };
16 // Template template parameters.
17 template<template<class> class X0 = X0> struct X2 { }
[all...] |
| /external/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/ |
| p2-0x.cpp | 4 template<typename T> using X = A; // expected-note {{declared here}}
5 struct X<int>* p2; // expected-error {{elaborated type refers to a type alias template}}
8 template<typename T> using Id = T; // expected-note {{declared here}}
9 template<template<typename> class F>
11 struct F<int> i; // expected-error {{elaborated type refers to a type alias template}}
15 template<typename T> using U = F<char>; // expected-note 2{{declared here}}
16 struct Y<F>::template U<char> k; // expected-error 2{{elaborated type refers to a type alias template}}
17 typename Y<F>::template U<char> l; // o
[all...] |
| /external/clang/test/CXX/temp/temp.res/temp.local/ |
| p8.cpp | 6 template<class T> class B {
11 template<class C> void N::B<C>::f(C) {
19 template<typename C> class X {
20 template<typename U> void f(C, U);
22 template<typename D> void g(C, D) {
29 template<typename U> void f(U);
34 template<typename D> void f(D);
38 template<typename C>
39 template<typename D>
45 template<typename C
[all...] |
| /external/clang/test/CXX/temp/temp.spec/temp.explicit/ |
| p10.cpp | 3 template<typename T>
12 template<typename T>
17 template<typename T>
22 template<typename T>
25 extern template struct X0<void*>;
26 template struct X0<void*>; // expected-note 2{{instantiation}}
28 template struct X0<int>; // expected-note 4{{explicit instantiation definition is here}}
30 extern template void X0<int>::f(int&); // expected-error{{follows explicit instantiation definition}}
31 extern template struct X0<int>::Inner; // expected-error{{follows explicit instantiation definition}}
32 extern template int X0<int>::static_var; // expected-error{{follows explicit instantiation definition}
[all...] |
| p6.cpp | 4 template<class T> class Array { /* ... */ };
5 template<class T> void sort(Array<T>& v) { }
7 // instantiate sort(Array<int>&) - template-argument deduced
8 template void sort<>(Array<int>&);
10 template void sort(Array<long>&);
12 template<typename T, typename U> void f0(T, U*) { }
14 template void f0<int>(int, float*);
15 template void f0<>(double, float*);
17 template<typename T> struct hash { };
22 template<typename T> struct Hash_map
[all...] |
| /external/clang/test/CodeGenCXX/ |
| debug-info-determinism.cpp | 5 template <int N> struct C {
6 template <int M> int f() {
8 return arr[M/2] + C<M/2>().template f<M-1>();
11 template <> template <> int C<0>::f<0>() { return 0; }
12 template <> template <> int C<0>::f<1>() { return 0; }
13 template <> template <> int C<1>::f<0>() { return 0; }
14 template <> template <> int C<1>::f<1>() { return 0;
[all...] |
