1 | // RUN: %check_clang_tidy %s bugprone-standalone-empty %t |
2 | |
3 | namespace std { |
4 | template <typename T> |
5 | struct vector { |
6 | bool empty(); |
7 | }; |
8 | |
9 | template <typename T> |
10 | struct vector_with_clear { |
11 | bool empty(); |
12 | void clear(); |
13 | }; |
14 | |
15 | template <typename T> |
16 | struct vector_with_void_empty { |
17 | void empty(); |
18 | void clear(); |
19 | }; |
20 | |
21 | template <typename T> |
22 | struct vector_with_int_empty { |
23 | int empty(); |
24 | void clear(); |
25 | }; |
26 | |
27 | template <typename T> |
28 | struct vector_with_clear_args { |
29 | bool empty(); |
30 | void clear(int i); |
31 | }; |
32 | |
33 | template <typename T> |
34 | struct vector_with_clear_variable { |
35 | bool empty(); |
36 | int clear; |
37 | }; |
38 | |
39 | template <typename T> |
40 | bool empty(T &&); |
41 | |
42 | } // namespace std |
43 | |
44 | namespace absl { |
45 | struct string { |
46 | bool empty(); |
47 | }; |
48 | |
49 | struct string_with_clear { |
50 | bool empty(); |
51 | void clear(); |
52 | }; |
53 | |
54 | struct string_with_void_empty { |
55 | void empty(); |
56 | void clear(); |
57 | }; |
58 | |
59 | struct string_with_int_empty { |
60 | int empty(); |
61 | void clear(); |
62 | }; |
63 | |
64 | struct string_with_clear_args { |
65 | bool empty(); |
66 | void clear(int i); |
67 | }; |
68 | |
69 | struct string_with_clear_variable { |
70 | bool empty(); |
71 | int clear; |
72 | }; |
73 | |
74 | template <class T> |
75 | bool empty(T &&); |
76 | } // namespace absl |
77 | |
78 | namespace test { |
79 | template <class T> |
80 | void empty(T &&); |
81 | } // namespace test |
82 | |
83 | namespace test_no_args { |
84 | bool empty(); |
85 | } // namespace test_no_args |
86 | |
87 | namespace base { |
88 | template <typename T> |
89 | struct base_vector { |
90 | void clear(); |
91 | }; |
92 | |
93 | template <typename T> |
94 | struct base_vector_clear_with_args { |
95 | void clear(int i); |
96 | }; |
97 | |
98 | template <typename T> |
99 | struct base_vector_clear_variable { |
100 | int clear; |
101 | }; |
102 | |
103 | struct base_vector_non_dependent { |
104 | void clear(); |
105 | }; |
106 | |
107 | template <typename T> |
108 | struct vector : base_vector<T> { |
109 | bool empty(); |
110 | }; |
111 | |
112 | template <typename T> |
113 | struct vector_clear_with_args : base_vector_clear_with_args<T> { |
114 | bool empty(); |
115 | }; |
116 | |
117 | template <typename T> |
118 | struct vector_clear_variable : base_vector_clear_variable<T> { |
119 | bool empty(); |
120 | }; |
121 | |
122 | template <typename T> |
123 | struct vector_non_dependent : base_vector_non_dependent { |
124 | bool empty(); |
125 | }; |
126 | |
127 | template <typename T> |
128 | bool empty(T &&); |
129 | |
130 | } // namespace base |
131 | |
132 | namespace qualifiers { |
133 | template <typename T> |
134 | struct vector_with_const_clear { |
135 | bool empty() const; |
136 | void clear() const; |
137 | }; |
138 | |
139 | template <typename T> |
140 | struct vector_with_const_empty { |
141 | bool empty() const; |
142 | void clear(); |
143 | }; |
144 | |
145 | template <typename T> |
146 | struct vector_with_volatile_clear { |
147 | bool empty() volatile; |
148 | void clear() volatile; |
149 | }; |
150 | |
151 | template <typename T> |
152 | struct vector_with_volatile_empty { |
153 | bool empty() volatile; |
154 | void clear(); |
155 | }; |
156 | |
157 | template <typename T> |
158 | bool empty(T &&); |
159 | } // namespace qualifiers |
160 | |
161 | |
162 | bool test_member_empty() { |
163 | { |
164 | std::vector<int> v; |
165 | v.empty(); |
166 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
167 | } |
168 | |
169 | { |
170 | std::vector_with_void_empty<int> v; |
171 | v.empty(); |
172 | // no-warning |
173 | } |
174 | |
175 | { |
176 | std::vector_with_clear<int> v; |
177 | v.empty(); |
178 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
179 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
180 | } |
181 | |
182 | { |
183 | std::vector_with_int_empty<int> v; |
184 | v.empty(); |
185 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
186 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
187 | } |
188 | |
189 | { |
190 | std::vector_with_clear_args<int> v; |
191 | v.empty(); |
192 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
193 | } |
194 | |
195 | { |
196 | std::vector_with_clear_variable<int> v; |
197 | v.empty(); |
198 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
199 | } |
200 | |
201 | { |
202 | absl::string s; |
203 | s.empty(); |
204 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
205 | } |
206 | |
207 | { |
208 | absl::string_with_void_empty s; |
209 | s.empty(); |
210 | // no-warning |
211 | } |
212 | |
213 | { |
214 | absl::string_with_clear s; |
215 | s.empty(); |
216 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
217 | // CHECK-FIXES: {{^ }} s.clear();{{$}} |
218 | } |
219 | |
220 | { |
221 | absl::string_with_int_empty s; |
222 | s.empty(); |
223 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
224 | // CHECK-FIXES: {{^ }} s.clear();{{$}} |
225 | } |
226 | |
227 | { |
228 | absl::string_with_clear_args s; |
229 | s.empty(); |
230 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
231 | } |
232 | |
233 | { |
234 | absl::string_with_clear_variable s; |
235 | s.empty(); |
236 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
237 | } |
238 | |
239 | { |
240 | std::vector<int> v; |
241 | return v.empty(); |
242 | // no-warning |
243 | } |
244 | |
245 | { |
246 | std::vector_with_clear<int> v; |
247 | return v.empty(); |
248 | // no-warning |
249 | } |
250 | |
251 | { |
252 | std::vector_with_int_empty<int> v; |
253 | return v.empty(); |
254 | // no-warning |
255 | } |
256 | |
257 | { |
258 | std::vector_with_clear_args<int> v; |
259 | return v.empty(); |
260 | // no-warning |
261 | } |
262 | |
263 | { |
264 | std::vector_with_clear_variable<int> v; |
265 | return v.empty(); |
266 | // no-warning |
267 | } |
268 | |
269 | { |
270 | absl::string s; |
271 | return s.empty(); |
272 | // no-warning |
273 | } |
274 | |
275 | { |
276 | absl::string_with_clear s; |
277 | return s.empty(); |
278 | // no-warning |
279 | } |
280 | |
281 | { |
282 | absl::string_with_int_empty s; |
283 | return s.empty(); |
284 | // no-warning |
285 | } |
286 | |
287 | { |
288 | absl::string_with_clear_args s; |
289 | return s.empty(); |
290 | // no-warning |
291 | } |
292 | |
293 | { |
294 | absl::string_with_clear_variable s; |
295 | return s.empty(); |
296 | // no-warning |
297 | } |
298 | } |
299 | |
300 | bool test_qualified_empty() { |
301 | { |
302 | absl::string_with_clear v; |
303 | std::empty(v); |
304 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
305 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
306 | |
307 | absl::empty(v); |
308 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
309 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
310 | |
311 | test::empty(v); |
312 | // no-warning |
313 | |
314 | test_no_args::empty(); |
315 | // no-warning |
316 | } |
317 | |
318 | { |
319 | absl::string s; |
320 | std::empty(s); |
321 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
322 | } |
323 | |
324 | { |
325 | std::empty(0); |
326 | // no-warning |
327 | absl::empty(nullptr); |
328 | // no-warning |
329 | } |
330 | |
331 | { |
332 | absl::string_with_clear s; |
333 | return std::empty(s); |
334 | // no-warning |
335 | return absl::empty(s); |
336 | // no-warning |
337 | } |
338 | |
339 | { |
340 | absl::string s; |
341 | return std::empty(s); |
342 | // no-warning |
343 | } |
344 | |
345 | { |
346 | return std::empty(0); |
347 | // no-warning |
348 | return absl::empty(nullptr); |
349 | // no-warning |
350 | } |
351 | } |
352 | |
353 | bool test_unqualified_empty() { |
354 | { |
355 | std::vector<int> v; |
356 | empty(v); |
357 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
358 | } |
359 | |
360 | { |
361 | std::vector_with_void_empty<int> v; |
362 | empty(v); |
363 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
364 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
365 | } |
366 | |
367 | { |
368 | std::vector_with_clear<int> v; |
369 | empty(v); |
370 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
371 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
372 | } |
373 | |
374 | { |
375 | std::vector_with_int_empty<int> v; |
376 | empty(v); |
377 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
378 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
379 | } |
380 | |
381 | { |
382 | std::vector_with_clear_args<int> v; |
383 | empty(v); |
384 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
385 | } |
386 | |
387 | { |
388 | std::vector_with_clear_variable<int> v; |
389 | empty(v); |
390 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
391 | } |
392 | |
393 | { |
394 | absl::string s; |
395 | empty(s); |
396 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty' [bugprone-standalone-empty] |
397 | } |
398 | |
399 | { |
400 | absl::string_with_void_empty s; |
401 | empty(s); |
402 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
403 | // CHECK-FIXES: {{^ }} s.clear();{{$}} |
404 | } |
405 | |
406 | { |
407 | absl::string_with_clear s; |
408 | empty(s); |
409 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
410 | // CHECK-FIXES: {{^ }} s.clear();{{$}} |
411 | } |
412 | |
413 | { |
414 | absl::string_with_int_empty s; |
415 | empty(s); |
416 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
417 | // CHECK-FIXES: {{^ }} s.clear();{{$}} |
418 | } |
419 | |
420 | { |
421 | absl::string_with_clear_args s; |
422 | empty(s); |
423 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty' [bugprone-standalone-empty] |
424 | } |
425 | |
426 | { |
427 | absl::string_with_clear_variable s; |
428 | empty(s); |
429 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty' [bugprone-standalone-empty] |
430 | } |
431 | |
432 | { |
433 | std::vector<int> v; |
434 | using std::empty; |
435 | empty(v); |
436 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
437 | } |
438 | |
439 | { |
440 | std::vector_with_clear<int> v; |
441 | using std::empty; |
442 | empty(v); |
443 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
444 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
445 | } |
446 | |
447 | { |
448 | absl::string s; |
449 | using absl::empty; |
450 | empty(s); |
451 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty' [bugprone-standalone-empty] |
452 | } |
453 | |
454 | { |
455 | absl::string_with_clear s; |
456 | using absl::empty; |
457 | empty(s); |
458 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
459 | // CHECK-FIXES: {{^ }} s.clear();{{$}} |
460 | } |
461 | |
462 | { |
463 | std::vector<int> v; |
464 | return empty(v); |
465 | // no-warning |
466 | } |
467 | |
468 | { |
469 | std::vector_with_void_empty<int> v; |
470 | return empty(v); |
471 | // no-warning |
472 | } |
473 | |
474 | { |
475 | std::vector_with_clear<int> v; |
476 | return empty(v); |
477 | // no-warning |
478 | } |
479 | |
480 | { |
481 | std::vector_with_int_empty<int> v; |
482 | return empty(v); |
483 | // no-warning |
484 | } |
485 | |
486 | { |
487 | std::vector_with_clear_args<int> v; |
488 | return empty(v); |
489 | // no-warning |
490 | } |
491 | |
492 | { |
493 | std::vector_with_clear_variable<int> v; |
494 | return empty(v); |
495 | // no-warning |
496 | } |
497 | |
498 | { |
499 | absl::string s; |
500 | return empty(s); |
501 | // no-warning |
502 | } |
503 | |
504 | { |
505 | absl::string_with_void_empty s; |
506 | return empty(s); |
507 | // no-warning |
508 | } |
509 | |
510 | { |
511 | absl::string_with_clear s; |
512 | return empty(s); |
513 | // no-warning |
514 | } |
515 | |
516 | { |
517 | absl::string_with_int_empty s; |
518 | return empty(s); |
519 | // no-warning |
520 | } |
521 | |
522 | { |
523 | absl::string_with_clear_args s; |
524 | return empty(s); |
525 | // no-warning |
526 | } |
527 | |
528 | { |
529 | absl::string_with_clear_variable s; |
530 | return empty(s); |
531 | // no-warning |
532 | } |
533 | |
534 | { |
535 | std::vector<int> v; |
536 | using std::empty; |
537 | return empty(v); |
538 | // no-warning |
539 | } |
540 | |
541 | { |
542 | std::vector_with_clear<int> v; |
543 | using std::empty; |
544 | return empty(v); |
545 | // no-warning |
546 | } |
547 | |
548 | { |
549 | absl::string s; |
550 | using absl::empty; |
551 | return empty(s); |
552 | // no-warning |
553 | } |
554 | |
555 | { |
556 | absl::string_with_clear s; |
557 | using absl::empty; |
558 | return empty(s); |
559 | // no-warning |
560 | } |
561 | } |
562 | |
563 | void test_empty_method_expressions() { |
564 | std::vector<int> v; |
565 | bool EmptyReturn(v.empty()); |
566 | // no-warning |
567 | |
568 | (void)v.empty(); |
569 | // no-warning |
570 | |
571 | // Don't warn in the if condition. |
572 | if (v.empty()) v.empty(); |
573 | // CHECK-MESSAGES: :[[#@LINE-1]]:18: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
574 | |
575 | // Don't warn in the for condition. |
576 | for(v.empty();v.empty();v.empty()) v.empty(); |
577 | // CHECK-MESSAGES: :[[#@LINE-1]]:7: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
578 | // CHECK-MESSAGES: :[[#@LINE-2]]:27: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
579 | // CHECK-MESSAGES: :[[#@LINE-3]]:38: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
580 | |
581 | // Don't warn in the while condition. |
582 | while(v.empty()) v.empty(); |
583 | // CHECK-MESSAGES: :[[#@LINE-1]]:20: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
584 | |
585 | // Don't warn in the do-while condition. |
586 | do v.empty(); while(v.empty()); |
587 | // CHECK-MESSAGES: :[[#@LINE-1]]:6: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
588 | |
589 | // Don't warn in the switch expression. |
590 | switch(v.empty()) { |
591 | // no-warning |
592 | case true: |
593 | v.empty(); |
594 | // CHECK-MESSAGES: :[[#@LINE-1]]:7: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
595 | } |
596 | |
597 | // Don't warn in the return expression, which is the last statement. |
598 | bool StmtExprReturn = ({v.empty(); v.empty();}); |
599 | // CHECK-MESSAGES: :[[#@LINE-1]]:27: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
600 | } |
601 | |
602 | void test_empty_expressions() { |
603 | absl::string s; |
604 | bool test(std::empty(s)); |
605 | // no-warning |
606 | |
607 | (void)std::empty(s); |
608 | // no-warning |
609 | |
610 | if (std::empty(s)) std::empty(s); |
611 | // CHECK-MESSAGES: :[[#@LINE-1]]:22: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
612 | |
613 | for(std::empty(s);std::empty(s);std::empty(s)) std::empty(s); |
614 | // CHECK-MESSAGES: :[[#@LINE-1]]:7: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
615 | // CHECK-MESSAGES: :[[#@LINE-2]]:35: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
616 | // CHECK-MESSAGES: :[[#@LINE-3]]:50: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
617 | |
618 | while(std::empty(s)) std::empty(s); |
619 | // CHECK-MESSAGES: :[[#@LINE-1]]:24: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
620 | |
621 | do std::empty(s); while(std::empty(s)); |
622 | // CHECK-MESSAGES: :[[#@LINE-1]]:6: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
623 | |
624 | switch(std::empty(s)) { |
625 | // no-warning |
626 | case true: |
627 | std::empty(s); |
628 | // CHECK-MESSAGES: :[[#@LINE-1]]:7: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
629 | } |
630 | |
631 | bool StmtExprReturn = ({std::empty(s); std::empty(s);}); |
632 | // CHECK-MESSAGES: :[[#@LINE-1]]:27: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
633 | } |
634 | |
635 | bool test_clear_in_base_class() { |
636 | { |
637 | base::vector<int> v; |
638 | v.empty(); |
639 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
640 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
641 | } |
642 | |
643 | { |
644 | base::vector_non_dependent<int> v; |
645 | v.empty(); |
646 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
647 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
648 | } |
649 | |
650 | { |
651 | base::vector_clear_with_args<int> v; |
652 | v.empty(); |
653 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
654 | } |
655 | |
656 | { |
657 | base::vector_clear_variable<int> v; |
658 | v.empty(); |
659 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
660 | } |
661 | |
662 | { |
663 | base::vector<int> v; |
664 | empty(v); |
665 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'base::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
666 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
667 | } |
668 | |
669 | { |
670 | base::vector_non_dependent<int> v; |
671 | empty(v); |
672 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'base::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
673 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
674 | } |
675 | |
676 | { |
677 | base::vector_clear_with_args<int> v; |
678 | empty(v); |
679 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'base::empty' [bugprone-standalone-empty] |
680 | } |
681 | |
682 | { |
683 | base::vector_clear_variable<int> v; |
684 | empty(v); |
685 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'base::empty' [bugprone-standalone-empty] |
686 | } |
687 | |
688 | { |
689 | base::vector<int> v; |
690 | return v.empty(); |
691 | // no-warning |
692 | } |
693 | |
694 | { |
695 | base::vector_non_dependent<int> v; |
696 | return v.empty(); |
697 | // no-warning |
698 | } |
699 | |
700 | { |
701 | base::vector_clear_with_args<int> v; |
702 | return v.empty(); |
703 | // no-warning |
704 | } |
705 | |
706 | { |
707 | base::vector_clear_variable<int> v; |
708 | return v.empty(); |
709 | // no-warning |
710 | } |
711 | |
712 | { |
713 | base::vector<int> v; |
714 | return empty(v); |
715 | // no-warning |
716 | } |
717 | |
718 | { |
719 | base::vector_non_dependent<int> v; |
720 | return empty(v); |
721 | // no-warning |
722 | } |
723 | |
724 | { |
725 | base::vector_clear_with_args<int> v; |
726 | return empty(v); |
727 | // no-warning |
728 | } |
729 | |
730 | { |
731 | base::vector_clear_variable<int> v; |
732 | return empty(v); |
733 | // no-warning |
734 | } |
735 | } |
736 | |
737 | bool test_clear_with_qualifiers() { |
738 | { |
739 | qualifiers::vector_with_const_clear<int> v; |
740 | v.empty(); |
741 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
742 | } |
743 | |
744 | { |
745 | const qualifiers::vector_with_const_clear<int> v; |
746 | v.empty(); |
747 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
748 | } |
749 | |
750 | { |
751 | const qualifiers::vector_with_const_empty<int> v; |
752 | v.empty(); |
753 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
754 | } |
755 | |
756 | { |
757 | qualifiers::vector_with_const_clear<int> v; |
758 | empty(v); |
759 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'qualifiers::empty' [bugprone-standalone-empty] |
760 | } |
761 | |
762 | { |
763 | const qualifiers::vector_with_const_clear<int> v; |
764 | empty(v); |
765 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'qualifiers::empty' [bugprone-standalone-empty] |
766 | } |
767 | |
768 | { |
769 | const std::vector_with_clear<int> v; |
770 | empty(v); |
771 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
772 | } |
773 | |
774 | { |
775 | qualifiers::vector_with_volatile_clear<int> v; |
776 | v.empty(); |
777 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
778 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
779 | } |
780 | |
781 | { |
782 | volatile qualifiers::vector_with_volatile_clear<int> v; |
783 | v.empty(); |
784 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
785 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
786 | } |
787 | |
788 | { |
789 | volatile qualifiers::vector_with_volatile_empty<int> v; |
790 | v.empty(); |
791 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
792 | } |
793 | |
794 | { |
795 | qualifiers::vector_with_volatile_clear<int> v; |
796 | empty(v); |
797 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'qualifiers::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
798 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
799 | } |
800 | |
801 | { |
802 | volatile qualifiers::vector_with_volatile_clear<int> v; |
803 | empty(v); |
804 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'qualifiers::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
805 | // CHECK-FIXES: {{^ }} v.clear();{{$}} |
806 | } |
807 | |
808 | { |
809 | volatile std::vector_with_clear<int> v; |
810 | empty(v); |
811 | // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
812 | } |
813 | |
814 | { |
815 | qualifiers::vector_with_const_clear<int> v; |
816 | return v.empty(); |
817 | // no-warning |
818 | } |
819 | |
820 | { |
821 | const qualifiers::vector_with_const_clear<int> v; |
822 | return v.empty(); |
823 | // no-warning |
824 | } |
825 | |
826 | { |
827 | const qualifiers::vector_with_const_empty<int> v; |
828 | return v.empty(); |
829 | // no-warning |
830 | } |
831 | |
832 | { |
833 | qualifiers::vector_with_const_clear<int> v; |
834 | return empty(v); |
835 | // no-warning |
836 | } |
837 | |
838 | { |
839 | const qualifiers::vector_with_const_clear<int> v; |
840 | return empty(v); |
841 | // no-warning |
842 | } |
843 | |
844 | { |
845 | const std::vector_with_clear<int> v; |
846 | return empty(v); |
847 | // no-warning |
848 | } |
849 | |
850 | { |
851 | qualifiers::vector_with_volatile_clear<int> v; |
852 | return v.empty(); |
853 | // no-warning |
854 | } |
855 | |
856 | { |
857 | volatile qualifiers::vector_with_volatile_clear<int> v; |
858 | return v.empty(); |
859 | // no-warning |
860 | } |
861 | |
862 | { |
863 | volatile qualifiers::vector_with_volatile_empty<int> v; |
864 | return v.empty(); |
865 | // no-warning |
866 | } |
867 | |
868 | { |
869 | qualifiers::vector_with_volatile_clear<int> v; |
870 | return empty(v); |
871 | // no-warning |
872 | } |
873 | |
874 | { |
875 | volatile qualifiers::vector_with_volatile_clear<int> v; |
876 | return empty(v); |
877 | // no-warning |
878 | } |
879 | |
880 | { |
881 | volatile std::vector_with_clear<int> v; |
882 | return empty(v); |
883 | // no-warning |
884 | } |
885 | } |
886 | |
887 | namespace user_lib { |
888 | template <typename T> |
889 | struct vector { |
890 | bool empty(); |
891 | bool test_empty_inside_impl() { |
892 | empty(); |
893 | // no-warning |
894 | return empty(); |
895 | // no-warning |
896 | } |
897 | }; |
898 | } // namespace user_lib |
899 | |
900 | bool test_template_empty_outside_impl() { |
901 | user_lib::vector<int> v; |
902 | v.empty(); |
903 | // CHECK-MESSAGES: :[[#@LINE-1]]:3: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
904 | return v.empty(); |
905 | // no-warning |
906 | } |
907 | |