|
150
|
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>
|
|
|
135 container<DT> initializer(const DT& d) {
|
|
|
136 return container<DT>();
|
|
|
137 }
|
|
|
138
|
|
|
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>
|
|
|
155 void S<X>::f() {}
|
|
|
156 }
|
|
|
157
|
|
|
158 namespace DR1635 {
|
|
|
159 template <class T> struct X {
|
|
|
160 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
|
|
|
164 static void f(...) {}
|
|
|
165 };
|
|
|
166
|
|
|
167 int g() { X<int>::f(0); } // expected-note {{in instantiation of template class 'DR1635::X<int>' requested here}}
|
|
|
168 }
|
|
|
169
|
|
|
170 namespace NondefDecls {
|
|
|
171 template<typename T> void f1() {
|
|
236
|
172 int g1(int defarg = T::error); // expected-error{{type 'int' cannot be used prior to '::' because it has no members}} \
|
|
|
173 // expected-note {{in instantiation of default function argument expression for 'g1<int>' required here}}
|
|
150
|
174 }
|
|
|
175 template void f1<int>(); // expected-note{{in instantiation of function template specialization 'NondefDecls::f1<int>' requested here}}
|
|
|
176 }
|
|
|
177
|
|
|
178 template <typename T>
|
|
|
179 struct C {
|
|
|
180 C(T t = ); // expected-error {{expected expression}}
|
|
|
181 };
|
|
|
182 C<int> obj;
|
|
|
183
|
|
|
184 namespace PR26134 {
|
|
|
185 // Make sure when substituting default template arguments we do it in the current context.
|
|
|
186 template<class T, bool Val = T::value>
|
|
|
187 struct X {};
|
|
|
188
|
|
|
189 template<bool B> struct Y {
|
|
|
190 void f() { X<Y> xy; }
|
|
|
191 static const bool value = B;
|
|
|
192 };
|
|
|
193
|
|
|
194 namespace ns1 {
|
|
|
195 template<class T0>
|
|
|
196 struct X {
|
|
|
197 template<bool B = T0::value> struct XInner { static const bool value = B; };
|
|
|
198 };
|
|
|
199 template<bool B> struct S { static const bool value = B; };
|
|
|
200 #if __cplusplus > 199711L
|
|
|
201 template<bool B> struct Y {
|
|
|
202 static constexpr bool f() { return typename X<S<B>>::template XInner<>{}.value; }
|
|
|
203 static_assert(f() == B, "");
|
|
|
204 };
|
|
|
205 Y<true> y;
|
|
|
206 Y<false> y2;
|
|
|
207 #endif
|
|
|
208
|
|
|
209 } // end ns1
|
|
|
210 } // end ns PR26134
|
|
|
211
|
|
|
212 namespace friends {
|
|
|
213 namespace ns {
|
|
|
214 template<typename> struct A {
|
|
|
215 template<typename> friend void f();
|
|
|
216 template<typename> friend struct X;
|
|
|
217 };
|
|
|
218 template<typename = int> void f(); // expected-warning 0-1{{extension}}
|
|
|
219 template<typename = int> struct X;
|
|
|
220 A<int> a;
|
|
|
221 }
|
|
|
222 namespace ns {
|
|
|
223 void g() { f(); }
|
|
|
224 X<int> *p;
|
|
|
225 }
|
|
|
226 }
|
|
|
227
|
|
|
228 namespace unevaluated {
|
|
|
229 int a;
|
|
|
230 template<int = 0> int f(int = a); // expected-warning 0-1{{extension}}
|
|
|
231 int k = sizeof(f());
|
|
|
232 }
|
