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
5 template<typename T>
6 class C { C(int a0 = 0); };
7
8 template<>
9 C<char>::C(int a0);
10
11 struct S { }; // expected-note 3 {{candidate constructor (the implicit copy constructor)}}
12 #if __cplusplus >= 201103L // C++11 or later
13 // expected-note@-2 3 {{candidate constructor (the implicit move constructor) not viable}}
14 #endif
15
f1(T a,T b=10)16 template<typename T> void f1(T a, T b = 10) { } // expected-error{{no viable conversion}} \
17 // expected-note{{passing argument to parameter 'b' here}}
18
f2(T a,T b=T ())19 template<typename T> void f2(T a, T b = T()) { }
20
21 template<typename T> void f3(T a, T b = T() + T()); // expected-error{{invalid operands to binary expression ('S' and 'S')}}
22
g()23 void g() {
24 f1(10);
25 f1(S()); // expected-note{{in instantiation of default function argument expression for 'f1<S>' required here}}
26
27 f2(10);
28 f2(S());
29
30 f3(10);
31 f3(S()); // expected-note{{in instantiation of default function argument expression for 'f3<S>' required here}}
32 }
33
34 template<typename T> struct F {
35 F(T t = 10); // expected-error{{no viable conversion}} \
36 // expected-note{{passing argument to parameter 't' here}}
37 void f(T t = 10); // expected-error{{no viable conversion}} \
38 // expected-note{{passing argument to parameter 't' here}}
39 };
40
41 struct FD : F<int> { };
42
g2()43 void g2() {
44 F<int> f;
45 FD fd;
46 }
47
g3(F<int> f,F<struct S> s)48 void g3(F<int> f, F<struct S> s) {
49 f.f();
50 s.f(); // expected-note{{in instantiation of default function argument expression for 'f<S>' required here}}
51
52 F<int> f2;
53 F<S> s2; // expected-note{{in instantiation of default function argument expression for 'F<S>' required here}}
54 }
55
56 template<typename T> struct G {
GG57 G(T) {}
58 };
59
s(G<int> flags=10)60 void s(G<int> flags = 10) { }
61
62 // Test default arguments
63 template<typename T>
64 struct X0 {
65 void f(T = T()); // expected-error{{no matching}}
66 };
67
68 template<typename U>
f(U)69 void X0<U>::f(U) { }
70
test_x0(X0<int> xi)71 void test_x0(X0<int> xi) {
72 xi.f();
73 xi.f(17);
74 }
75
76 struct NotDefaultConstructible { // expected-note 2 {{candidate constructor (the implicit copy constructor) not viable}}
77 #if __cplusplus >= 201103L // C++11 or later
78 // expected-note@-2 2 {{candidate constructor (the implicit move constructor) not viable}}
79 #endif
80 NotDefaultConstructible(int); // expected-note 2{{candidate}}
81 };
82
test_x0_not_default_constructible(X0<NotDefaultConstructible> xn)83 void test_x0_not_default_constructible(X0<NotDefaultConstructible> xn) {
84 xn.f(NotDefaultConstructible(17));
85 xn.f(42);
86 xn.f(); // expected-note{{in instantiation of default function argument}}
87 }
88
89 template<typename T>
90 struct X1 {
91 typedef T value_type;
92 X1(const value_type& value = value_type());
93 };
94
test_X1()95 void test_X1() {
96 X1<int> x1;
97 }
98
99 template<typename T>
100 struct X2 {
101 void operator()(T = T()); // expected-error{{no matching}}
102 };
103
test_x2(X2<int> x2i,X2<NotDefaultConstructible> x2n)104 void test_x2(X2<int> x2i, X2<NotDefaultConstructible> x2n) {
105 x2i();
106 x2i(17);
107 x2n(NotDefaultConstructible(17));
108 x2n(); // expected-note{{in instantiation of default function argument}}
109 }
110
111 // PR5283
112 namespace PR5283 {
113 template<typename T> struct A {
114 A(T = 1); // expected-error 3 {{cannot initialize a parameter of type 'int *' with an rvalue of type 'int'}} \
115 // expected-note 3{{passing argument to parameter here}}
116 };
117
118 struct B : A<int*> {
119 B();
120 };
B()121 B::B() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
122
123 struct C : virtual A<int*> {
124 C();
125 };
C()126 C::C() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
127
128 struct D {
129 D();
130
131 A<int*> a;
132 };
D()133 D::D() { } // expected-note {{in instantiation of default function argument expression for 'A<int *>' required he}}
134 }
135
136 // PR5301
137 namespace pr5301 {
138 void f(int, int = 0);
139
140 template <typename T>
141 void g(T, T = 0);
142
143 template <int I>
144 void i(int a = I);
145
146 template <typename T>
h(T t)147 void h(T t) {
148 f(0);
149 g(1);
150 g(t);
151 i<2>();
152 }
153
test()154 void test() {
155 h(0);
156 }
157 }
158
159 // PR5810
160 namespace PR5810 {
161 template<typename T>
162 struct allocator {
allocatorPR5810::allocator163 allocator() { int a[sizeof(T) ? -1 : -1]; } // expected-error2 {{array with a negative size}}
164 };
165
166 template<typename T>
167 struct vector {
vectorPR5810::vector168 vector(const allocator<T>& = allocator<T>()) {} // expected-note2 {{instantiation of}}
169 };
170
171 struct A { };
172 struct B { };
173
174 template<typename>
FilterVTs()175 void FilterVTs() {
176 vector<A> Result;
177 }
178
f()179 void f() {
180 vector<A> Result;
181 }
182
183 template<typename T>
184 struct X {
185 vector<B> bs;
XPR5810::X186 X() { }
187 };
188
f2()189 void f2() {
190 X<float> x; // expected-note{{member function}}
191 }
192 }
193
194 template<typename T> void f4(T, int = 17);
195 template<> void f4<int>(int, int);
196
f4_test(int i)197 void f4_test(int i) {
198 f4(i);
199 }
200
201 // Instantiate for initialization
202 namespace InstForInit {
203 template<typename T>
204 struct Ptr {
205 typedef T* type;
206 Ptr(type);
207 };
208
209 template<typename T>
210 struct Holder {
211 Holder(int i, Ptr<T> ptr = 0);
212 };
213
test_holder(int i)214 void test_holder(int i) {
215 Holder<int> h(i);
216 }
217 };
218
219 namespace PR5810b {
220 template<typename T>
broken()221 T broken() {
222 T t;
223 double**** not_it = t;
224 }
225
226 void f(int = broken<int>());
g()227 void g() { f(17); }
228 }
229
230 namespace PR5810c {
231 template<typename T>
232 struct X {
XPR5810c::X233 X() {
234 T t;
235 double *****p = t; // expected-error{{cannot initialize a variable of type 'double *****' with an lvalue of type 'int'}}
236 }
XPR5810c::X237 X(const X&) { }
238 };
239
240 struct Y : X<int> { // expected-note{{instantiation of}}
241 };
242
243 void f(Y y = Y());
244
g()245 void g() { f(); }
246 }
247
248 namespace PR8127 {
249 template< typename T > class PointerClass {
250 public:
PointerClass(T * object_p)251 PointerClass( T * object_p ) : p_( object_p ) {
252 p_->acquire();
253 }
254 private:
255 T * p_;
256 };
257
258 class ExternallyImplementedClass;
259
260 class MyClass {
261 void foo( PointerClass<ExternallyImplementedClass> = 0 );
262 };
263 }
264
265 namespace rdar8427926 {
266 template<typename T>
267 struct Boom {
~Boomrdar8427926::Boom268 ~Boom() {
269 T t;
270 double *******ptr = t; // expected-error 2{{cannot initialize}}
271 }
272 };
273
274 Boom<float> *bfp;
275
276 struct X {
frdar8427926::X277 void f(Boom<int> = Boom<int>()) { } // expected-note{{requested here}}
278 void g(int x = (delete bfp, 0)); // expected-note{{requested here}}
279 };
280
test(X * x)281 void test(X *x) {
282 x->f();
283 x->g();
284 }
285 }
286
287 namespace PR8401 {
288 template<typename T>
289 struct A {
APR8401::A290 A() { T* x = 1; } // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
291 };
292
293 template<typename T>
294 struct B {
295 B(const A<T>& a = A<T>()); // expected-note{{in instantiation of}}
296 };
297
298 void f(B<int> b = B<int>());
299
g()300 void g() {
301 f();
302 }
303 }
304
305 namespace PR12581 {
306 const int a = 0;
307 template < typename > struct A;
308 template < typename MatrixType, int =
309 A < MatrixType >::Flags ? : A < MatrixType >::Flags & a > class B;
310 void
fn1()311 fn1 ()
312 {
313 }
314 }
315
316 namespace PR13758 {
317 template <typename T> struct move_from {
318 T invalid;
319 };
320 template <class K>
321 struct unordered_map {
322 explicit unordered_map(int n = 42);
323 unordered_map(move_from<K> other);
324 };
325 template<typename T>
StripedHashTable()326 void StripedHashTable() {
327 new unordered_map<void>();
328 new unordered_map<void>;
329 }
tt()330 void tt() {
331 StripedHashTable<int>();
332 }
333 }
334