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, int N = 2> struct X; // expected-note{{template is declared here}} 5 6 X<int, 1> *x1; 7 X<int> *x2; 8 9 X<> *x3; // expected-error{{too few template arguments for class template 'X'}} 10 11 template<typename U = float, int M> struct X; 12 13 X<> *x4; 14 15 template<typename T = int> struct Z { }; 16 template struct Z<>; 17 18 // PR4362 19 template<class T> struct a { }; 20 template<> struct a<int> { static const bool v = true; }; 21 22 template<class T, bool = a<T>::v> struct p { }; // expected-error {{no member named 'v'}} 23 24 template struct p<bool>; // expected-note {{in instantiation of default argument for 'p<bool>' required here}} 25 template struct p<int>; 26 27 // PR5187 28 template<typename T, typename U> 29 struct A; 30 31 template<typename T, typename U = T> 32 struct A; 33 34 template<typename T, typename U> 35 struct A { 36 void f(A<T>); 37 }; 38 39 template<typename T> 40 struct B { }; 41 42 template<> 43 struct B<void> { 44 typedef B<void*> type; 45 }; 46 47 // Nested default arguments for template parameters. 48 template<typename T> struct X1 { }; 49 50 template<typename T> 51 struct X2 { 52 template<typename U = typename X1<T>::type> // expected-error{{no type named 'type' in 'X1<int>'}} \ 53 // expected-error{{no type named 'type' in 'X1<char>'}} 54 struct Inner1 { }; // expected-note{{template is declared here}} 55 56 template<T Value = X1<T>::value> // expected-error{{no member named 'value' in 'X1<int>'}} \ 57 // expected-error{{no member named 'value' in 'X1<char>'}} 58 struct NonType1 { }; // expected-note{{template is declared here}} 59 60 template<T Value> 61 struct Inner2 { }; 62 63 template<typename U> 64 struct Inner3 { 65 template<typename X = T, typename V = U> 66 struct VeryInner { }; 67 68 template<T Value1 = sizeof(T), T Value2 = sizeof(U), 69 T Value3 = Value1 + Value2> 70 struct NonType2 { }; 71 }; 72 }; 73 74 X2<int> x2i; // expected-note{{in instantiation of template class 'X2<int>' requested here}} 75 X2<int>::Inner1<float> x2iif; 76 77 X2<int>::Inner1<> x2bad; // expected-error{{too few template arguments for class template 'Inner1'}} 78 79 X2<int>::NonType1<'a'> x2_nontype1; 80 X2<int>::NonType1<> x2_nontype1_bad; // expected-error{{too few template arguments for class template 'NonType1'}} 81 82 // Check multi-level substitution into template type arguments 83 X2<int>::Inner3<float>::VeryInner<> vi; 84 X2<char>::Inner3<int>::NonType2<> x2_deep_nontype; // expected-note{{in instantiation of template class 'X2<char>' requested here}} 85 86 template<typename T, typename U> 87 struct is_same { static const bool value = false; }; 88 89 template<typename T> 90 struct is_same<T, T> { static const bool value = true; }; 91 92 int array1[is_same<__typeof__(vi), 93 X2<int>::Inner3<float>::VeryInner<int, float> >::value? 1 : -1]; 94 95 int array2[is_same<__typeof(x2_deep_nontype), 96 X2<char>::Inner3<int>::NonType2<sizeof(char), sizeof(int), 97 sizeof(char)+sizeof(int)> >::value? 1 : -1]; 98 99 // Template template parameter defaults 100 template<template<typename T> class X = X2> struct X3 { }; 101 int array3[is_same<X3<>, X3<X2> >::value? 1 : -1]; 102 103 struct add_pointer { 104 template<typename T> 105 struct apply { 106 typedef T* type; 107 }; 108 }; 109 110 template<typename T, template<typename> class X = T::template apply> 111 struct X4; 112 int array4[is_same<X4<add_pointer>, 113 X4<add_pointer, add_pointer::apply> >::value? 1 : -1]; 114 115 template<int> struct X5 {}; // expected-note{{has a different type 'int'}} 116 template<long> struct X5b {}; 117 template<typename T, 118 template<T> class B = X5> // expected-error{{template template argument has different}} \ 119 // expected-note{{previous non-type template parameter}} 120 struct X6 {}; 121 122 X6<int> x6a; 123 X6<long> x6b; // expected-note{{while checking a default template argument}} 124 X6<long, X5b> x6c; 125 126 127 template<template<class> class X = B<int> > struct X7; // expected-error{{must be a class template}} 128 129 namespace PR9643 { 130 template<typename T> class allocator {}; 131 template<typename T, typename U = allocator<T> > class vector {}; 132 133 template<template<typename U, typename = allocator<U> > class container, 134 typename DT> initializer(const DT & d)135 container<DT> initializer(const DT& d) { 136 return container<DT>(); 137 } 138 f()139 void f() { 140 vector<int, allocator<int> > v = initializer<vector>(5); 141 } 142 } 143 144 namespace PR16288 { 145 template<typename X> 146 struct S { 147 template<typename T = int, typename U> 148 #if __cplusplus <= 199711L // C++03 or earlier modes 149 // expected-warning@-2 {{default template arguments for a function template are a C++11 extension}} 150 #endif 151 void f(); 152 }; 153 template<typename X> 154 template<typename T, typename U> f()155 void S<X>::f() {} 156 } 157 158 namespace DR1635 { 159 template <class T> struct X { fDR1635::X160 template <class U = typename T::type> static void f(int) {} // expected-error {{type 'int' cannot be used prior to '::' because it has no members}} 161 #if __cplusplus <= 199711L // C++03 or earlier modes 162 // expected-warning@-2 {{default template arguments for a function template are a C++11 extension}} 163 #endif fDR1635::X164 static void f(...) {} 165 }; 166 g()167 int g() { X<int>::f(0); } // expected-note {{in instantiation of template class 'DR1635::X<int>' requested here}} 168 } 169 170 namespace NondefDecls { f1()171 template<typename T> void f1() { 172 int g1(int defarg = T::error); // expected-error{{type 'int' cannot be used prior to '::' because it has no members}} 173 } 174 template void f1<int>(); // expected-note{{in instantiation of function template specialization 'NondefDecls::f1<int>' requested here}} 175 } 176 177 template <typename T> 178 struct C { 179 C(T t = ); // expected-error {{expected expression}} 180 }; 181 C<int> obj; 182 183 namespace PR26134 { 184 // Make sure when substituting default template arguments we do it in the current context. 185 template<class T, bool Val = T::value> 186 struct X {}; 187 188 template<bool B> struct Y { fPR26134::Y189 void f() { X<Y> xy; } 190 static const bool value = B; 191 }; 192 193 namespace ns1 { 194 template<class T0> 195 struct X { 196 template<bool B = T0::value> struct XInner { static const bool value = B; }; 197 }; 198 template<bool B> struct S { static const bool value = B; }; 199 #if __cplusplus > 199711L 200 template<bool B> struct Y { fPR26134::ns1::Y201 static constexpr bool f() { return typename X<S<B>>::template XInner<>{}.value; } 202 static_assert(f() == B, ""); 203 }; 204 Y<true> y; 205 Y<false> y2; 206 #endif 207 208 } // end ns1 209 } // end ns PR26134 210