1 // RUN: %clang_cc1 -fsyntax-only -verify %s 2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s 3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 4 template<typename T, typename U = int> struct A; // expected-note {{template is declared here}} \ 5 // expected-note{{explicitly specialized}} 6 7 template<> struct A<double, double>; // expected-note{{forward declaration}} 8 9 template<> struct A<float, float> { // expected-note{{previous definition}} 10 int x; 11 }; 12 13 template<> struct A<float> { // expected-note{{previous definition}} 14 int y; 15 }; 16 17 int test_specs(A<float, float> *a1, A<float, int> *a2) { 18 return a1->x + a2->y; 19 } 20 21 int test_incomplete_specs(A<double, double> *a1, 22 A<double> *a2) 23 { 24 (void)a1->x; // expected-error{{member access into incomplete type}} 25 (void)a2->x; // expected-error{{implicit instantiation of undefined template 'A<double>'}} 26 } 27 28 typedef float FLOAT; 29 30 template<> struct A<float, FLOAT>; 31 32 template<> struct A<FLOAT, float> { }; // expected-error{{redefinition}} 33 34 template<> struct A<float, int> { }; // expected-error{{redefinition}} 35 36 template<typename T, typename U = int> struct X; 37 38 template <> struct X<int, int> { int foo(); }; // #1 39 template <> struct X<float> { int bar(); }; // #2 40 41 typedef int int_type; 42 void testme(X<int_type> *x1, X<float, int> *x2) { 43 (void)x1->foo(); // okay: refers to #1 44 (void)x2->bar(); // okay: refers to #2 45 } 46 47 // Make sure specializations are proper classes. 48 template<> 49 struct A<char> { 50 A(); 51 }; 52 53 A<char>::A() { } 54 55 // Make sure we can see specializations defined before the primary template. 56 namespace N{ 57 template<typename T> struct A0; 58 } 59 60 namespace N { 61 template<> 62 struct A0<void> { 63 typedef void* pointer; 64 }; 65 } 66 67 namespace N { 68 template<typename T> 69 struct A0 { 70 void foo(A0<void>::pointer p = 0); 71 }; 72 } 73 74 // Diagnose specialization errors 75 struct A<double> { }; // expected-error{{template specialization requires 'template<>'}} 76 77 template<> struct ::A<double>; 78 79 namespace N { 80 template<typename T> struct B; // expected-note {{explicitly specialized}} 81 82 template<> struct ::N::B<char>; // okay 83 template<> struct ::N::B<short>; // okay 84 template<> struct ::N::B<int>; // okay 85 86 int f(int); 87 } 88 89 template<> struct N::B<int> { }; // okay 90 91 template<> struct N::B<float> { }; 92 93 94 namespace M { 95 template<> struct ::N::B<short> { }; // expected-error{{class template specialization of 'B' not in a namespace enclosing 'N'}} 96 97 template<> struct ::A<long double>; // expected-error{{must occur at global scope}} 98 } 99 100 template<> struct N::B<char> { 101 int testf(int x) { return f(x); } 102 }; 103 104 // PR5264 105 template <typename T> class Foo; 106 Foo<int>* v; 107 Foo<int>& F() { return *v; } 108 template <typename T> class Foo {}; 109 Foo<int> x; 110 111 112 // Template template parameters 113 template<template<class T> class Wibble> 114 class Wibble<int> { }; // expected-error{{cannot specialize a template template parameter}} 115 116 namespace rdar9676205 { 117 template<typename T> 118 struct X { // expected-note {{here}} 119 template<typename U> 120 struct X<U*> { // expected-error{{partial specialization of 'X' not in a namespace enclosing}} 121 }; 122 }; 123 124 } 125 126 namespace PR18009 { 127 template <typename T> struct A { 128 template <int N, int M> struct S; 129 template <int N> struct S<N, sizeof(T)> {}; 130 }; 131 A<int>::S<8, sizeof(int)> a; // ok 132 133 template <typename T> struct B { 134 template <int N, int M> struct S; 135 template <int N> struct S<N, sizeof(T) + N> {}; // ok (dr1315) 136 }; 137 B<int>::S<8, sizeof(int) + 8> b; 138 139 template <typename T> struct C { 140 template <int N, int M> struct S; 141 template <int N> struct S<N, N ? **(T(*)[N])0 : 0> {}; // expected-error {{depends on a template parameter of the partial specialization}} 142 }; 143 C<int> c; // expected-note {{in instantiation of}} 144 145 template<int A> struct outer { 146 template<int B, int C> struct inner {}; 147 template<int C> struct inner<A * 2, C> {}; 148 }; 149 } 150 151 namespace PR16519 { 152 template<typename T, T...N> struct integer_sequence { typedef T value_type; }; 153 #if __cplusplus <= 199711L 154 // expected-warning@-2 {{variadic templates are a C++11 extension}} 155 #endif 156 157 template<typename T> struct __make_integer_sequence; 158 template<typename T, T N> using make_integer_sequence = typename __make_integer_sequence<T>::template make<N, N % 2>::type; 159 #if __cplusplus <= 199711L 160 // expected-warning@-2 {{alias declarations are a C++11 extension}} 161 #endif 162 163 template<typename T, typename T::value_type ...Extra> struct __make_integer_sequence_impl; 164 #if __cplusplus <= 199711L 165 // expected-warning@-2 {{variadic templates are a C++11 extension}} 166 #endif 167 168 // Note that the following seemingly-equivalent template parameter list is 169 // not OK; it would result in a partial specialization that is not more 170 // specialized than the primary template. (See NTTPTypeVsPartialOrder below.) 171 // 172 // template<typename T, T ...N, T ...Extra> 173 template<typename T, T ...N, typename integer_sequence<T, N...>::value_type ...Extra> 174 #if __cplusplus <= 199711L 175 // expected-warning@-2 2{{variadic templates are a C++11 extension}} 176 #endif 177 struct __make_integer_sequence_impl<integer_sequence<T, N...>, Extra...> { 178 typedef integer_sequence<T, N..., sizeof...(N) + N..., Extra...> type; 179 }; 180 181 template<typename T> struct __make_integer_sequence { 182 template<T N, T Parity, typename = void> struct make; 183 template<typename Dummy> struct make<0, 0, Dummy> { typedef integer_sequence<T> type; }; 184 template<typename Dummy> struct make<1, 1, Dummy> { typedef integer_sequence<T, 0> type; }; 185 template<T N, typename Dummy> struct make<N, 0, Dummy> : __make_integer_sequence_impl<make_integer_sequence<T, N/2> > {}; 186 template<T N, typename Dummy> struct make<N, 1, Dummy> : __make_integer_sequence_impl<make_integer_sequence<T, N/2>, N - 1> {}; 187 }; 188 189 using X = make_integer_sequence<int, 5>; 190 #if __cplusplus <= 199711L 191 // expected-warning@-2 {{alias declarations are a C++11 extension}} 192 #endif 193 194 using X = integer_sequence<int, 0, 1, 2, 3, 4>; 195 #if __cplusplus <= 199711L 196 // expected-warning@-2 {{alias declarations are a C++11 extension}} 197 #endif 198 } 199 200 namespace NTTPTypeVsPartialOrder { 201 struct X { typedef int value_type; }; 202 template<typename T> struct Y { typedef T value_type; }; 203 204 template<typename T, typename T::value_type N> struct A; 205 template<int N> struct A<X, N> {}; 206 template<typename T, T N> struct A<Y<T>, N> {}; 207 A<X, 0> ax; 208 A<Y<int>, 0> ay; 209 210 211 template<int, typename T, typename T::value_type> struct B; 212 template<typename T, typename T::value_type N> struct B<0, T, N>; 213 template<int N> struct B<0, X, N> {}; 214 template<typename T, T N> struct B<0, Y<T>, N> {}; 215 B<0, X, 0> bx; 216 B<0, Y<int>, 0> by; 217 } 218 219 namespace DefaultArgVsPartialSpec { 220 // Check that the diagnostic points at the partial specialization, not just at 221 // the default argument. 222 template<typename T, int N = 223 sizeof(T) // ok (dr1315) 224 > struct X {}; 225 template<typename T> struct X<T> {}; 226 227 template<typename T, 228 T N = 0 // expected-note {{template parameter is declared here}} 229 > struct S; 230 template<typename T> struct S<T> {}; // expected-error {{non-type template argument specializes a template parameter with dependent type 'T'}} 231 } 232