maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang-tools-extra/test/clang-tidy/readability-container-size-...

440 lines
14 KiB
C++
Raw Normal View History

Add %check_clang_tidy and %clang_tidy_diff. With this, site specific lit configs can inject parameters into the test scripts if they need site specific parameters. Next up: enable check_clang_tidy to take a resource dir to enable non-standard locations for builtin includes. llvm-svn: 251010
2015-10-22 19:31:44 +08:00
// RUN: %check_clang_tidy %s readability-container-size-empty %t
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
namespace std {
template <typename T> struct vector {
[clang-tidy] Make readability-container-size-empty work with inline namespaces. Fix PR25812. llvm-svn: 260217
2016-02-09 18:20:48 +08:00
vector();
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
bool operator==(const vector<T>& other) const;
bool operator!=(const vector<T>& other) const;
[clang-tidy] Fix a false positive case in ContainerSizeEmpty check. llvm-svn: 256504
2015-12-29 01:20:33 +08:00
unsigned long size() const;
bool empty() const;
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
};
[clang-tidy] Make readability-container-size-empty work with inline namespaces. Fix PR25812. llvm-svn: 260217
2016-02-09 18:20:48 +08:00
[clang-tidy] readability-container-size-empty fixes Summary: This patch fixes PR27410 and adds std::basic_string support. Reviewers: Eugene.Zelenko, hokein Subscribers: cfe-commits, o.gyorgy Differential Revision: http://reviews.llvm.org/D19262 llvm-svn: 266734
2016-04-19 21:29:05 +08:00
template <typename T> struct basic_string {
basic_string();
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
bool operator==(const basic_string<T>& other) const;
bool operator!=(const basic_string<T>& other) const;
bool operator==(const char *) const;
bool operator!=(const char *) const;
basic_string<T> operator+(const basic_string<T>& other) const;
[clang-tidy] readability-container-size-empty fixes Summary: This patch fixes PR27410 and adds std::basic_string support. Reviewers: Eugene.Zelenko, hokein Subscribers: cfe-commits, o.gyorgy Differential Revision: http://reviews.llvm.org/D19262 llvm-svn: 266734
2016-04-19 21:29:05 +08:00
unsigned long size() const;
bool empty() const;
};
typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;
[clang-tidy] Make readability-container-size-empty work with inline namespaces. Fix PR25812. llvm-svn: 260217
2016-02-09 18:20:48 +08:00
inline namespace __v2 {
template <typename T> struct set {
set();
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
bool operator==(const set<T>& other) const;
bool operator!=(const set<T>& other) const;
[clang-tidy] Make readability-container-size-empty work with inline namespaces. Fix PR25812. llvm-svn: 260217
2016-02-09 18:20:48 +08:00
unsigned long size() const;
bool empty() const;
};
}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
template <typename T>
class TemplatedContainer {
public:
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
bool operator==(const TemplatedContainer<T>& other) const;
bool operator!=(const TemplatedContainer<T>& other) const;
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
int size() const;
bool empty() const;
};
template <typename T>
class PrivateEmpty {
public:
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
bool operator==(const PrivateEmpty<T>& other) const;
bool operator!=(const PrivateEmpty<T>& other) const;
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
int size() const;
private:
bool empty() const;
};
struct BoolSize {
bool size() const;
bool empty() const;
};
struct EnumSize {
enum E { one };
enum E size() const;
bool empty() const;
};
class Container {
public:
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
bool operator==(const Container& other) const;
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
int size() const;
bool empty() const;
};
class Derived : public Container {
};
[clang-tidy] Ignore `size() == 0` in the container implementation. llvm-svn: 290289
2016-12-22 07:44:23 +08:00
class Container2 {
public:
int size() const;
bool empty() const { return size() == 0; }
};
class Container3 {
public:
int size() const;
bool empty() const;
};
bool Container3::empty() const { return this->size() == 0; }
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
class Container4 {
public:
bool operator==(const Container4& rhs) const;
int size() const;
bool empty() const { return *this == Container4(); }
};
std::string s_func() {
return std::string();
}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
int main() {
[clang-tidy] Make readability-container-size-empty work with inline namespaces. Fix PR25812. llvm-svn: 260217
2016-02-09 18:20:48 +08:00
std::set<int> intSet;
[clang-tidy] readability-container-size-empty fixes Summary: This patch fixes PR27410 and adds std::basic_string support. Reviewers: Eugene.Zelenko, hokein Subscribers: cfe-commits, o.gyorgy Differential Revision: http://reviews.llvm.org/D19262 llvm-svn: 266734
2016-04-19 21:29:05 +08:00
std::string str;
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
std::string str2;
[clang-tidy] readability-container-size-empty fixes Summary: This patch fixes PR27410 and adds std::basic_string support. Reviewers: Eugene.Zelenko, hokein Subscribers: cfe-commits, o.gyorgy Differential Revision: http://reviews.llvm.org/D19262 llvm-svn: 266734
2016-04-19 21:29:05 +08:00
std::wstring wstr;
str.size() + 0;
str.size() - 0;
0 + str.size();
0 - str.size();
[clang-tidy] Make readability-container-size-empty work with inline namespaces. Fix PR25812. llvm-svn: 260217
2016-02-09 18:20:48 +08:00
if (intSet.size() == 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty]
// CHECK-FIXES: {{^ }}if (intSet.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
// CHECK-MESSAGES: :32:8: note: method 'set<int>'::empty() defined here
if (intSet == std::set<int>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness
// CHECK-FIXES: {{^ }}if (intSet.empty()){{$}}
// CHECK-MESSAGES: :32:8: note: method 'set<int>'::empty() defined here
if (s_func() == "")
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (s_func().empty()){{$}}
[clang-tidy] readability-container-size-empty fixes Summary: This patch fixes PR27410 and adds std::basic_string support. Reviewers: Eugene.Zelenko, hokein Subscribers: cfe-commits, o.gyorgy Differential Revision: http://reviews.llvm.org/D19262 llvm-svn: 266734
2016-04-19 21:29:05 +08:00
if (str.size() == 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (str.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if ((str + str2).size() == 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if ((str + str2).empty()){{$}}
if (str == "")
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (str.empty()){{$}}
if (str + str2 == "")
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if ((str + str2).empty()){{$}}
[clang-tidy] readability-container-size-empty fixes Summary: This patch fixes PR27410 and adds std::basic_string support. Reviewers: Eugene.Zelenko, hokein Subscribers: cfe-commits, o.gyorgy Differential Revision: http://reviews.llvm.org/D19262 llvm-svn: 266734
2016-04-19 21:29:05 +08:00
if (wstr.size() == 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (wstr.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (wstr == "")
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (wstr.empty()){{$}}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
std::vector<int> vect;
if (vect.size() == 0)
;
[clang-tidy] Make readability-container-size-empty work with inline namespaces. Fix PR25812. llvm-svn: 260217
2016-02-09 18:20:48 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (vect.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (vect == std::vector<int>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (vect.empty()){{$}}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
if (vect.size() != 0)
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (vect != std::vector<int>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
if (0 == vect.size())
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (vect.empty()){{$}}
if (0 != vect.size())
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (std::vector<int>() == vect)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (vect.empty()){{$}}
if (std::vector<int>() != vect)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
if (vect.size() > 0)
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
if (0 < vect.size())
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
if (vect.size() < 1)
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (vect.empty()){{$}}
if (1 > vect.size())
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (vect.empty()){{$}}
if (vect.size() >= 1)
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
if (1 <= vect.size())
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
Fix a false positive case in ContainerSizeEmpty check (PR25893). llvm-svn: 256142
2015-12-21 17:43:52 +08:00
if (vect.size() > 1) // no warning
;
if (1 < vect.size()) // no warning
;
[clang-tidy] Fix a false positive case in ContainerSizeEmpty check. llvm-svn: 256504
2015-12-29 01:20:33 +08:00
if (vect.size() <= 1) // no warning
;
if (1 >= vect.size()) // no warning
;
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
if (!vect.size())
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:8: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (vect.empty()){{$}}
if (vect.size())
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!vect.empty()){{$}}
if (vect.empty())
;
const std::vector<int> vect2;
if (vect2.size() != 0)
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!vect2.empty()){{$}}
std::vector<int> *vect3 = new std::vector<int>();
if (vect3->size() == 0)
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (vect3->empty()){{$}}
[clang-tidy] readability-container-size-empty fix for (*x).size() llvm-svn: 298316
2017-03-21 06:15:27 +08:00
if ((*vect3).size() == 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if ((*vect3).empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if ((*vect3) == std::vector<int>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (vect3->empty()){{$}}
if (*vect3 == std::vector<int>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (vect3->empty()){{$}}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
delete vect3;
const std::vector<int> &vect4 = vect2;
if (vect4.size() == 0)
;
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (vect4.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (vect4 == std::vector<int>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (vect4.empty()){{$}}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
TemplatedContainer<void> templated_container;
if (templated_container.size() == 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (templated_container == TemplatedContainer<void>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
if (templated_container.size() != 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (templated_container != TemplatedContainer<void>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
if (0 == templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (TemplatedContainer<void>() == templated_container)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
if (0 != templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (TemplatedContainer<void>() != templated_container)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
if (templated_container.size() > 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
if (0 < templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
if (templated_container.size() < 1)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}}
if (1 > templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:11: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}}
if (templated_container.size() >= 1)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
if (1 <= templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:12: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
if (templated_container.size() > 1) // no warning
;
if (1 < templated_container.size()) // no warning
;
if (templated_container.size() <= 1) // no warning
;
if (1 >= templated_container.size()) // no warning
;
if (!templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:8: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}}
if (templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
if (templated_container.empty())
;
// No warnings expected.
PrivateEmpty<void> private_empty;
if (private_empty.size() == 0)
;
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (private_empty == PrivateEmpty<void>())
;
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
if (private_empty.size() != 0)
;
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (private_empty != PrivateEmpty<void>())
;
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
if (0 == private_empty.size())
;
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (PrivateEmpty<void>() == private_empty)
;
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
if (0 != private_empty.size())
;
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (PrivateEmpty<void>() != private_empty)
;
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
if (private_empty.size() > 0)
;
if (0 < private_empty.size())
;
if (private_empty.size() < 1)
;
if (1 > private_empty.size())
;
if (private_empty.size() >= 1)
;
if (1 <= private_empty.size())
;
if (private_empty.size() > 1)
;
if (1 < private_empty.size())
;
if (private_empty.size() <= 1)
;
if (1 >= private_empty.size())
;
if (!private_empty.size())
;
if (private_empty.size())
;
// Types with weird size() return type.
BoolSize bs;
if (bs.size() == 0)
;
EnumSize es;
if (es.size() == 0)
;
Derived derived;
if (derived.size() == 0)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (derived.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (derived == Derived())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (derived.empty()){{$}}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
}
#define CHECKSIZE(x) if (x.size())
// CHECK-FIXES: #define CHECKSIZE(x) if (x.size())
template <typename T> void f() {
std::vector<T> v;
if (v.size())
;
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty]
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES: {{^ }}if (!v.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (v == std::vector<T>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of comparing to an empty object [readability-container-size-empty]
// CHECK-FIXES: {{^ }}if (v.empty()){{$}}
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-FIXES-NEXT: ;
CHECKSIZE(v);
[clang-tidy] Fix message style (capitalization, trailing period). llvm-svn: 252471
2015-11-09 23:53:28 +08:00
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
// CHECK-MESSAGES: CHECKSIZE(v);
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
TemplatedContainer<T> templated_container;
if (templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
Extend readability-container-size-empty to add comparisons to empty-state objects. Patch by Josh Zimmerman. llvm-svn: 301185
2017-04-24 22:57:09 +08:00
if (templated_container != TemplatedContainer<T>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
[clang-tidy] Extend readability-container-size-empty to arbitrary class with size() and empty() This patch extends readability-container-size-empty check allowing it to produce warnings not only for STL containers, but also for containers, which provide two functions matching following signatures: * `size_type size() const;` * `bool empty() const;` Where `size_type` can be any kind of integer type. This functionality was proposed in https://llvm.org/bugs/show_bug.cgi?id=26823 by Eugene Zelenko. Approval: alexfh Reviewers: alexfh, aaron.ballman, Eugene.Zelenko Subscribers: etienneb, Prazek, hokein, xazax.hun, cfe-commits Differential Revision: https://reviews.llvm.org/D24349 llvm-svn: 281307
2016-09-13 16:58:11 +08:00
// CHECK-FIXES-NEXT: ;
CHECKSIZE(templated_container);
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used
// CHECK-MESSAGES: CHECKSIZE(templated_container);
clang-tidy: 'size' call that could be replaced with 'empty' on STL containers We are porting some of the checkers at a company we developed to the Clang Tidy infrastructure. We would like to open source the checkers that may be useful for the community as well. This patch is the first checker that is being ported to Clang Tidy. We also added fix-it hints, and applied them to LLVM: http://reviews.llvm.org/D6924 The code compiled and the unit tests are passed after the fixits was applied. The documentation of the checker: /// The emptiness of a container should be checked using the empty method /// instead of the size method. It is not guaranteed that size is a /// constant-time function, and it is generally more efficient and also shows /// clearer intent to use empty. Furthermore some containers may implement the /// empty method but not implement the size method. Using empty whenever /// possible makes it easier to switch to another container in the future. It also uses some custom ASTMatchers. In case you find them useful I can submit them as separate patches to clang. I will apply your suggestions to this patch. http://reviews.llvm.org/D6925 Patch by Gábor Horváth! llvm-svn: 226172
2015-01-15 23:46:58 +08:00
}
void g() {
f<int>();
f<double>();
f<char *>();
}