| // RUN: %check_clang_tidy %s bugprone-standalone-empty %t |
| |
| namespace std { |
| template <typename T> |
| struct vector { |
| bool empty(); |
| }; |
| |
| template <typename T> |
| struct vector_with_clear { |
| bool empty(); |
| void clear(); |
| }; |
| |
| template <typename T> |
| struct vector_with_void_empty { |
| void empty(); |
| void clear(); |
| }; |
| |
| template <typename T> |
| struct vector_with_int_empty { |
| int empty(); |
| void clear(); |
| }; |
| |
| template <typename T> |
| struct vector_with_clear_args { |
| bool empty(); |
| void clear(int i); |
| }; |
| |
| template <typename T> |
| struct vector_with_clear_variable { |
| bool empty(); |
| int clear; |
| }; |
| |
| template <typename T> |
| bool empty(T &&); |
| |
| } // namespace std |
| |
| namespace absl { |
| struct string { |
| bool empty(); |
| }; |
| |
| struct string_with_clear { |
| bool empty(); |
| void clear(); |
| }; |
| |
| struct string_with_void_empty { |
| void empty(); |
| void clear(); |
| }; |
| |
| struct string_with_int_empty { |
| int empty(); |
| void clear(); |
| }; |
| |
| struct string_with_clear_args { |
| bool empty(); |
| void clear(int i); |
| }; |
| |
| struct string_with_clear_variable { |
| bool empty(); |
| int clear; |
| }; |
| |
| template <class T> |
| bool empty(T &&); |
| } // namespace absl |
| |
| namespace test { |
| template <class T> |
| void empty(T &&); |
| } // namespace test |
| |
| namespace test_no_args { |
| bool empty(); |
| } // namespace test_no_args |
| |
| namespace base { |
| template <typename T> |
| struct base_vector { |
| void clear(); |
| }; |
| |
| template <typename T> |
| struct base_vector_clear_with_args { |
| void clear(int i); |
| }; |
| |
| template <typename T> |
| struct base_vector_clear_variable { |
| int clear; |
| }; |
| |
| struct base_vector_non_dependent { |
| void clear(); |
| }; |
| |
| template <typename T> |
| struct vector : base_vector<T> { |
| bool empty(); |
| }; |
| |
| template <typename T> |
| struct vector_clear_with_args : base_vector_clear_with_args<T> { |
| bool empty(); |
| }; |
| |
| template <typename T> |
| struct vector_clear_variable : base_vector_clear_variable<T> { |
| bool empty(); |
| }; |
| |
| template <typename T> |
| struct vector_non_dependent : base_vector_non_dependent { |
| bool empty(); |
| }; |
| |
| template <typename T> |
| bool empty(T &&); |
| |
| } // namespace base |
| |
| namespace qualifiers { |
| template <typename T> |
| struct vector_with_const_clear { |
| bool empty() const; |
| void clear() const; |
| }; |
| |
| template <typename T> |
| struct vector_with_const_empty { |
| bool empty() const; |
| void clear(); |
| }; |
| |
| template <typename T> |
| struct vector_with_volatile_clear { |
| bool empty() volatile; |
| void clear() volatile; |
| }; |
| |
| template <typename T> |
| struct vector_with_volatile_empty { |
| bool empty() volatile; |
| void clear(); |
| }; |
| |
| template <typename T> |
| bool empty(T &&); |
| } // namespace qualifiers |
| |
| |
| bool test_member_empty() { |
| { |
| std::vector<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| std::vector_with_void_empty<int> v; |
| v.empty(); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_clear<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| std::vector_with_int_empty<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| std::vector_with_clear_args<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| std::vector_with_clear_variable<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| absl::string s; |
| s.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| absl::string_with_void_empty s; |
| s.empty(); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear s; |
| s.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} s.clear();{{$}} |
| } |
| |
| { |
| absl::string_with_int_empty s; |
| s.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} s.clear();{{$}} |
| } |
| |
| { |
| absl::string_with_clear_args s; |
| s.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| absl::string_with_clear_variable s; |
| s.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| std::vector<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_clear<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_int_empty<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_clear_args<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_clear_variable<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| absl::string s; |
| return s.empty(); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear s; |
| return s.empty(); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_int_empty s; |
| return s.empty(); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear_args s; |
| return s.empty(); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear_variable s; |
| return s.empty(); |
| // no-warning |
| } |
| } |
| |
| bool test_qualified_empty() { |
| { |
| absl::string_with_clear v; |
| std::empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| |
| absl::empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| |
| test::empty(v); |
| // no-warning |
| |
| test_no_args::empty(); |
| // no-warning |
| } |
| |
| { |
| absl::string s; |
| std::empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| std::empty(0); |
| // no-warning |
| absl::empty(nullptr); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear s; |
| return std::empty(s); |
| // no-warning |
| return absl::empty(s); |
| // no-warning |
| } |
| |
| { |
| absl::string s; |
| return std::empty(s); |
| // no-warning |
| } |
| |
| { |
| return std::empty(0); |
| // no-warning |
| return absl::empty(nullptr); |
| // no-warning |
| } |
| } |
| |
| bool test_unqualified_empty() { |
| { |
| std::vector<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| std::vector_with_void_empty<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| std::vector_with_clear<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| std::vector_with_int_empty<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| std::vector_with_clear_args<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| std::vector_with_clear_variable<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| absl::string s; |
| empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| absl::string_with_void_empty s; |
| empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} s.clear();{{$}} |
| } |
| |
| { |
| absl::string_with_clear s; |
| empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} s.clear();{{$}} |
| } |
| |
| { |
| absl::string_with_int_empty s; |
| empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} s.clear();{{$}} |
| } |
| |
| { |
| absl::string_with_clear_args s; |
| empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| absl::string_with_clear_variable s; |
| empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| std::vector<int> v; |
| using std::empty; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| std::vector_with_clear<int> v; |
| using std::empty; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| absl::string s; |
| using absl::empty; |
| empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| absl::string_with_clear s; |
| using absl::empty; |
| empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'absl::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} s.clear();{{$}} |
| } |
| |
| { |
| std::vector<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_void_empty<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_clear<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_int_empty<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_clear_args<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_clear_variable<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| absl::string s; |
| return empty(s); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_void_empty s; |
| return empty(s); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear s; |
| return empty(s); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_int_empty s; |
| return empty(s); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear_args s; |
| return empty(s); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear_variable s; |
| return empty(s); |
| // no-warning |
| } |
| |
| { |
| std::vector<int> v; |
| using std::empty; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| std::vector_with_clear<int> v; |
| using std::empty; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| absl::string s; |
| using absl::empty; |
| return empty(s); |
| // no-warning |
| } |
| |
| { |
| absl::string_with_clear s; |
| using absl::empty; |
| return empty(s); |
| // no-warning |
| } |
| } |
| |
| void test_empty_method_expressions() { |
| std::vector<int> v; |
| bool EmptyReturn(v.empty()); |
| // no-warning |
| |
| (void)v.empty(); |
| // no-warning |
| |
| // Don't warn in the if condition. |
| if (v.empty()) v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:18: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| |
| // Don't warn in the for condition. |
| for(v.empty();v.empty();v.empty()) v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:7: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| // CHECK-MESSAGES: :[[#@LINE-2]]:27: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| // CHECK-MESSAGES: :[[#@LINE-3]]:38: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| |
| // Don't warn in the while condition. |
| while(v.empty()) v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:20: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| |
| // Don't warn in the do-while condition. |
| do v.empty(); while(v.empty()); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:6: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| |
| // Don't warn in the switch expression. |
| switch(v.empty()) { |
| // no-warning |
| case true: |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:7: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| // Don't warn in the return expression, which is the last statement. |
| bool StmtExprReturn = ({v.empty(); v.empty();}); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:27: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| void test_empty_expressions() { |
| absl::string s; |
| bool test(std::empty(s)); |
| // no-warning |
| |
| (void)std::empty(s); |
| // no-warning |
| |
| if (std::empty(s)) std::empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:22: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| |
| for(std::empty(s);std::empty(s);std::empty(s)) std::empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:7: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| // CHECK-MESSAGES: :[[#@LINE-2]]:35: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| // CHECK-MESSAGES: :[[#@LINE-3]]:50: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| |
| while(std::empty(s)) std::empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:24: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| |
| do std::empty(s); while(std::empty(s)); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:6: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| |
| switch(std::empty(s)) { |
| // no-warning |
| case true: |
| std::empty(s); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:7: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| bool StmtExprReturn = ({std::empty(s); std::empty(s);}); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:27: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| bool test_clear_in_base_class() { |
| { |
| base::vector<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| base::vector_non_dependent<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| base::vector_clear_with_args<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| base::vector_clear_variable<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| base::vector<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'base::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| base::vector_non_dependent<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'base::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| base::vector_clear_with_args<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'base::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| base::vector_clear_variable<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'base::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| base::vector<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| base::vector_non_dependent<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| base::vector_clear_with_args<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| base::vector_clear_variable<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| base::vector<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| base::vector_non_dependent<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| base::vector_clear_with_args<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| base::vector_clear_variable<int> v; |
| return empty(v); |
| // no-warning |
| } |
| } |
| |
| bool test_clear_with_qualifiers() { |
| { |
| qualifiers::vector_with_const_clear<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| const qualifiers::vector_with_const_clear<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| const qualifiers::vector_with_const_empty<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| qualifiers::vector_with_const_clear<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'qualifiers::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| const qualifiers::vector_with_const_clear<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'qualifiers::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| const std::vector_with_clear<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| qualifiers::vector_with_volatile_clear<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| volatile qualifiers::vector_with_volatile_clear<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| volatile qualifiers::vector_with_volatile_empty<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| } |
| |
| { |
| qualifiers::vector_with_volatile_clear<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'qualifiers::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| volatile qualifiers::vector_with_volatile_clear<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'qualifiers::empty'; did you mean 'clear()'? [bugprone-standalone-empty] |
| // CHECK-FIXES: {{^ }} v.clear();{{$}} |
| } |
| |
| { |
| volatile std::vector_with_clear<int> v; |
| empty(v); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:5: warning: ignoring the result of 'std::empty' [bugprone-standalone-empty] |
| } |
| |
| { |
| qualifiers::vector_with_const_clear<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| const qualifiers::vector_with_const_clear<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| const qualifiers::vector_with_const_empty<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| qualifiers::vector_with_const_clear<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| const qualifiers::vector_with_const_clear<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| const std::vector_with_clear<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| qualifiers::vector_with_volatile_clear<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| volatile qualifiers::vector_with_volatile_clear<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| volatile qualifiers::vector_with_volatile_empty<int> v; |
| return v.empty(); |
| // no-warning |
| } |
| |
| { |
| qualifiers::vector_with_volatile_clear<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| volatile qualifiers::vector_with_volatile_clear<int> v; |
| return empty(v); |
| // no-warning |
| } |
| |
| { |
| volatile std::vector_with_clear<int> v; |
| return empty(v); |
| // no-warning |
| } |
| } |
| |
| namespace user_lib { |
| template <typename T> |
| struct vector { |
| bool empty(); |
| bool test_empty_inside_impl() { |
| empty(); |
| // no-warning |
| return empty(); |
| // no-warning |
| } |
| }; |
| } // namespace user_lib |
| |
| bool test_template_empty_outside_impl() { |
| user_lib::vector<int> v; |
| v.empty(); |
| // CHECK-MESSAGES: :[[#@LINE-1]]:3: warning: ignoring the result of 'empty()' [bugprone-standalone-empty] |
| return v.empty(); |
| // no-warning |
| } |