1 // RUN: %check_clang_tidy %s readability-suspicious-call-argument %t -- -- -std=c++11
2
foo_1(int aaaaaa,int bbbbbb)3 void foo_1(int aaaaaa, int bbbbbb) {}
4
foo_2(int source,int aaaaaa)5 void foo_2(int source, int aaaaaa) {}
6
foo_3(int valToRet,int aaaaaa)7 void foo_3(int valToRet, int aaaaaa) {}
8
foo_4(int pointer,int aaaaaa)9 void foo_4(int pointer, int aaaaaa) {}
10
foo_5(int aaaaaa,int bbbbbb,int cccccc,...)11 void foo_5(int aaaaaa, int bbbbbb, int cccccc, ...) {}
12
foo_6(const int dddddd,bool & eeeeee)13 void foo_6(const int dddddd, bool &eeeeee) {}
14
foo_7(int aaaaaa,int bbbbbb,int cccccc,int ffffff=7)15 void foo_7(int aaaaaa, int bbbbbb, int cccccc, int ffffff = 7) {}
16
foo_8(int frobble1,int frobble2)17 void foo_8(int frobble1, int frobble2) {}
18
19 // Test functions for convertible argument--parameter types.
20 void fun(const int &m);
fun2()21 void fun2() {
22 int m = 3;
23 fun(m);
24 }
25
26 // Test cases for parameters of const reference and value.
27 void value_const_reference(int llllll, const int &kkkkkk);
28
const_ref_value_swapped()29 void const_ref_value_swapped() {
30 const int &kkkkkk = 42;
31 const int &llllll = 42;
32 value_const_reference(kkkkkk, llllll);
33 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'kkkkkk' (passed to 'llllll') looks like it might be swapped with the 2nd, 'llllll' (passed to 'kkkkkk') [readability-suspicious-call-argument]
34 // CHECK-MESSAGES: :[[@LINE-7]]:6: note: in the call to 'value_const_reference', declared here
35 }
36
37 // Const, non const references.
38 void const_nonconst_parameters(const int &mmmmmm, int &nnnnnn);
39
const_nonconst_swap1()40 void const_nonconst_swap1() {
41 const int &nnnnnn = 42;
42 int mmmmmm;
43 // Do not check, because non-const reference parameter cannot bind to const reference argument.
44 const_nonconst_parameters(nnnnnn, mmmmmm);
45 }
46
const_nonconst_swap3()47 void const_nonconst_swap3() {
48 const int nnnnnn = 42;
49 int m = 42;
50 int &mmmmmm = m;
51 // Do not check, const int does not bind to non const reference.
52 const_nonconst_parameters(nnnnnn, mmmmmm);
53 }
54
const_nonconst_swap2()55 void const_nonconst_swap2() {
56 int nnnnnn;
57 int mmmmmm;
58 // Check for swapped arguments. (Both arguments are non-const.)
59 const_nonconst_parameters(nnnnnn, mmmmmm);
60 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'nnnnnn' (passed to 'mmmmmm') looks like it might be swapped with the 2nd, 'mmmmmm' (passed to 'nnnnnn')
61 }
62
63 void const_nonconst_pointers(const int *mmmmmm, int *nnnnnn);
64 void const_nonconst_pointers2(const int *mmmmmm, const int *nnnnnn);
65
const_nonconst_pointers_swapped()66 void const_nonconst_pointers_swapped() {
67 int *mmmmmm;
68 const int *nnnnnn;
69 const_nonconst_pointers(nnnnnn, mmmmmm);
70 }
71
const_nonconst_pointers_swapped2()72 void const_nonconst_pointers_swapped2() {
73 const int *mmmmmm;
74 int *nnnnnn;
75 const_nonconst_pointers2(nnnnnn, mmmmmm);
76 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'nnnnnn' (passed to 'mmmmmm') looks like it might be swapped with the 2nd, 'mmmmmm' (passed to 'nnnnnn')
77 }
78
79 // Test cases for pointers and arrays.
80 void pointer_array_parameters(
81 int *pppppp, int qqqqqq[4]);
82
pointer_array_swap()83 void pointer_array_swap() {
84 int qqqqqq[5];
85 int *pppppp;
86 // Check for swapped arguments. An array implicitly converts to a pointer.
87 pointer_array_parameters(qqqqqq, pppppp);
88 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'qqqqqq' (passed to 'pppppp') looks like it might be swapped with the 2nd, 'pppppp' (passed to 'qqqqqq')
89 }
90
91 // Test cases for multilevel pointers.
92 void multilevel_pointer_parameters(int *const **pppppp,
93 const int *const *volatile const *qqqqqq);
94 void multilevel_pointer_parameters2(
95 char *****nnnnnn, char *volatile *const *const *const *const &mmmmmm);
96
97 typedef float T;
98 typedef T *S;
99 typedef S *const volatile R;
100 typedef R *Q;
101 typedef Q *P;
102 typedef P *O;
103 void multilevel_pointer_parameters3(float **const volatile ***rrrrrr, O &ssssss);
104
multilevel_pointer_swap()105 void multilevel_pointer_swap() {
106 int *const **qqqqqq;
107 int *const **pppppp;
108 multilevel_pointer_parameters(qqqqqq, pppppp);
109 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'qqqqqq' (passed to 'pppppp') looks like it might be swapped with the 2nd, 'pppppp' (passed to 'qqqqqq')
110
111 char *****mmmmmm;
112 char *****nnnnnn;
113 multilevel_pointer_parameters2(mmmmmm, nnnnnn);
114 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'mmmmmm' (passed to 'nnnnnn') looks like it might be swapped with the 2nd, 'nnnnnn' (passed to 'mmmmmm')
115
116 float **const volatile ***rrrrrr;
117 float **const volatile ***ssssss;
118 multilevel_pointer_parameters3(ssssss, rrrrrr);
119 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'ssssss' (passed to 'rrrrrr') looks like it might be swapped with the 2nd, 'rrrrrr' (passed to 'ssssss')
120 }
121
122 void multilevel_pointer_parameters4(char ****pppppp,
123 char *const volatile **const *qqqqqq);
124 void multilevel_pointer_parameters5(
125 bool *****nnnnnn, bool *volatile *const *const *const *&mmmmmm);
126 void multilevel_pointer_parameters6(double **llllll, char **&kkkkkk);
127 void multilevel_pointer_parameters7(const volatile int ***iiiiii,
128 const int *const *const *jjjjjj);
129
multilevel_pointer_swap3()130 void multilevel_pointer_swap3() {
131 char ****qqqqqq;
132 char *const volatile **const *pppppp;
133 // Do not check.
134 multilevel_pointer_parameters4(qqqqqq, pppppp);
135
136 bool *****mmmmmm;
137 bool *volatile *const *const *const *nnnnnn;
138 // Do not check.
139 multilevel_pointer_parameters5(mmmmmm, nnnnnn);
140
141 double **kkkkkk;
142 char **llllll;
143 multilevel_pointer_parameters6(kkkkkk, llllll);
144
145 const volatile int ***jjjjjj;
146 const int *const *const *iiiiii;
147 multilevel_pointer_parameters7(jjjjjj, iiiiii);
148 }
149
150 // Test cases for multidimesional arrays.
151 void multilevel_array_parameters(int pppppp[2][2][2], const int qqqqqq[][2][2]);
152
153 void multilevel_array_parameters2(int (*mmmmmm)[2][2], int nnnnnn[9][2][23]);
154
155 void multilevel_array_parameters3(int (*eeeeee)[2][2], int (&ffffff)[1][2][2]);
156
157 void multilevel_array_parameters4(int (*llllll)[2][2], int kkkkkk[2][2]);
158
159 void multilevel_array_parameters5(int iiiiii[2][2], char jjjjjj[2][2]);
160
161 void multilevel_array_parameters6(int (*bbbbbb)[2][2], int cccccc[1][2][2]);
162
multilevel_array_swap()163 void multilevel_array_swap() {
164 int qqqqqq[1][2][2];
165 int pppppp[][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}}; // int [2][2][2]
166 multilevel_array_parameters(qqqqqq, pppppp);
167 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'qqqqqq' (passed to 'pppppp') looks like it might be swapped with the 2nd, 'pppppp' (passed to 'qqqqqq')
168
169 int(*nnnnnn)[2][2];
170 int mmmmmm[9][2][23];
171 // Do not check, array sizes has to match in every dimension, except the first.
172 multilevel_array_parameters2(nnnnnn, mmmmmm);
173
174 int ffffff[][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}}; // int [2][2][2]
175 int eeeeee[1][2][2] = {{{1, 2}, {1, 2}}}; // int [1][2][2]
176 // Do not check, for array references, size has to match in every dimension.
177 multilevel_array_parameters3(ffffff, eeeeee);
178
179 int kkkkkk[2][2][2];
180 int(*llllll)[2];
181 // Do not check, argument dimensions differ.
182 multilevel_array_parameters4(kkkkkk, llllll);
183
184 int jjjjjj[2][2];
185 char iiiiii[2][2];
186 // Do not check, array element types differ.
187 multilevel_array_parameters5(jjjjjj, iiiiii);
188
189 int t[][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}}; // int [2][2][2]
190 int(*cccccc)[2][2] = t; // int (*)[2][2]
191 int bbbbbb[][2][2] = {{{1, 2}, {1, 2}}}; // int [1][2][2]
192 multilevel_array_parameters6(cccccc, bbbbbb);
193 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'bbbbbb') looks like it might be swapped with the 2nd, 'bbbbbb' (passed to 'cccccc')
194 }
195
multilevel_array_swap2()196 void multilevel_array_swap2() {
197 int qqqqqq[2][2][2];
198 const int pppppp[][2][2] = {{{1, 2}, {1, 2}}, {{1, 2}, {1, 2}}};
199 // Do not check, pppppp is const and cannot bind to an array with nonconst elements.
200 multilevel_array_parameters(qqqqqq, pppppp);
201 }
202
203 // Complex test case.
204 void multilevel_pointer_array_parameters(const int(*const (*volatile const (*const (*const (*const &aaaaaa)[1])[32])[4])[3][2][2]), const int(*const (*volatile const (*const (*const (*&bbbbbb)[1])[32])[4])[3][2][2]));
205
multilevel_pointer_array_swap()206 void multilevel_pointer_array_swap() {
207 const int(
208 *const(*volatile const(*const(*const(*aaaaaa)[1])[32])[4])[3][2][2]);
209 const int(
210 *const(*volatile const(*const(*const(*bbbbbb)[1])[32])[4])[3][2][2]);
211 multilevel_pointer_array_parameters(bbbbbb, aaaaaa);
212 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'bbbbbb' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')
213 }
214
215 enum class numbers_scoped { one,
216 two };
217
218 // Test cases for arithmetic types.
219 void arithmetic_type_parameters(float vvvvvv, int wwwwww);
220 void arithmetic_type_parameters2(numbers_scoped vvvvvv, int wwwwww);
221
arithmetic_types_swap1()222 void arithmetic_types_swap1() {
223 bool wwwwww;
224 float vvvvvv;
225 arithmetic_type_parameters(wwwwww, vvvvvv);
226 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'wwwwww' (passed to 'vvvvvv') looks like it might be swapped with the 2nd, 'vvvvvv' (passed to 'wwwwww')
227 }
228
arithmetic_types_swap3()229 void arithmetic_types_swap3() {
230 char wwwwww;
231 unsigned long long int vvvvvv;
232 arithmetic_type_parameters(wwwwww, vvvvvv);
233 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'wwwwww' (passed to 'vvvvvv') looks like it might be swapped with the 2nd, 'vvvvvv' (passed to 'wwwwww')
234 }
235
arithmetic_types_swap4()236 void arithmetic_types_swap4() {
237 enum numbers { one,
238 two };
239 numbers wwwwww = numbers::one;
240 int vvvvvv;
241 arithmetic_type_parameters(wwwwww, vvvvvv);
242 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'wwwwww' (passed to 'vvvvvv') looks like it might be swapped with the 2nd, 'vvvvvv' (passed to 'wwwwww')
243 }
244
arithmetic_types_swap5()245 void arithmetic_types_swap5() {
246 wchar_t vvvvvv;
247 float wwwwww;
248 arithmetic_type_parameters(wwwwww, vvvvvv);
249 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'wwwwww' (passed to 'vvvvvv') looks like it might be swapped with the 2nd, 'vvvvvv' (passed to 'wwwwww')
250 }
251
arithmetic_types_swap6()252 void arithmetic_types_swap6() {
253 wchar_t vvvvvv;
254 numbers_scoped wwwwww = numbers_scoped::one;
255 // Do not check, numers is a scoped enum type.
256 arithmetic_type_parameters2(wwwwww, vvvvvv);
257 }
258
259 // Base, derived
260 class TestClass {
261 public:
thisFunction(int integerParam,int thisIsPARAM)262 void thisFunction(int integerParam, int thisIsPARAM) {}
263 };
264
265 class DerivedTestClass : public TestClass {};
266
267 void base_derived_pointer_parameters(TestClass *aaaaaa,
268 DerivedTestClass *bbbbbb);
269
base_derived_swap1()270 void base_derived_swap1() {
271 TestClass *bbbbbb;
272 DerivedTestClass *aaaaaa;
273 // Do not check, because TestClass does not convert implicitly to DerivedTestClass.
274 base_derived_pointer_parameters(bbbbbb, aaaaaa);
275 }
276
base_derived_swap2()277 void base_derived_swap2() {
278 DerivedTestClass *bbbbbb, *aaaaaa;
279 // Check for swapped arguments, DerivedTestClass converts to TestClass implicitly.
280 base_derived_pointer_parameters(bbbbbb, aaaaaa);
281 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'bbbbbb' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')
282 }
283
284 class PrivateDerivedClass : private TestClass {};
285
286 void private_derived_pointer_parameters(TestClass *aaaaaa, PrivateDerivedClass *bbbbbb);
287
private_base_swap1()288 void private_base_swap1() {
289 TestClass *bbbbbb;
290 PrivateDerivedClass *aaaaaa;
291 private_derived_pointer_parameters(bbbbbb, aaaaaa);
292 }
293
294 // Multilevel inheritance
295 class DerivedOfDerivedTestClass : public DerivedTestClass {};
296
multi_level_inheritance_swap()297 void multi_level_inheritance_swap() {
298 DerivedOfDerivedTestClass *aaaaaa, *bbbbbb;
299 // Check for swapped arguments. Derived classes implicitly convert to their base.
300 base_derived_pointer_parameters(
301 bbbbbb, aaaaaa);
302 // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: 1st argument 'bbbbbb' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')
303 }
304
305 // Tests for function pointer swaps
306 void funct_ptr_params(double (*ffffff)(int, int), double (*gggggg)(int, int));
307 void funct_ptr_params(double (*ffffff)(int, int), int (*gggggg)(int, int));
308
ffffff(int a,int b)309 double ffffff(int a, int b) { return 0; }
gggggg(int a,int b)310 double gggggg(int a, int b) { return 0; }
311
funtionc_ptr_params_swap()312 void funtionc_ptr_params_swap() {
313 funct_ptr_params(gggggg, ffffff);
314 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'gggggg' (passed to 'ffffff') looks like it might be swapped with the 2nd, 'ffffff' (passed to 'gggggg')
315 }
316
fffff(int a,int b)317 int fffff(int a, int b) { return 0; }
318
function_ptr_swap2()319 void function_ptr_swap2() {
320 // Do not check, because the function `ffffff` cannot convert to a function
321 // with prototype: double(int,int).
322 funct_ptr_params(gggggg, fffff);
323 }
324
325 // Paraphrased example from Z3 (src/qe/qe_arrays.cpp) which originally produced
326 // a false positive. Operator() calls should ignore the called object
327 // "argument".
328 struct type1;
329 struct type2;
330 struct type3;
331
332 struct callable1 {
operator ()callable1333 void operator()(type1 &mdl, type2 &arr_vars, type3 &fml, type2 &aux_vars) const {}
334 };
335
336 struct callable2 {
operator ()callable2337 void operator()(type1 &mdl, type2 &arr_vars, type3 &fml, type2 &aux_vars,
338 bool reduce_all_selects) const {
339 (void)reduce_all_selects;
340 callable1 pe;
341 pe(mdl, arr_vars, fml, aux_vars);
342 // NO-WARN: Argument and parameter names match perfectly, "pe" should be
343 // ignored!
344 }
345 };
346
347 struct binop_t {};
348
operator +(const binop_t & lhs,const binop_t & rhs)349 binop_t operator+(const binop_t &lhs, const binop_t &rhs) { return lhs; }
operator <(const binop_t & lhs,const binop_t & rhs)350 bool operator<(const binop_t &lhs, const binop_t &rhs) { return true; }
operator >(const binop_t & aaaaaa,const binop_t & bbbbbb)351 bool operator>(const binop_t &aaaaaa, const binop_t &bbbbbb) { return false; }
352
binop_test()353 void binop_test() {
354 // NO-WARN: Binary operators are ignored.
355 binop_t lhs, rhs;
356 if (lhs + rhs < rhs)
357 return;
358
359 if (operator<(rhs, lhs))
360 return;
361
362 binop_t aaaaaa, cccccc;
363 if (operator>(cccccc, aaaaaa))
364 return;
365 }
366
recursion(int aaaa,int bbbb)367 int recursion(int aaaa, int bbbb) {
368 if (aaaa)
369 return 0;
370
371 int cccc = 0;
372 return recursion(bbbb, cccc);
373 // NO-WARN: Recursive calls usually shuffle with arguments and we ignore those.
374 }
375
pass_by_copy(binop_t xxxx,binop_t yyyy)376 void pass_by_copy(binop_t xxxx, binop_t yyyy) {}
377
378 // Paraphrased example from LLVM's code (lib/Analysis/InstructionSimplify.cpp)
379 // that generated a false positive.
380 struct value;
381 enum opcode { Foo,
382 Bar };
SimplifyRightShift(opcode Opcode,value * Op0,value * Op1,bool isExact,const type1 & Q,unsigned MaxRecurse)383 static value *SimplifyRightShift(
384 opcode Opcode, value *Op0, value *Op1, bool isExact,
385 const type1 &Q, unsigned MaxRecurse) {}
SimplifyLShrInst(value * Op0,value * Op1,bool isExact,const type1 & Q,unsigned MaxRecurse)386 static value *SimplifyLShrInst(value *Op0, value *Op1, bool isExact,
387 const type1 &Q, unsigned MaxRecurse) {
388 if (value *V = SimplifyRightShift(Foo, Op0, Op1, isExact, Q, MaxRecurse))
389 return V;
390 // NO-WARN: Argument names perfectly match parameter names, sans the enum.
391
392 return nullptr;
393 }
394
has_unnamed(int aaaaaa,int)395 void has_unnamed(int aaaaaa, int) {}
396
main()397 int main() {
398 // Equality test.
399 int aaaaaa, cccccc = 0;
400 foo_1(cccccc, aaaaaa);
401 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')
402
403 binop_t xxxx, yyyy;
404 pass_by_copy(yyyy, xxxx);
405 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'yyyy' (passed to 'xxxx') looks like it might be swapped with the 2nd, 'xxxx' (passed to 'yyyy')
406
407 // Abbreviation test.
408 int src = 0;
409 foo_2(aaaaaa, src);
410 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'aaaaaa' (passed to 'source') looks like it might be swapped with the 2nd, 'src' (passed to 'aaaaaa')
411
412 // Levenshtein test.
413 int aaaabb = 0;
414 foo_1(cccccc, aaaabb);
415 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaabb' (passed to 'bbbbbb')
416
417 // Prefix test.
418 int aaaa = 0;
419 foo_1(cccccc, aaaa);
420 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaa' (passed to 'bbbbbb')
421
422 // Suffix test.
423 int urce = 0;
424 foo_2(cccccc, urce);
425 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'source') looks like it might be swapped with the 2nd, 'urce' (passed to 'aaaaaa')
426
427 // Substring test.
428 int ourc = 0;
429 foo_2(cccccc, ourc);
430 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'source') looks like it might be swapped with the 2nd, 'ourc' (passed to 'aaaaaa')
431
432 // Jaro-Winkler test.
433 int iPonter = 0;
434 foo_4(cccccc, iPonter);
435 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'pointer') looks like it might be swapped with the 2nd, 'iPonter' (passed to 'aaaaaa')
436
437 // Dice test.
438 int aaabaa = 0;
439 foo_1(cccccc, aaabaa);
440 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaabaa' (passed to 'bbbbbb')
441
442 // Variadic function test.
443 int bbbbbb = 0;
444 foo_5(src, bbbbbb, cccccc, aaaaaa); // Should pass.
445 foo_5(cccccc, bbbbbb, aaaaaa, src);
446 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 3rd, 'aaaaaa' (passed to 'cccccc')
447
448 // Test function with default argument.
449 foo_7(src, bbbbbb, cccccc, aaaaaa);
450 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'src' (passed to 'aaaaaa') looks like it might be swapped with the 4th, 'aaaaaa' (passed to 'ffffff')
451
452 foo_7(cccccc, bbbbbb, aaaaaa, src);
453 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'cccccc' (passed to 'aaaaaa') looks like it might be swapped with the 3rd, 'aaaaaa' (passed to 'cccccc')
454
455 int ffffff = 0;
456 foo_7(ffffff, bbbbbb, cccccc); // NO-WARN: Even though 'ffffff' is passed to 'aaaaaa' and there is a 4th parameter 'ffffff', there isn't a **swap** here.
457
458 int frobble1 = 1, frobble2 = 2;
459 foo_8(frobble2, frobble1);
460 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'frobble2' (passed to 'frobble1') looks like it might be swapped with the 2nd, 'frobble1' (passed to 'frobble2')
461
462 int bar1 = 1, bar2 = 2;
463 foo_8(bar2, bar1); // NO-WARN.
464
465 // Type match
466 bool dddddd = false;
467 int eeeeee = 0;
468 auto szam = 0;
469 foo_6(eeeeee, dddddd);
470 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'eeeeee' (passed to 'dddddd') looks like it might be swapped with the 2nd, 'dddddd' (passed to 'eeeeee')
471 foo_1(szam, aaaaaa);
472 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 1st argument 'szam' (passed to 'aaaaaa') looks like it might be swapped with the 2nd, 'aaaaaa' (passed to 'bbbbbb')
473
474 // Test lambda.
475 auto testMethod = [&](int method, int randomParam) { return 0; };
476 int method = 0;
477 testMethod(method, 0); // Should pass.
478
479 // Member function test.
480 TestClass test;
481 int integ, thisIsAnArg = 0;
482 test.thisFunction(integ, thisIsAnArg); // Should pass.
483
484 has_unnamed(1, bbbbbb);
485
486 return 0;
487 }
488