1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-avoid-bind %t
namespace std {
inline namespace impl {
template <class Fp, class... Arguments>
class bind_rt {};
template <class Fp, class... Arguments>
bind_rt<Fp, Arguments...> bind(Fp &&, Arguments &&...);
}
}
int add(int x, int y) { return x + y; }
void f() {
auto clj = std::bind(add, 2, 2);
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind [modernize-avoid-bind]
// CHECK-FIXES: auto clj = [] { return add(2, 2); };
}
void g() {
int x = 2;
int y = 2;
auto clj = std::bind(add, x, y);
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
// CHECK-FIXES: auto clj = [=] { return add(x, y); };
}
struct placeholder {};
placeholder _1;
placeholder _2;
void h() {
int x = 2;
auto clj = std::bind(add, x, _1);
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
// CHECK-FIXES: auto clj = [=](auto && arg1) { return add(x, arg1); };
}
struct A;
struct B;
bool ABTest(const A &, const B &);
void i() {
auto BATest = std::bind(ABTest, _2, _1);
// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: prefer a lambda to std::bind
// CHECK-FIXES: auto BATest = [](auto && arg1, auto && arg2) { return ABTest(arg2, arg1); };
}
void j() {
auto clj = std::bind(add, 2, 2, 2);
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
// No fix is applied for argument mismatches.
// CHECK-FIXES: auto clj = std::bind(add, 2, 2, 2);
}
void k() {
auto clj = std::bind(add, _1, _1);
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
// No fix is applied for reused placeholders.
// CHECK-FIXES: auto clj = std::bind(add, _1, _1);
}
void m() {
auto clj = std::bind(add, 1, add(2, 5));
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
// No fix is applied for nested calls.
// CHECK-FIXES: auto clj = std::bind(add, 1, add(2, 5));
}
namespace C {
int add(int x, int y){ return x + y; }
}
void n() {
auto clj = std::bind(C::add, 1, 1);
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
// CHECK-FIXES: auto clj = [] { return C::add(1, 1); };
}
// Let's fake a minimal std::function-like facility.
namespace std {
template <typename _Tp>
_Tp declval();
template <typename _Functor, typename... _ArgTypes>
struct __res {
template <typename... _Args>
static decltype(declval<_Functor>()(_Args()...)) _S_test(int);
template <typename...>
static void _S_test(...);
using type = decltype(_S_test<_ArgTypes...>(0));
};
template <typename>
struct function;
template <typename... _ArgTypes>
struct function<void(_ArgTypes...)> {
template <typename _Functor,
typename = typename __res<_Functor, _ArgTypes...>::type>
function(_Functor) {}
};
} // namespace std
struct Thing {};
void UseThing(Thing *);
struct Callback {
Callback();
Callback(std::function<void()>);
void Reset(std::function<void()>);
};
void test(Thing *t) {
Callback cb;
if (t)
cb.Reset(std::bind(UseThing, t));
// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: prefer a lambda to std::bind
// CHECK-FIXES: cb.Reset([=] { return UseThing(t); });
}
|
