Clang Project

clang_source_code/test/SemaTemplate/instantiate-expr-4.cpp
1// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
2// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++98 %s
3// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify -std=c++11 %s
4
5// ---------------------------------------------------------------------
6// C++ Functional Casts
7// ---------------------------------------------------------------------
8template<int N>
9struct ValueInit0 {
10  int f() {
11    return int();
12  }
13};
14
15template struct ValueInit0<5>;
16
17template<int N>
18struct FunctionalCast0 {
19  int f() {
20    return int(N);
21  }
22};
23
24template struct FunctionalCast0<5>;
25
26struct X { // expected-note 3 {{candidate constructor (the implicit copy constructor)}}
27#if __cplusplus >= 201103L
28// expected-note@-2 3 {{candidate constructor (the implicit move constructor) not viable}}
29#endif
30  X(int, int); // expected-note 3 {{candidate constructor}}
31};
32
33template<int N, int M>
34struct BuildTemporary0 {
35  X f() {
36    return X(N, M);
37  }
38};
39
40template struct BuildTemporary0<5, 7>;
41
42template<int N, int M>
43struct Temporaries0 {
44  void f() {
45    (void)X(N, M);
46  }
47};
48
49template struct Temporaries0<5, 7>;
50
51// Ensure that both the constructor and the destructor are instantiated by
52// checking for parse errors from each.
53template<int N> struct BadX {
54  BadX() { int a[-N]; } // expected-error {{array with a negative size}}
55  ~BadX() { int a[-N]; } // expected-error {{array with a negative size}}
56};
57
58template<int N>
59struct PR6671 {
60  void f() { (void)BadX<1>(); } // expected-note 2 {{instantiation}}
61};
62template struct PR6671<1>;
63
64// ---------------------------------------------------------------------
65// new/delete expressions
66// ---------------------------------------------------------------------
67struct Y { };
68
69template<typename T>
70struct New0 {
71  T* f(bool x) {
72    if (x)
73      return new T; // expected-error{{no matching}}
74    else
75      return new T();
76  }
77};
78
79template struct New0<int>;
80template struct New0<Y>;
81template struct New0<X>; // expected-note{{instantiation}}
82
83template<typename T, typename Arg1>
84struct New1 {
85  T* f(bool x, Arg1 a1) {
86    return new T(a1); // expected-error{{no matching}}
87  }
88};
89
90template struct New1<int, float>;
91template struct New1<Y, Y>;
92template struct New1<X, Y>; // expected-note{{instantiation}}
93
94template<typename T, typename Arg1, typename Arg2>
95struct New2 {
96  T* f(bool x, Arg1 a1, Arg2 a2) {
97    return new T(a1, a2); // expected-error{{no matching}}
98  }
99};
100
101template struct New2<X, int, float>;
102template struct New2<X, int, int*>; // expected-note{{instantiation}}
103// FIXME: template struct New2<int, int, float>;
104
105// PR5833
106struct New3 {
107  New3();
108
109  void *operator new[](__SIZE_TYPE__) __attribute__((unavailable)); // expected-note{{explicitly marked unavailable here}}
110};
111
112template<class C>
113void* object_creator() {
114  return new C(); // expected-error{{'operator new[]' is unavailable}}
115}
116
117template void *object_creator<New3[4]>(); // expected-note{{instantiation}}
118
119template<typename T>
120struct Delete0 {
121  void f(T t) {
122    delete t; // expected-error{{cannot delete}}
123    ::delete [] t; // expected-error{{cannot delete}}
124  }
125};
126
127template struct Delete0<int*>;
128template struct Delete0<X*>;
129template struct Delete0<int>; // expected-note{{instantiation}}
130
131namespace PR5755 {
132  template <class T>
133  void Foo() {
134    char* p = 0;
135    delete[] p;
136  }
137  
138  void Test() {
139    Foo<int>();
140  }
141}
142
143namespace PR10480 {
144  template<typename T>
145  struct X {
146    X();
147    ~X() {
148      T *ptr = 1; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
149    }
150  };
151
152  template<typename T>
153  void f() {
154    new X<int>[1]; // expected-note{{in instantiation of member function 'PR10480::X<int>::~X' requested here}}
155  }
156
157  template void f<int>();
158}
159
160// ---------------------------------------------------------------------
161// throw expressions
162// ---------------------------------------------------------------------
163template<typename T>
164struct Throw1 {
165  void f(T t) {
166    throw;
167    throw t; // expected-error{{incomplete type}}
168  }
169};
170
171struct Incomplete; // expected-note 2{{forward}}
172
173template struct Throw1<int>;
174template struct Throw1<int*>;
175template struct Throw1<Incomplete*>; // expected-note{{instantiation}}
176
177// ---------------------------------------------------------------------
178// typeid expressions
179// ---------------------------------------------------------------------
180
181namespace std {
182  class type_info;
183}
184
185template<typename T>
186struct TypeId0 {
187  const std::type_info &f(T* ptr) {
188    if (ptr)
189      return typeid(ptr);
190    else
191      return typeid(T); // expected-error{{'typeid' of incomplete type 'Incomplete'}}
192  }
193};
194
195struct Abstract {
196  virtual void f() = 0;
197};
198
199template struct TypeId0<int>;
200template struct TypeId0<Incomplete>; // expected-note{{instantiation of member function}}
201template struct TypeId0<Abstract>;
202
203// ---------------------------------------------------------------------
204// type traits
205// ---------------------------------------------------------------------
206template<typename T>
207struct is_pod {
208  static const bool value = __is_pod(T);
209};
210
211static int is_pod0[is_pod<X>::value? -1 : 1];
212static int is_pod1[is_pod<Y>::value? 1 : -1];
213
214// ---------------------------------------------------------------------
215// initializer lists
216// ---------------------------------------------------------------------
217template<typename T, typename Val1>
218struct InitList1 {
219  void f(Val1 val1) { 
220    T x = { val1 };
221#if __cplusplus >= 201103L
222    // expected-error@-2 {{type 'float' cannot be narrowed to 'int' in initializer list}}
223    // expected-note@-3 {{insert an explicit cast to silence this issue}}
224#endif
225  }
226};
227
228struct APair {
229  int *x;
230  const float *y;
231};
232
233template struct InitList1<int[1], float>;
234#if __cplusplus >= 201103L
235// expected-note@-2 {{instantiation of member function}}
236#endif
237template struct InitList1<APair, int*>;
238
239template<typename T, typename Val1, typename Val2>
240struct InitList2 {
241  void f(Val1 val1, Val2 val2) { 
242    T x = { val1, val2 }; // expected-error{{cannot initialize}}
243  }
244};
245
246template struct InitList2<APair, int*, float*>;
247template struct InitList2<APair, int*, double*>; // expected-note{{instantiation}}
248
249// ---------------------------------------------------------------------
250// member references
251// ---------------------------------------------------------------------
252template<typename T, typename Result>
253struct DotMemRef0 {
254  void f(T t) {
255    Result result = t.m; // expected-error{{non-const lvalue reference to type}}
256  }
257};
258
259struct MemInt {
260  int m;
261};
262
263struct InheritsMemInt : MemInt { };
264
265struct MemIntFunc {
266  static int m(int);
267};
268
269template struct DotMemRef0<MemInt, int&>;
270template struct DotMemRef0<InheritsMemInt, int&>;
271template struct DotMemRef0<MemIntFunc, int (*)(int)>;
272template struct DotMemRef0<MemInt, float&>; // expected-note{{instantiation}}
273
274template<typename T, typename Result>
275struct ArrowMemRef0 {
276  void f(T t) {
277    Result result = t->m; // expected-error 2{{non-const lvalue reference}}
278  }
279};
280
281template<typename T>
282struct ArrowWrapper {
283  T operator->();
284};
285
286template struct ArrowMemRef0<MemInt*, int&>;
287template struct ArrowMemRef0<InheritsMemInt*, int&>;
288template struct ArrowMemRef0<MemIntFunc*, int (*)(int)>;
289template struct ArrowMemRef0<MemInt*, float&>; // expected-note{{instantiation}}
290
291template struct ArrowMemRef0<ArrowWrapper<MemInt*>, int&>;
292template struct ArrowMemRef0<ArrowWrapper<InheritsMemInt*>, int&>;
293template struct ArrowMemRef0<ArrowWrapper<MemIntFunc*>, int (*)(int)>;
294template struct ArrowMemRef0<ArrowWrapper<MemInt*>, float&>; // expected-note{{instantiation}}
295template struct ArrowMemRef0<ArrowWrapper<ArrowWrapper<MemInt*> >, int&>;
296
297struct UnresolvedMemRefArray {
298  int f(int);
299  int f(char);
300};
301UnresolvedMemRefArray Arr[10];
302template<typename U> int UnresolvedMemRefArrayT(U u) {
303  return Arr->f(u);
304}
305template int UnresolvedMemRefArrayT<int>(int);
306
307// FIXME: we should be able to return a MemInt without the reference!
308MemInt &createMemInt(int);
309
310template<int N>
311struct NonDepMemberExpr0 {
312  void f() {
313    createMemInt(N).m = N;
314  }
315};
316
317template struct NonDepMemberExpr0<0>; 
318
319template<typename T, typename Result>
320struct MemberFuncCall0 {
321  void f(T t) {
322    Result result = t.f();
323  }
324};
325
326template<typename T>
327struct HasMemFunc0 {
328  T f();
329};
330
331
332template struct MemberFuncCall0<HasMemFunc0<int&>, const int&>;
333
334template<typename Result>
335struct ThisMemberFuncCall0 {
336  Result g();
337
338  void f() {
339    Result r1 = g();
340    Result r2 = this->g();
341  }
342};
343
344template struct ThisMemberFuncCall0<int&>;
345
346template<typename T>
347struct NonDepMemberCall0 {
348  void foo(HasMemFunc0<int&> x) {
349    T result = x.f(); // expected-error{{non-const lvalue reference}}
350  }
351};
352
353template struct NonDepMemberCall0<int&>;
354template struct NonDepMemberCall0<const int&>;
355template struct NonDepMemberCall0<float&>; // expected-note{{instantiation}}
356
357
358template<typename T>
359struct QualifiedDeclRef0 {
360  T f() {
361    return is_pod<X>::value; // expected-error{{non-const lvalue reference to type 'int' cannot bind to a value of unrelated type 'const bool'}}
362  }
363};
364
365template struct QualifiedDeclRef0<bool>;
366template struct QualifiedDeclRef0<int&>; // expected-note{{instantiation}}
367
CodeThinker, Enjoy your reading code