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/checkers/readability-container-size-...

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

699 lines
25 KiB
C++
Raw Normal View History

Try to fix build on Windows
2020-12-23 04:25:10 +08:00
// RUN: %check_clang_tidy %s readability-container-size-empty %t -- -- -fno-delayed-template-parsing
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(); }
};
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
struct Lazy {
constexpr unsigned size() const { return 0; }
constexpr bool empty() const { return true; }
};
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 s_func() {
return std::string();
}
[ClangTidy] NFC: Add more tests for container-size-empty
2020-12-15 07:09:32 +08:00
void takesBool(bool)
{
}
bool returnsBool() {
[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;
[clang-tidy] Minor fixes in a test Use CHECK-FIXES where it was intended instead of CHECK-MESSAGES. Fixed compiler warnings to pacify YouCompleteMe. llvm-svn: 347651
2018-11-27 18:53:38 +08:00
(void)(str.size() + 0);
(void)(str.size() - 0);
(void)(0 + str.size());
(void)(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()){{$}}
[clang-tidy] Avoid inconsistent notes in readability-container-size-empty When a warning is issued in a template instantiation, the check would previously use template arguments in a note, which would result in inconsistent or duplicate warnings (depending on how deduplication was done). This patch removes template arguments from the note. llvm-svn: 347652
2018-11-27 18:53:44 +08:00
// CHECK-MESSAGES: :32:8: note: method 'set'::empty() defined here
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 (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()){{$}}
[clang-tidy] Avoid inconsistent notes in readability-container-size-empty When a warning is issued in a template instantiation, the check would previously use template arguments in a note, which would result in inconsistent or duplicate warnings (depending on how deduplication was done). This patch removes template arguments from the note. llvm-svn: 347652
2018-11-27 18:53:44 +08:00
// CHECK-MESSAGES: :32:8: note: method 'set'::empty() defined here
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 (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()){{$}}
[ClangTidy] NFC: Add more tests for container-size-empty
2020-12-15 07:09:32 +08:00
takesBool(derived.size());
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}takesBool(!derived.empty());
takesBool(derived.size() == 0);
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}takesBool(derived.empty());
takesBool(derived.size() != 0);
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}takesBool(!derived.empty());
bool b1 = derived.size();
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}bool b1 = !derived.empty();
bool b2(derived.size());
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}bool b2(!derived.empty());
auto b3 = static_cast<bool>(derived.size());
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}auto b3 = static_cast<bool>(!derived.empty());
auto b4 = (bool)derived.size();
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}auto b4 = (bool)!derived.empty();
auto b5 = bool(derived.size());
// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}auto b5 = bool(!derived.empty());
return derived.size();
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used
// CHECK-FIXES: {{^ }}return !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
}
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
class ConstructWithBoolField {
bool B;
public:
ConstructWithBoolField(const std::vector<int> &C) : B(C.size()) {}
// CHECK-MESSAGES: :[[@LINE-1]]:57: warning: the 'empty' method should be used
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}ConstructWithBoolField(const std::vector<int> &C) : B(!C.empty()) {}
};
struct StructWithNSDMI {
std::vector<int> C;
bool B = C.size();
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: the 'empty' method should be used
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}bool B = !C.empty();
};
int func(const std::vector<int> &C) {
return C.size() ? 0 : 1;
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}return !C.empty() ? 0 : 1;
}
constexpr Lazy L;
static_assert(!L.size(), "");
// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: the 'empty' method should be used
// CHECK-MESSAGES: :101:18: note: method 'Lazy'::empty() defined here
// CHECK-FIXES: {{^}}static_assert(L.empty(), "");
struct StructWithLazyNoexcept {
void func() noexcept(L.size());
};
[clang-tidy] Minor fixes in a test Use CHECK-FIXES where it was intended instead of CHECK-MESSAGES. Fixed compiler warnings to pacify YouCompleteMe. llvm-svn: 347651
2018-11-27 18:53:38 +08:00
#define CHECKSIZE(x) if (x.size()) {}
// CHECK-FIXES: #define CHECKSIZE(x) if (x.size()) {}
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
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] Avoid inconsistent notes in readability-container-size-empty When a warning is issued in a template instantiation, the check would previously use template arguments in a note, which would result in inconsistent or duplicate warnings (depending on how deduplication was done). This patch removes template arguments from the note. llvm-svn: 347652
2018-11-27 18:53:44 +08:00
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
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] Avoid inconsistent notes in readability-container-size-empty When a warning is issued in a template instantiation, the check would previously use template arguments in a note, which would result in inconsistent or duplicate warnings (depending on how deduplication was done). This patch removes template arguments from the note. llvm-svn: 347652
2018-11-27 18:53:44 +08:00
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
[clang-tidy] Minor fixes in a test Use CHECK-FIXES where it was intended instead of CHECK-MESSAGES. Fixed compiler warnings to pacify YouCompleteMe. llvm-svn: 347651
2018-11-27 18:53:38 +08:00
// CHECK-FIXES: 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
[clang-tidy] Avoid inconsistent notes in readability-container-size-empty When a warning is issued in a template instantiation, the check would previously use template arguments in a note, which would result in inconsistent or duplicate warnings (depending on how deduplication was done). This patch removes template arguments from the note. llvm-svn: 347652
2018-11-27 18:53:44 +08:00
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
[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: {{^ }}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
[clang-tidy] Avoid inconsistent notes in readability-container-size-empty When a warning is issued in a template instantiation, the check would previously use template arguments in a note, which would result in inconsistent or duplicate warnings (depending on how deduplication was done). This patch removes template arguments from the note. llvm-svn: 347652
2018-11-27 18:53:44 +08:00
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
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-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
[clang-tidy] Avoid inconsistent notes in readability-container-size-empty When a warning is issued in a template instantiation, the check would previously use template arguments in a note, which would result in inconsistent or duplicate warnings (depending on how deduplication was done). This patch removes template arguments from the note. llvm-svn: 347652
2018-11-27 18:53:44 +08:00
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
[clang-tidy] Minor fixes in a test Use CHECK-FIXES where it was intended instead of CHECK-MESSAGES. Fixed compiler warnings to pacify YouCompleteMe. llvm-svn: 347651
2018-11-27 18:53:38 +08:00
// CHECK-FIXES: 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 *>();
}
[clang-tidy] Handle template instantiations in container size check readability-container-size-empty currently modifies source code based on AST nodes in template instantiations, which means that it makes transformations based on substituted types. This can lead to transforming code to be broken. Change the matcher implementation to ignore template instantiations explicitly, and add a matcher to explicitly handle template declarations instead of instantiations. Differential Revision: https://reviews.llvm.org/D91302
2020-10-28 07:24:20 +08:00
template <typename T>
bool neverInstantiatedTemplate() {
std::vector<T> v;
if (v.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty]
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}if (!v.empty()){{$}}
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()){{$}}
// CHECK-FIXES-NEXT: ;
if (v.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-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}if (v.empty()){{$}}
if (v.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-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}if (!v.empty()){{$}}
if (v.size() < 1)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty]
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}if (v.empty()){{$}}
if (v.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-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}if (!v.empty()){{$}}
if (v.size() == 1)
;
if (v.size() != 1)
;
if (v.size() == 2)
;
if (v.size() != 2)
;
if (static_cast<bool>(v.size()))
;
// CHECK-MESSAGES: :[[@LINE-2]]:25: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty]
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}if (static_cast<bool>(!v.empty())){{$}}
if (v.size() && false)
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty]
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}if (!v.empty() && false){{$}}
if (!v.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:8: warning: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty]
// CHECK-MESSAGES: :9:8: note: method 'vector'::empty() defined here
// CHECK-FIXES: {{^ }}if (v.empty()){{$}}
TemplatedContainer<T> templated_container;
if (templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
if (templated_container != TemplatedContainer<T>())
;
// CHECK-MESSAGES: :[[@LINE-2]]:7: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}if (!templated_container.empty()){{$}}
// CHECK-FIXES-NEXT: ;
while (templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:10: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}while (!templated_container.empty()){{$}}
do {
}
while (templated_container.size());
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}while (!templated_container.empty());
for (; templated_container.size();)
;
// CHECK-MESSAGES: :[[@LINE-2]]:10: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}for (; !templated_container.empty();){{$}}
if (true && templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:15: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}if (true && !templated_container.empty()){{$}}
if (true || templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:15: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}if (true || !templated_container.empty()){{$}}
if (!templated_container.size())
;
// CHECK-MESSAGES: :[[@LINE-2]]:8: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}if (templated_container.empty()){{$}}
bool b1 = templated_container.size();
// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}bool b1 = !templated_container.empty();
bool b2(templated_container.size());
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}bool b2(!templated_container.empty());
auto b3 = static_cast<bool>(templated_container.size());
// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}auto b3 = static_cast<bool>(!templated_container.empty());
auto b4 = (bool)templated_container.size();
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}auto b4 = (bool)!templated_container.empty();
auto b5 = bool(templated_container.size());
// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}auto b5 = bool(!templated_container.empty());
takesBool(templated_container.size());
// We don't detect this one because we don't know the parameter of takesBool
// until the type of templated_container.size() is known
return templated_container.size();
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: the 'empty' method should be used
// CHECK-MESSAGES: :44:8: note: method 'TemplatedContainer'::empty() defined here
// CHECK-FIXES: {{^ }}return !templated_container.empty();
}
template <typename TypeRequiresSize>
void instantiatedTemplateWithSizeCall() {
TypeRequiresSize t;
// The instantiation of the template with std::vector<int> should not
// result in changing the template, because we don't know that
// TypeRequiresSize generally has `.empty()`
if (t.size())
;
if (t == TypeRequiresSize{})
;
if (t != TypeRequiresSize{})
;
}
class TypeWithSize {
public:
TypeWithSize();
bool operator==(const TypeWithSize &other) const;
bool operator!=(const TypeWithSize &other) const;
unsigned size() const { return 0; }
// Does not have `.empty()`
};
void instantiator() {
instantiatedTemplateWithSizeCall<TypeWithSize>();
instantiatedTemplateWithSizeCall<std::vector<int>>();
}