llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-tidy Author: Baranov Victor (vbvictor) <details> <summary>Changes</summary> --- Patch is 53.98 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/186669.diff 28 Files Affected: - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/deque (+71) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/forward_list (+61) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/functional (+82) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/list (+68) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/map (+127) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/queue (+45) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/set (+121) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/stack (+28) - (modified) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/string (+1) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/tuple (+81) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/unordered_map (+126) - (added) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/unordered_set (+113) - (modified) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/utility (+28) - (modified) clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/vector (+3-3) - (modified) clang-tools-extra/test/clang-tidy/checkers/bugprone/dangling-handle.cpp (+3-27) - (modified) clang-tools-extra/test/clang-tidy/checkers/bugprone/infinite-loop.cpp (+2-35) - (modified) clang-tools-extra/test/clang-tidy/checkers/bugprone/unsafe-functions.cpp (+3-7) - (modified) clang-tools-extra/test/clang-tidy/checkers/bugprone/use-after-move.cpp (+11-58) - (modified) clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines/pro-bounds-pointer-arithmetic.cpp (+4-4) - (modified) clang-tools-extra/test/clang-tidy/checkers/fuchsia/trailing-return.cpp (+3-7) - (modified) clang-tools-extra/test/clang-tidy/checkers/google/build-explicit-make-pair.cpp (+1-11) - (removed) clang-tools-extra/test/clang-tidy/checkers/modernize/Inputs/use-structured-binding/fake_std_pair_tuple.h (-62) - (modified) clang-tools-extra/test/clang-tidy/checkers/modernize/use-emplace.cpp (+12-303) - (modified) clang-tools-extra/test/clang-tidy/checkers/modernize/use-structured-binding.cpp (+20-5) - (modified) clang-tools-extra/test/clang-tidy/checkers/modernize/use-transparent-functors.cpp (+2-37) - (modified) clang-tools-extra/test/clang-tidy/checkers/portability/std-allocator-const.cpp (+7-33) - (modified) clang-tools-extra/test/clang-tidy/checkers/readability/container-contains.cpp (+3-36) - (modified) clang-tools-extra/test/clang-tidy/checkers/readability/isolate-declaration-cxx17.cpp (+2-16) ``````````diff diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/deque b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/deque new file mode 100644 index 0000000000000..9f7393b467321 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/deque @@ -0,0 +1,71 @@ +#ifndef _DEQUE_ +#define _DEQUE_ + +#include <initializer_list> +#include <memory> + +namespace std { + +template <typename T, typename Allocator = allocator<T>> +class deque { +public: + using value_type = T; + + class iterator { + public: + iterator &operator++(); + iterator operator++(int); + bool operator!=(const iterator &other) const; + bool operator==(const iterator &other) const; + T &operator*(); + T *operator->(); + }; + class const_iterator { + public: + const_iterator() = default; + const_iterator(const iterator &) {} + const_iterator &operator++(); + const_iterator operator++(int); + bool operator!=(const const_iterator &other) const; + bool operator==(const const_iterator &other) const; + const T &operator*() const; + const T *operator->() const; + }; + class reverse_iterator {}; + + deque() = default; + deque(initializer_list<T>) {} + + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + void push_back(const T &) {} + void push_back(T &&) {} + + void push_front(const T &) {} + void push_front(T &&) {} + + template <typename... Args> + iterator emplace(const_iterator pos, Args &&...args); + template <typename... Args> + void emplace_back(Args &&...args) {} + template <typename... Args> + void emplace_front(Args &&...args) {} + + T &operator[](size_t); + const T &operator[](size_t) const; + + void assign(size_t count, const T &value); + + void clear(); + bool empty() const; + size_t size() const; + + ~deque(); +}; + +} // namespace std + +#endif // _DEQUE_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/forward_list b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/forward_list new file mode 100644 index 0000000000000..b2a6521c0d331 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/forward_list @@ -0,0 +1,61 @@ +#ifndef _FORWARD_LIST_ +#define _FORWARD_LIST_ + +#include <initializer_list> +#include <memory> + +namespace std { + +template <typename T, typename Allocator = allocator<T>> +class forward_list { +public: + using value_type = T; + + class iterator { + public: + iterator &operator++(); + iterator operator++(int); + bool operator!=(const iterator &other) const; + bool operator==(const iterator &other) const; + T &operator*(); + T *operator->(); + }; + class const_iterator { + public: + const_iterator() = default; + const_iterator(const iterator &) {} + const_iterator &operator++(); + const_iterator operator++(int); + bool operator!=(const const_iterator &other) const; + bool operator==(const const_iterator &other) const; + const T &operator*() const; + const T *operator->() const; + }; + + forward_list() = default; + forward_list(initializer_list<T>) {} + + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + void push_front(const T &) {} + void push_front(T &&) {} + + template <typename... Args> + void emplace_front(Args &&...args) {} + template <typename... Args> + iterator emplace_after(const_iterator pos, Args &&...args); + + void assign(size_t count, const T &value); + + void clear(); + bool empty() const; + + ~forward_list(); +}; + +} // namespace std + +#endif // _FORWARD_LIST_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/functional b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/functional new file mode 100644 index 0000000000000..0f524c9c85508 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/functional @@ -0,0 +1,82 @@ +#ifndef _FUNCTIONAL_ +#define _FUNCTIONAL_ + +namespace std { + +template <typename T = void> +struct less { + constexpr bool operator()(const T &Lhs, const T &Rhs) const { + return Lhs < Rhs; + } +}; + +template <> +struct less<void> { + template <typename T, typename U> + constexpr bool operator()(T &&Lhs, U &&Rhs) const { + return Lhs < Rhs; + } +}; + +template <typename T = void> +struct greater { + constexpr bool operator()(const T &Lhs, const T &Rhs) const { + return Lhs > Rhs; + } +}; + +template <> +struct greater<void> { + template <typename T, typename U> + constexpr bool operator()(T &&Lhs, U &&Rhs) const { + return Lhs > Rhs; + } +}; + +template <typename T = void> +struct equal_to { + constexpr bool operator()(const T &Lhs, const T &Rhs) const { + return Lhs == Rhs; + } +}; + +template <> +struct equal_to<void> { + template <typename T, typename U> + constexpr bool operator()(T &&Lhs, U &&Rhs) const { + return Lhs == Rhs; + } +}; + +template <typename T> +struct hash {}; + +template <typename T = void> +struct plus { + constexpr T operator()(const T &Lhs, const T &Rhs) const { + return Lhs + Rhs; + } +}; + +template <> +struct plus<void> { + template <typename T, typename U> + constexpr auto operator()(T &&Lhs, U &&Rhs) const -> decltype(Lhs + Rhs) { + return Lhs + Rhs; + } +}; + +template <typename T = void> +struct logical_not { + constexpr bool operator()(const T &Arg) const { return !Arg; } +}; + +template <> +struct logical_not<void> { + template <typename T> + constexpr bool operator()(T &&Arg) const { return !Arg; } +}; + +} // namespace std + +#endif // _FUNCTIONAL_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/list b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/list new file mode 100644 index 0000000000000..a5ea99180869a --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/list @@ -0,0 +1,68 @@ +#ifndef _LIST_ +#define _LIST_ + +#include <initializer_list> +#include <memory> + +namespace std { + +template <typename T, typename Allocator = allocator<T>> +class list { +public: + using value_type = T; + + class iterator { + public: + iterator &operator++(); + iterator operator++(int); + bool operator!=(const iterator &other) const; + bool operator==(const iterator &other) const; + T &operator*(); + T *operator->(); + }; + class const_iterator { + public: + const_iterator() = default; + const_iterator(const iterator &) {} + const_iterator &operator++(); + const_iterator operator++(int); + bool operator!=(const const_iterator &other) const; + bool operator==(const const_iterator &other) const; + const T &operator*() const; + const T *operator->() const; + }; + class reverse_iterator {}; + + list() = default; + list(initializer_list<T>) {} + + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + void push_front(const T &) {} + void push_front(T &&) {} + + void push_back(const T &) {} + void push_back(T &&) {} + + template <typename... Args> + iterator emplace(const_iterator pos, Args &&...args); + template <typename... Args> + void emplace_back(Args &&...args) {} + template <typename... Args> + void emplace_front(Args &&...args) {} + + void assign(size_t count, const T &value); + + void clear(); + bool empty() const; + size_t size() const; + + ~list(); +}; + +} // namespace std + +#endif // _LIST_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/map b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/map new file mode 100644 index 0000000000000..63b10cac05190 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/map @@ -0,0 +1,127 @@ +#ifndef _MAP_ +#define _MAP_ + +#include <functional> +#include <initializer_list> +#include <memory> +#include <utility> + +namespace std { + +template <typename Key, typename T, typename Compare = less<Key>, + typename Allocator = allocator<pair<const Key, T>>> +class map { +public: + using key_type = Key; + using mapped_type = T; + using value_type = std::pair<const Key, T>; + + class iterator { + public: + iterator &operator++(); + iterator operator++(int); + bool operator!=(const iterator &other) const; + bool operator==(const iterator &other) const; + value_type &operator*(); + value_type *operator->(); + }; + class const_iterator { + public: + const_iterator() = default; + const_iterator(const iterator &) {} + const_iterator(decltype(nullptr)) {} + const_iterator &operator++(); + const_iterator operator++(int); + bool operator!=(const const_iterator &other) const; + bool operator==(const const_iterator &other) const; + const value_type &operator*() const; + const value_type *operator->() const; + }; + + map() = default; + map(initializer_list<value_type>) {} + + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + T &operator[](const Key &); + T &operator[](Key &&); + + template <typename... Args> + void emplace(Args &&...args) {} + template <typename... Args> + iterator emplace_hint(const_iterator pos, Args &&...args); + + template <typename... Args> + pair<iterator, bool> try_emplace(const Key &key, Args &&...args); + + iterator find(const Key &); + const_iterator find(const Key &) const; + + T &at(const Key &); + const T &at(const Key &) const; + + unsigned count(const Key &) const; + bool contains(const Key &) const; + + void clear(); + bool empty() const; + size_t size() const; +}; + +template <typename Key, typename T, typename Compare = less<Key>, + typename Allocator = allocator<pair<const Key, T>>> +class multimap { +public: + using key_type = Key; + using mapped_type = T; + using value_type = std::pair<const Key, T>; + + class iterator { + public: + iterator &operator++(); + iterator operator++(int); + bool operator!=(const iterator &other) const; + bool operator==(const iterator &other) const; + value_type &operator*(); + value_type *operator->(); + }; + class const_iterator { + public: + const_iterator() = default; + const_iterator(const iterator &) {} + const_iterator(decltype(nullptr)) {} + const_iterator &operator++(); + const_iterator operator++(int); + bool operator!=(const const_iterator &other) const; + bool operator==(const const_iterator &other) const; + const value_type &operator*() const; + const value_type *operator->() const; + }; + + multimap() = default; + multimap(initializer_list<value_type>) {} + + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + template <typename... Args> + void emplace(Args &&...args) {} + template <typename... Args> + iterator emplace_hint(const_iterator pos, Args &&...args); + + unsigned count(const Key &) const; + bool contains(const Key &) const; + + void clear(); + bool empty() const; + size_t size() const; +}; + +} // namespace std + +#endif // _MAP_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/queue b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/queue new file mode 100644 index 0000000000000..99ae5ff1c1ed1 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/queue @@ -0,0 +1,45 @@ +#ifndef _QUEUE_ +#define _QUEUE_ + +namespace std { + +template <typename T, typename Container = void> +class queue { +public: + using value_type = T; + + void push(const T &) {} + void push(T &&) {} + + template <typename... Args> + void emplace(Args &&...args) {} + + T &front(); + const T &front() const; + T &back(); + const T &back() const; + + bool empty() const; + size_t size() const; +}; + +template <typename T, typename Container = void, typename Compare = void> +class priority_queue { +public: + using value_type = T; + + void push(const T &) {} + void push(T &&) {} + + template <typename... Args> + void emplace(Args &&...args) {} + + const T &top() const; + + bool empty() const; + size_t size() const; +}; + +} // namespace std + +#endif // _QUEUE_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/set b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/set new file mode 100644 index 0000000000000..39448431da032 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/set @@ -0,0 +1,121 @@ +#ifndef _SET_ +#define _SET_ + +#include <functional> +#include <initializer_list> +#include <memory> +#include <utility> + +namespace std { + +template <typename T, typename Compare = less<T>, + typename Allocator = allocator<T>> +class set { +public: + using value_type = T; + using key_type = T; + + class iterator { + public: + iterator &operator++(); + iterator operator++(int); + bool operator!=(const iterator &other) const; + bool operator==(const iterator &other) const; + const T &operator*() const; + const T *operator->() const; + }; + class const_iterator { + public: + const_iterator() = default; + const_iterator(const iterator &) {} + const_iterator(decltype(nullptr)) {} + const_iterator &operator++(); + const_iterator operator++(int); + bool operator!=(const const_iterator &other) const; + bool operator==(const const_iterator &other) const; + const T &operator*() const; + const T *operator->() const; + }; + + set() = default; + set(initializer_list<T>) {} + + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + pair<iterator, bool> insert(const T &); + pair<iterator, bool> insert(T &&); + iterator insert(const_iterator hint, const T &); + iterator insert(const_iterator hint, T &&); + + template <typename... Args> + void emplace(Args &&...args) {} + template <typename... Args> + iterator emplace_hint(const_iterator pos, Args &&...args); + + iterator find(const T &); + const_iterator find(const T &) const; + + unsigned count(const T &) const; + bool contains(const T &) const; + + void clear(); + bool empty() const; + size_t size() const; +}; + +template <typename T, typename Compare = less<T>, + typename Allocator = allocator<T>> +class multiset { +public: + using value_type = T; + using key_type = T; + + class iterator { + public: + iterator &operator++(); + iterator operator++(int); + bool operator!=(const iterator &other) const; + bool operator==(const iterator &other) const; + const T &operator*() const; + const T *operator->() const; + }; + class const_iterator { + public: + const_iterator() = default; + const_iterator(const iterator &) {} + const_iterator(decltype(nullptr)) {} + const_iterator &operator++(); + const_iterator operator++(int); + bool operator!=(const const_iterator &other) const; + bool operator==(const const_iterator &other) const; + const T &operator*() const; + const T *operator->() const; + }; + + multiset() = default; + multiset(initializer_list<T>) {} + + iterator begin(); + const_iterator begin() const; + iterator end(); + const_iterator end() const; + + template <typename... Args> + void emplace(Args &&...args) {} + template <typename... Args> + iterator emplace_hint(const_iterator pos, Args &&...args); + + unsigned count(const T &) const; + bool contains(const T &) const; + + void clear(); + bool empty() const; + size_t size() const; +}; + +} // namespace std + +#endif // _SET_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/stack b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/stack new file mode 100644 index 0000000000000..a5edaed7eb152 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/stack @@ -0,0 +1,28 @@ +#ifndef _STACK_ +#define _STACK_ + +#include <deque> + +namespace std { + +template <typename T, typename Container = deque<T>> +class stack { +public: + using value_type = T; + + void push(const T &) {} + void push(T &&) {} + + template <typename... Args> + void emplace(Args &&...args) {} + + T &top(); + const T &top() const; + + bool empty() const; + size_t size() const; +}; + +} // namespace std + +#endif // _STACK_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/string b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/string index 3631c0330c427..dbebeaaa46514 100644 --- a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/string +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/string @@ -33,6 +33,7 @@ struct basic_string { const C *c_str() const; const C *data() const; + void clear(); bool empty() const; size_type size() const; size_type length() const; diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/tuple b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/tuple new file mode 100644 index 0000000000000..1424b95b09355 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/tuple @@ -0,0 +1,81 @@ +#ifndef _TUPLE_ +#define _TUPLE_ + +#include <utility> + +namespace std { + +template <typename T, T V> +struct integral_constant { + static constexpr T value = V; +}; + +struct _Swallow_assign +{ + template<class _Tp> + const _Swallow_assign& + operator=(const _Tp&) const + { return *this; } +}; + +constexpr _Swallow_assign ignore{}; + +template <typename... Ts> +class tuple { +public: + tuple() = default; + tuple(const tuple &) = default; + tuple(tuple &&) = default; + tuple &operator=(const tuple &) = default; + tuple &operator=(tuple &&) = default; + + tuple(const Ts &...) {} + tuple(Ts &&...) {} + + template <typename... Us> + tuple(const tuple<Us...> &) {} + template <typename... Us> + tuple(tuple<Us...> &&) {} + + template <typename U1, typename U2> + tuple(const pair<U1, U2> &) {} + template <typename U1, typename U2> + tuple(pair<U1, U2> &&) {} +}; + +template <typename T> +struct tuple_size; + +template <typename... Ts> +struct tuple_size<tuple<Ts...>> + : integral_constant<size_t, sizeof...(Ts)> {}; + +template <size_t I, typename T> +struct tuple_element; + +template <size_t I, typename... Ts> +struct tuple_element<I, tuple<Ts...>> { + using type = __type_pack_element<I, Ts...>; +}; + +template <size_t I, typename... Ts> +typename tuple_element<I, tuple<Ts...>>::type +get(const tuple<Ts...> &); + +template <size_t I, typename... Ts> +typename tuple_element<I, tuple<Ts...>>::type +get(tuple<Ts...> &&); + +template <typename... Ts> +tuple<typename remove_reference<Ts>::type...> make_tuple(Ts &&...) { + return {}; +} + +template<typename... Args> +tuple<Args...> tie(Args&... args) { + return tuple<Args...>(args...); +} + +} // namespace std + +#endif // _TUPLE_ diff --git a/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/unordered_map b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/unordered_map new file mode 100644 index 0000000000000..509fdaa96849a --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/checkers/Inputs/Headers/std/unordered_map @@ -0,0 +1,126 @@ +#ifndef _UNORDERED_MAP_ +#define _UNORDERED_MAP_ + +#include <functional> +#include <initializer_list> +#include <memory> +#include <utility> + +namespace std { + +template <typename Key, typename T, typename Hash = hash<Key>, + typename Pred = equal_to<Key>, + typename Allocator = allocator<pair<const Key, T>>> +class unordered_map { +public: + using key_type = Key; + using mapped_type = T; + using value_type = std::pair<const Key, T>; + + class iterator { + public: + iterator &operator++(); + iterator operator++(int); + bool operator!=(const iterator &other) const; + bool operator==(const iterator &other) const; + value_type &operator*(); + value_type *operator->(); + const value_type &operator*() const; + const value_type *operator->() const; + }; + class const_iterator { + public: + const_iterator() = default; + const_iterator(const iterator &) {} + const_iterator &operator++(); + const_iterator operator++(int); + bool operator!=(const const_iterator &other) const; + bool operator==(const const_iterator &other) const; + const value_type &operator*() const; + const value... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/186669 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
