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 
211 namespace friends {
212   namespace ns {
213     template<typename> struct A {
214       template<typename> friend void f();
215       template<typename> friend struct X;
216     };
217     template<typename = int> void f(); // expected-warning 0-1{{extension}}
218     template<typename = int> struct X;
219     A<int> a;
220   }
221   namespace ns {
g()222     void g() { f(); }
223     X<int> *p;
224   }
225 }
226 
227 namespace unevaluated {
228   int a;
229   template<int = 0> int f(int = a); // expected-warning 0-1{{extension}}
230   int k = sizeof(f());
231 }
232