Clang Project

clang_source_code/test/SemaCXX/compare.cpp
1// Force x86-64 because some of our heuristics are actually based
2// on integer sizes.
3
4// RUN: %clang_cc1 -triple x86_64-apple-darwin -fsyntax-only -pedantic -verify -Wsign-compare -Wtautological-constant-in-range-compare -std=c++11 %s
5
6int test0(long a, unsigned long b) {
7  enum EnumA {A};
8  enum EnumB {B};
9  enum EnumC {C = 0x10000};
10  return
11         // (a,b)
12         (a == (unsigned long) b) +  // expected-warning {{comparison of integers of different signs}}
13         (a == (unsigned int) b) +
14         (a == (unsigned short) b) +
15         (a == (unsigned char) b) +
16         ((long) a == b) +  // expected-warning {{comparison of integers of different signs}}
17         ((int) a == b) +  // expected-warning {{comparison of integers of different signs}}
18         ((short) a == b) +  // expected-warning {{comparison of integers of different signs}}
19         ((signed char) a == b) +  // expected-warning {{comparison of integers of different signs}}
20         ((long) a == (unsigned long) b) +  // expected-warning {{comparison of integers of different signs}}
21         ((int) a == (unsigned int) b) +  // expected-warning {{comparison of integers of different signs}}
22         ((short) a == (unsigned short) b) +
23         ((signed char) a == (unsigned char) b) +
24         (a < (unsigned long) b) +  // expected-warning {{comparison of integers of different signs}}
25         (a < (unsigned int) b) +
26         (a < (unsigned short) b) +
27         (a < (unsigned char) b) +
28         ((long) a < b) +  // expected-warning {{comparison of integers of different signs}}
29         ((int) a < b) +  // expected-warning {{comparison of integers of different signs}}
30         ((short) a < b) +  // expected-warning {{comparison of integers of different signs}}
31         ((signed char) a < b) +  // expected-warning {{comparison of integers of different signs}}
32         ((long) a < (unsigned long) b) +  // expected-warning {{comparison of integers of different signs}}
33         ((int) a < (unsigned int) b) +  // expected-warning {{comparison of integers of different signs}}
34         ((short) a < (unsigned short) b) +
35         ((signed char) a < (unsigned char) b) +
36
37         // (A,b)
38         (A == (unsigned long) b) +
39         (A == (unsigned int) b) +
40         (A == (unsigned short) b) +
41         (A == (unsigned char) b) +
42         ((long) A == b) +
43         ((int) A == b) +
44         ((short) A == b) +
45         ((signed char) A == b) +
46         ((long) A == (unsigned long) b) +
47         ((int) A == (unsigned int) b) +
48         ((short) A == (unsigned short) b) +
49         ((signed char) A == (unsigned char) b) +
50         (A < (unsigned long) b) +
51         (A < (unsigned int) b) +
52         (A < (unsigned short) b) +
53         (A < (unsigned char) b) +
54         ((long) A < b) +
55         ((int) A < b) +
56         ((short) A < b) +
57         ((signed char) A < b) +
58         ((long) A < (unsigned long) b) +
59         ((int) A < (unsigned int) b) +
60         ((short) A < (unsigned short) b) +
61         ((signed char) A < (unsigned char) b) +
62
63         // (a,B)
64         (a == (unsigned long) B) +
65         (a == (unsigned int) B) +
66         (a == (unsigned short) B) +
67         (a == (unsigned char) B) +
68         ((long) a == B) +
69         ((int) a == B) +
70         ((short) a == B) +
71         ((signed char) a == B) +
72         ((long) a == (unsigned long) B) +
73         ((int) a == (unsigned int) B) +
74         ((short) a == (unsigned short) B) +
75         ((signed char) a == (unsigned char) B) +
76         (a < (unsigned long) B) +  // expected-warning {{comparison of unsigned expression < 0 is always false}}
77         (a < (unsigned int) B) +
78         (a < (unsigned short) B) +
79         (a < (unsigned char) B) +
80         ((long) a < B) +
81         ((int) a < B) +
82         ((short) a < B) +
83         ((signed char) a < B) +
84         ((long) a < (unsigned long) B) +  // expected-warning {{comparison of unsigned expression < 0 is always false}}
85         ((int) a < (unsigned int) B) +  // expected-warning {{comparison of unsigned expression < 0 is always false}}
86         ((short) a < (unsigned short) B) +
87         ((signed char) a < (unsigned char) B) +
88
89         // (C,b)
90         (C == (unsigned long) b) +
91         (C == (unsigned int) b) +
92         (C == (unsigned short) b) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'unsigned short' is always false}}
93         (C == (unsigned char) b) +  // expected-warning {{comparison of constant 'C' (65536) with expression of type 'unsigned char' is always false}}
94         ((long) C == b) +
95         ((int) C == b) +
96         ((short) C == b) +
97         ((signed char) C == b) +
98         ((long) C == (unsigned long) b) +
99         ((int) C == (unsigned int) b) +
100         ((short) C == (unsigned short) b) +
101         ((signed char) C == (unsigned char) b) +
102         (C < (unsigned long) b) +
103         (C < (unsigned int) b) +
104         (C < (unsigned short) b) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'unsigned short' is always false}}
105         (C < (unsigned char) b) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'unsigned char' is always false}}
106         ((long) C < b) +
107         ((int) C < b) +
108         ((short) C < b) +
109         ((signed char) C < b) +
110         ((long) C < (unsigned long) b) +
111         ((int) C < (unsigned int) b) +
112         ((short) C < (unsigned short) b) +
113         ((signed char) C < (unsigned char) b) +
114
115         // (a,C)
116         (a == (unsigned long) C) +
117         (a == (unsigned int) C) +
118         (a == (unsigned short) C) +
119         (a == (unsigned char) C) +
120         ((long) a == C) +
121         ((int) a == C) +
122         ((short) a == C) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'short' is always false}}
123         ((signed char) a == C) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'signed char' is always false}}
124         ((long) a == (unsigned long) C) +
125         ((int) a == (unsigned int) C) +
126         ((short) a == (unsigned short) C) +
127         ((signed char) a == (unsigned char) C) +
128         (a < (unsigned long) C) +  // expected-warning {{comparison of integers of different signs}}
129         (a < (unsigned int) C) +
130         (a < (unsigned short) C) +
131         (a < (unsigned char) C) +
132         ((long) a < C) +
133         ((int) a < C) +
134         ((short) a < C) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'short' is always true}}
135         ((signed char) a < C) + // expected-warning {{comparison of constant 'C' (65536) with expression of type 'signed char' is always true}}
136         ((long) a < (unsigned long) C) +  // expected-warning {{comparison of integers of different signs}}
137         ((int) a < (unsigned int) C) +  // expected-warning {{comparison of integers of different signs}}
138         ((short) a < (unsigned short) C) +
139         ((signed char) a < (unsigned char) C) +
140
141         // (0x80000,b)
142         (0x80000 == (unsigned long) b) +
143         (0x80000 == (unsigned int) b) +
144         (0x80000 == (unsigned short) b) + // expected-warning {{comparison of constant 524288 with expression of type 'unsigned short' is always false}}
145         (0x80000 == (unsigned char) b) + // expected-warning {{comparison of constant 524288 with expression of type 'unsigned char' is always false}}
146         ((long) 0x80000 == b) +
147         ((int) 0x80000 == b) +
148         ((short) 0x80000 == b) +
149         ((signed char) 0x80000 == b) +
150         ((long) 0x80000 == (unsigned long) b) +
151         ((int) 0x80000 == (unsigned int) b) +
152         ((short) 0x80000 == (unsigned short) b) +
153         ((signed char) 0x80000 == (unsigned char) b) +
154         (0x80000 < (unsigned long) b) +
155         (0x80000 < (unsigned int) b) +
156         (0x80000 < (unsigned short) b) + // expected-warning {{comparison of constant 524288 with expression of type 'unsigned short' is always false}}
157         (0x80000 < (unsigned char) b) + // expected-warning {{comparison of constant 524288 with expression of type 'unsigned char' is always false}}
158         ((long) 0x80000 < b) +
159         ((int) 0x80000 < b) +
160         ((short) 0x80000 < b) +
161         ((signed char) 0x80000 < b) +
162         ((long) 0x80000 < (unsigned long) b) +
163         ((int) 0x80000 < (unsigned int) b) +
164         ((short) 0x80000 < (unsigned short) b) +
165         ((signed char) 0x80000 < (unsigned char) b) +
166
167         // (a,0x80000)
168         (a == (unsigned long) 0x80000) +
169         (a == (unsigned int) 0x80000) +
170         (a == (unsigned short) 0x80000) +
171         (a == (unsigned char) 0x80000) +
172         ((long) a == 0x80000) +
173         ((int) a == 0x80000) +
174         ((short) a == 0x80000) + // expected-warning {{comparison of constant 524288 with expression of type 'short' is always false}}
175         ((signed char) a == 0x80000) + // expected-warning {{comparison of constant 524288 with expression of type 'signed char' is always false}}
176         ((long) a == (unsigned long) 0x80000) +
177         ((int) a == (unsigned int) 0x80000) +
178         ((short) a == (unsigned short) 0x80000) +
179         ((signed char) a == (unsigned char) 0x80000) +
180         (a < (unsigned long) 0x80000) +  // expected-warning {{comparison of integers of different signs}}
181         (a < (unsigned int) 0x80000) +
182         (a < (unsigned short) 0x80000) +
183         (a < (unsigned char) 0x80000) +
184         ((long) a < 0x80000) +
185         ((int) a < 0x80000) +
186         ((short) a < 0x80000) + // expected-warning {{comparison of constant 524288 with expression of type 'short' is always true}}
187         ((signed char) a < 0x80000) + // expected-warning {{comparison of constant 524288 with expression of type 'signed char' is always true}}
188         ((long) a < (unsigned long) 0x80000) +  // expected-warning {{comparison of integers of different signs}}
189         ((int) a < (unsigned int) 0x80000) +  // expected-warning {{comparison of integers of different signs}}
190         ((short) a < (unsigned short) 0x80000) +
191         ((signed char) a < (unsigned char) 0x80000) +
192
193         10
194    ;
195}
196
197int test1(int i) {
198  enum en { zero };
199  return i > zero;
200}
201
202enum E { e };
203void test2(int i, void *vp) {
204  if (&i == vp) { } // ok
205  if (test1 == vp) { } // expected-warning{{equality comparison between function pointer and void pointer}}
206  if (test1 == e) { } // expected-error{{comparison between pointer and integer}}
207  if (vp < 0) { } // expected-error {{comparison between pointer and zero}}
208  if (test1 < e) { } // expected-error{{comparison between pointer and integer}}
209}
210
211// PR7536
212static const unsigned int kMax = 0;
213int pr7536() {
214  return (kMax > 0);
215}
216
217// -Wsign-compare should not warn when ?: operands have different signedness.
218// This will be caught by -Wsign-conversion
219void test3() {
220  unsigned long a;
221  signed long b;
222  (void) (true ? a : b);
223  (void) (true ? (unsigned int)a : (signed int)b);
224  (void) (true ? b : a);
225  (void) (true ? (unsigned char)b : (signed char)a);
226}
227
228// Test comparison of short to unsigned.  If tautological compare does not
229// trigger, then the signed comparison warning will.
230void test4(short s) {
231  // A is max short plus 1.  All zero and positive shorts are smaller than it.
232  // All negative shorts are cast towards the max unsigned range.  Relation
233  // comparisons are possible, but equality comparisons are tautological.
234  const unsigned A = 32768;
235  void (s < A); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
236  void (s > A); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
237  void (s <= A); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
238  void (s >= A); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
239
240  void (s == A); // expected-warning{{comparison of constant 32768 with expression of type 'short' is always false}}
241  void (s != A); // expected-warning{{comparison of constant 32768 with expression of type 'short' is always true}}
242
243  // When negative one is converted to an unsigned value, it becomes the max
244  // unsigned.  Likewise, a negative one short can also be converted to max
245  // unsigned.
246  const unsigned B = -1;
247  void (s < B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
248  void (s > B); // expected-warning{{comparison 'short' > 4294967295 is always false}}
249  void (s <= B); // expected-warning{{comparison 'short' <= 4294967295 is always true}}
250  void (s >= B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
251  void (s == B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
252  void (s != B); // expected-warning{{comparison of integers of different signs: 'short' and 'const unsigned int'}}
253
254}
255
256void test5(bool b) {
257  (void) (b < -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always false}}
258  (void) (b > -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always true}}
259  (void) (b == -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always false}}
260  (void) (b != -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always true}}
261  (void) (b <= -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always false}}
262  (void) (b >= -1); // expected-warning{{comparison of constant -1 with expression of type 'bool' is always true}}
263
264  (void) (b < -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always false}}
265  (void) (b > -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always true}}
266  (void) (b == -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always false}}
267  (void) (b != -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always true}}
268  (void) (b <= -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always false}}
269  (void) (b >= -10); // expected-warning{{comparison of constant -10 with expression of type 'bool' is always true}}
270
271  (void) (b < 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always true}}
272  (void) (b > 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always false}}
273  (void) (b == 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always false}}
274  (void) (b != 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always true}}
275  (void) (b <= 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always true}}
276  (void) (b >= 2); // expected-warning{{comparison of constant 2 with expression of type 'bool' is always false}}
277
278  (void) (b < 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always true}}
279  (void) (b > 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always false}}
280  (void) (b == 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always false}}
281  (void) (b != 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always true}}
282  (void) (b <= 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always true}}
283  (void) (b >= 10); // expected-warning{{comparison of constant 10 with expression of type 'bool' is always false}}
284}
285
286void test6(signed char sc) {
287  (void)(sc < 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
288  (void)(sc > 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
289  (void)(sc <= 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
290  (void)(sc >= 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
291  (void)(sc == 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
292  (void)(sc != 200); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
293
294  (void)(200 < sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
295  (void)(200 > sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
296  (void)(200 <= sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
297  (void)(200 >= sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
298  (void)(200 == sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always false}}
299  (void)(200 != sc); // expected-warning{{comparison of constant 200 with expression of type 'signed char' is always true}}
300}
301
302// Test many signedness combinations.
303void test7(unsigned long other) {
304  // Common unsigned, other unsigned, constant unsigned
305  (void)((unsigned)other != (unsigned long)(0x1ffffffff)); // expected-warning{{true}}
306  (void)((unsigned)other != (unsigned long)(0xffffffff));
307  (void)((unsigned long)other != (unsigned)(0x1ffffffff));
308  (void)((unsigned long)other != (unsigned)(0xffffffff));
309
310  // Common unsigned, other signed, constant unsigned
311  (void)((int)other != (unsigned long)(0xffffffffffffffff)); // expected-warning{{different signs}}
312  (void)((int)other != (unsigned long)(0x00000000ffffffff)); // expected-warning{{true}}
313  (void)((int)other != (unsigned long)(0x000000000fffffff));
314  (void)((int)other < (unsigned long)(0x00000000ffffffff));  // expected-warning{{different signs}}
315  (void)((int)other == (unsigned)(0x800000000));
316
317  // Common unsigned, other unsigned, constant signed
318  (void)((unsigned long)other != (int)(0xffffffff));  // expected-warning{{different signs}}
319
320  // Common unsigned, other signed, constant signed
321  // Should not be possible as the common type should also be signed.
322
323  // Common signed, other signed, constant signed
324  (void)((int)other != (long)(0xffffffff));  // expected-warning{{true}}
325  (void)((int)other != (long)(0xffffffff00000000));  // expected-warning{{true}}
326  (void)((int)other != (long)(0xfffffff));
327  (void)((int)other != (long)(0xfffffffff0000000));
328
329  // Common signed, other signed, constant unsigned
330  (void)((int)other != (unsigned char)(0xffff));
331  (void)((int)other != (unsigned char)(0xff));
332
333  // Common signed, other unsigned, constant signed
334  (void)((unsigned char)other != (int)(0xff));
335  (void)((unsigned char)other != (int)(0xffff));  // expected-warning{{true}}
336
337  // Common signed, other unsigned, constant unsigned
338  (void)((unsigned char)other != (unsigned short)(0xff));
339  (void)((unsigned char)other != (unsigned short)(0x100)); // expected-warning{{true}}
340  (void)((unsigned short)other != (unsigned char)(0xff));
341}
342
343void test8(int x) {
344  enum E {
345    Negative = -1,
346    Positive = 1
347  };
348
349  (void)((E)x == 1);
350  (void)((E)x == -1);
351}
352
353void test9(int x) {
354  enum E : int {
355    Positive = 1
356  };
357  (void)((E)x == 1);
358}
359
360namespace templates {
361  template<class T> T max();
362
363  template<> constexpr int max<int>() { return 2147483647; };
364
365  template<typename T>
366  bool less_than_max(short num, T value) {
367    const T vmax = max<T>();
368    return (vmax >= num);  // no warning
369  }
370
371  template<typename T>
372  bool less_than_max(short num) {
373    // This should trigger one warning on the template pattern, and not a
374    // warning per specialization.
375    return num < max<int>();  // expected-warning{{comparison of constant 2147483647 with expression of type 'short' is always true}}
376  }
377
378  void test10(short num, int x) {
379    less_than_max(num, x);
380    less_than_max<int>(num);
381    less_than_max<long>(num);
382    less_than_max<short>(num);
383  }
384
385  template<typename T>
386  inline bool less_than_zero(T num, T value) {
387    return num < 0;  // no warning
388  }
389
390  template<typename T>
391  inline bool less_than_zero(unsigned num) {
392    // This should trigger one warning on the template pattern, and not a
393    // warning per specialization.
394    return num < 0;  // expected-warning{{comparison of unsigned expression < 0 is always false}}
395  }
396
397  void test11(unsigned num) {
398    less_than_zero(num, num);
399    less_than_zero<int>(num);
400    less_than_zero<long>(num);
401    less_than_zero<short>(num);
402  }
403
404  template<unsigned n> bool compare(unsigned k) { return k >= n; }
405
406  void test12() {
407    compare<0>(42);
408  }
409
410  struct A { static int x; };
411  struct B { static int x; };
412  typedef A otherA;
413
414  template <typename T>
415  void testx() {
416    if (A::x == T::x &&  // no warning
417        A::x == otherA::x)  // expected-warning{{self-comparison always evaluates to true}}
418      return;
419  }
420
421  void test13() {
422    testx<A>();
423    testx<B>();
424  }
425}
426
427namespace tautological_enum {
428  enum E { a, b, c } e;
429
430  // FIXME: We should warn about constructing this out-of-range numeration value.
431  const E invalid = (E)-1;
432  // ... but we should not warn about comparing against it.
433  bool x = e == invalid;
434
435  // We should not warn about relational comparisons for enumerators, even if
436  // they're tautological.
437  bool y = e >= a && e <= b;
438  const E first_in_range = a;
439  const E last_in_range = b;
440  bool z = e >= first_in_range && e <= last_in_range;
441}
442
CodeThinker, Enjoy your reading code