1 // RUN: echo "static void staticFunctionHeader(int i) {;}" > %T/header.h
2 // RUN: echo "static void staticFunctionHeader(int /*i*/) {;}" > %T/header-fixed.h
3 // RUN: %check_clang_tidy -std=c++11 %s misc-unused-parameters %t -- -header-filter='.*' -- -fno-delayed-template-parsing
4 // RUN: diff %T/header.h %T/header-fixed.h
5 // FIXME: Make the test work in all language modes.
6
7 #include "header.h"
8 // CHECK-MESSAGES: header.h:1:38: warning
9
10 // Basic removal
11 // =============
a(int i)12 void a(int i) {;}
13 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]
14 // CHECK-FIXES: {{^}}void a(int /*i*/) {;}{{$}}
15
b(int i=1)16 void b(int i = 1) {;}
17 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]
18 // CHECK-FIXES: {{^}}void b(int /*i*/ = 1) {;}{{$}}
19
c(int * i)20 void c(int *i) {;}
21 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: parameter 'i' is unused [misc-unused-parameters]
22 // CHECK-FIXES: {{^}}void c(int * /*i*/) {;}{{$}}
23
d(int i[])24 void d(int i[]) {;}
25 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]
26 // CHECK-FIXES: {{^}}void d(int /*i*/[]) {;}{{$}}
27
e(int i[1])28 void e(int i[1]) {;}
29 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]
30 // CHECK-FIXES: {{^}}void e(int /*i*/[1]) {;}{{$}}
31
f(void (* fn)())32 void f(void (*fn)()) {;}
33 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: parameter 'fn' is unused [misc-unused-parameters]
34 // CHECK-FIXES: {{^}}void f(void (* /*fn*/)()) {;}{{$}}
35
36 // Unchanged cases
37 // ===============
38 void f(int i); // Don't remove stuff in declarations
39 void g(int i = 1);
40 void h(int i[]);
41 void s(int i[1]);
42 void u(void (*fn)());
w(int i)43 void w(int i) { (void)i; } // Don't remove used parameters
44
45 bool useLambda(int (*fn)(int));
__anon861a6ca00102(int a) 46 static bool static_var = useLambda([] (int a) { return a; });
47
48 // Remove parameters of local functions
49 // ====================================
50 static void staticFunctionA(int i);
51 // CHECK-FIXES: {{^}}static void staticFunctionA();
staticFunctionA(int i)52 static void staticFunctionA(int i) {;}
53 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning
54 // CHECK-FIXES: {{^}}static void staticFunctionA()
55
staticFunctionB(int i,int j)56 static void staticFunctionB(int i, int j) { (void)i; }
57 // CHECK-MESSAGES: :[[@LINE-1]]:40: warning
58 // CHECK-FIXES: {{^}}static void staticFunctionB(int i)
59
staticFunctionC(int i,int j)60 static void staticFunctionC(int i, int j) { (void)j; }
61 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning
62 // CHECK-FIXES: {{^}}static void staticFunctionC(int j)
63
staticFunctionD(int i,int j,int k)64 static void staticFunctionD(int i, int j, int k) { (void)i; (void)k; }
65 // CHECK-MESSAGES: :[[@LINE-1]]:40: warning
66 // CHECK-FIXES: {{^}}static void staticFunctionD(int i, int k)
67
staticFunctionE(int i=4)68 static void staticFunctionE(int i = 4) {;}
69 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning
70 // CHECK-FIXES: {{^}}static void staticFunctionE()
71
72 static void staticFunctionF(int i = 4);
73 // CHECK-FIXES: {{^}}static void staticFunctionF();
staticFunctionF(int i)74 static void staticFunctionF(int i) {;}
75 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning
76 // CHECK-FIXES: {{^}}static void staticFunctionF()
77
78 static void staticFunctionG(int i[]);
79 // CHECK-FIXES: {{^}}static void staticFunctionG();
staticFunctionG(int i[])80 static void staticFunctionG(int i[]) {;}
81 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning
82 // CHECK-FIXES: {{^}}static void staticFunctionG()
83
84 static void staticFunctionH(void (*fn)());
85 // CHECK-FIXES: {{^}}static void staticFunctionH();
staticFunctionH(void (* fn)())86 static void staticFunctionH(void (*fn)()) {;}
87 // CHECK-MESSAGES: :[[@LINE-1]]:36: warning
88 // CHECK-FIXES: {{^}}static void staticFunctionH()
89
someCallSites()90 static void someCallSites() {
91 staticFunctionA(1);
92 // CHECK-FIXES: staticFunctionA();
93 staticFunctionB(1, 2);
94 // CHECK-FIXES: staticFunctionB(1);
95 staticFunctionC(1, 2);
96 // CHECK-FIXES: staticFunctionC(2);
97 staticFunctionD(1, 2, 3);
98 // CHECK-FIXES: staticFunctionD(1, 3);
99 staticFunctionE(1);
100 // CHECK-FIXES: staticFunctionE();
101 staticFunctionF(1);
102 // CHECK-FIXES: staticFunctionF();
103 staticFunctionF();
104 // CHECK-FIXES: staticFunctionF();
105 int t[] = {1};
106 staticFunctionG(t);
107 // CHECK-FIXES: staticFunctionG();
108 void func();
109 staticFunctionH(&func);
110 // CHECK-FIXES: staticFunctionH();
111 }
112
113 /*
114 * FIXME: This fails because the removals overlap and ClangTidy doesn't apply
115 * them.
116 * static void bothVarsUnused(int a, int b) {;}
117 */
118
119 // Regression test for long variable names and expressions
120 // =======================================================
variableWithLongName1(int LongName1,int LongName2)121 static int variableWithLongName1(int LongName1, int LongName2) {
122 // CHECK-MESSAGES: :[[@LINE-1]]:53: warning: parameter 'LongName2' is unused
123 // CHECK-FIXES: {{^}}static int variableWithLongName1(int LongName1) {
124 return LongName1;
125 }
variableWithLongName2(int LongName1,int LongName2)126 static int variableWithLongName2(int LongName1, int LongName2) {
127 // CHECK-MESSAGES: :[[@LINE-1]]:38: warning: parameter 'LongName1' is unused
128 // CHECK-FIXES: {{^}}static int variableWithLongName2(int LongName2) {
129 return LongName2;
130 }
someLongNameCallSites()131 static void someLongNameCallSites() {
132 int LongName1 = 7, LongName2 = 17;
133 variableWithLongName1(LongName1, LongName2);
134 // CHECK-FIXES: variableWithLongName1(LongName1);
135 variableWithLongName2(LongName1, LongName2);
136 // CHECK-FIXES: variableWithLongName2(LongName2);
137 }
138
139 class SomeClass {
f(int i)140 static void f(int i) {;}
141 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning
142 // CHECK-FIXES: static void f(int /*i*/) {;}
g(int i=1)143 static void g(int i = 1) {;}
144 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning
145 // CHECK-FIXES: static void g(int /*i*/ = 1) {;}
h(int i[])146 static void h(int i[]) {;}
147 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning
148 // CHECK-FIXES: static void h(int /*i*/[]) {;}
s(void (* fn)())149 static void s(void (*fn)()) {;}
150 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning
151 // CHECK-FIXES: static void s(void (* /*fn*/)()) {;}
152 };
153
154 namespace {
155 class C {
156 public:
157 void f(int i);
158 // CHECK-FIXES: void f();
g(int i)159 void g(int i) {;}
160 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning
161 // CHECK-FIXES: void g() {;}
h(int i)162 void h(int i) {;}
163 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning
164 // CHECK-FIXES: void h(int /*i*/) {;}
s(int i=1)165 void s(int i = 1) {;}
166 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning
167 // CHECK-FIXES: void s(int /*i*/ = 1) {;}
u(int i[])168 void u(int i[]) {;}
169 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning
170 // CHECK-FIXES: void u(int /*i*/[]) {;}
w(void (* fn)())171 void w(void (*fn)()) {;}
172 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning
173 // CHECK-FIXES: void w(void (* /*fn*/)()) {;}
174 };
175
f(int i)176 void C::f(int i) {;}
177 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning
178 // CHECK-FIXES: void C::f() {;}
179
180 template <typename T>
181 void useFunction(T t);
182
someMoreCallSites()183 void someMoreCallSites() {
184 C c;
185 c.f(1);
186 // CHECK-FIXES: c.f();
187 c.g(1);
188 // CHECK-FIXES: c.g();
189
190 useFunction(&C::h);
191 useFunction(&C::s);
192 useFunction(&C::u);
193 useFunction(&C::w);
194 }
195
196 class Base {
197 virtual void f(int i);
198 };
199
200 class Derived : public Base {
f(int i)201 void f(int i) override {;}
202 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning
203 // CHECK-FIXES: void f(int /*i*/) override {;}
204 };
205
206 } // end namespace
207
someFunctionTemplate(T b,T e)208 template <typename T> void someFunctionTemplate(T b, T e) { (void)b; (void)e; }
209
someFunctionTemplateOneUnusedParam(T b,T e)210 template <typename T> void someFunctionTemplateOneUnusedParam(T b, T e) { (void)e; }
211 // CHECK-MESSAGES: :[[@LINE-1]]:65: warning
212 // CHECK-FIXES: {{^}}template <typename T> void someFunctionTemplateOneUnusedParam(T /*b*/, T e) { (void)e; }
213
someFunctionTemplateAllUnusedParams(T b,T e)214 template <typename T> void someFunctionTemplateAllUnusedParams(T b, T e) {;}
215 // CHECK-MESSAGES: :[[@LINE-1]]:66: warning
216 // CHECK-MESSAGES: :[[@LINE-2]]:71: warning
217 // CHECK-FIXES: {{^}}template <typename T> void someFunctionTemplateAllUnusedParams(T /*b*/, T /*e*/) {;}
218
dontGetConfusedByParametersInFunctionTypes()219 static void dontGetConfusedByParametersInFunctionTypes() { void (*F)(int i); }
220
221 template <typename T> class Function {};
dontGetConfusedByFunctionReturnTypes()222 static Function<void(int, int i)> dontGetConfusedByFunctionReturnTypes() {
223 return Function<void(int, int)>();
224 }
225
226 namespace PR38055 {
227 namespace {
228 struct a {
bPR38055::__anon861a6ca00311::a229 void b(int c) {;}
230 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: parameter 'c' is unused
231 // CHECK-FIXES: {{^}} void b() {;}{{$}}
232 };
233 template <class>
234 class d {
235 a e;
f()236 void f() { e.b(0); }
237 };
238 } // namespace
239 } // namespace PR38055
240
241 namespace strict_mode_off {
242 // Do not warn on empty function bodies.
f1(int foo1)243 void f1(int foo1) {}
f2(int foo2)244 void f2(int foo2) {
245 // "empty" in the AST sense, not in textual sense.
246 }
f3(int foo3)247 void f3(int foo3) {;}
248 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: parameter 'foo3' is unused
249 // CHECK-FIXES: {{^}}void f3(int /*foo3*/) {;}{{$}}
250
251 class E {
252 int i;
253
254 public:
E(int j)255 E(int j) {}
256 };
257 class F {
258 int i;
259
260 public:
261 // Constructor initializer counts as a non-empty body.
F(int j)262 F(int j) : i() {}
263 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'j' is unused
264 // CHECK-FIXES: {{^}} F(int /*j*/) : i() {}{{$}}
265 };
266
267 class A {
268 public:
269 A();
270 A(int);
271 };
272 class B : public A {
273 public:
B(int i)274 B(int i) : A() {}
275 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: parameter 'i' is unused
276 // CHECK-FIXES: {{^}} B(int /*i*/) : A() {}{{$}}
277 };
278 } // namespace strict_mode_off
279
280 namespace lambda {
281 using fn = void(int);
282 void f(fn *);
test()283 void test() {
284 // CHECK-MESSAGES: :[[@LINE+2]]:12: warning: parameter 'I' is unused
285 // CHECK-FIXES: {{^}} f([](int /*I*/) {
286 f([](int I) { return; });
287 }
288 } // namespace lambda
289