[clang-tidy] Suppress reports to patternedly named parameters in 'bugprone-easily-swappable-parameters'

[whisperity]

Summary

While the original check's (D69560) purpose is to identify potentially dangerous functions based on the parameter types (as identifier names do not mean anything when it comes to the language rules), unfortunately, such a plain interface check rule can be incredibly noisy. While the previous "filtering heuristic" in D78652 is able to find many similar usages, there is an entire class of parameters that should not be warned about very easily mixed by that check: parameters that have a name and their name follows a pattern, e.g. text1, text2, text3, .... [1]

This patch implements a simple, but powerful rule, that allows us to detect such cases and ensure that no warnings are emitted for parameter sequences that follow a pattern, even if their types allow for them to be potentially mixed at a call site.

Given a threshold k, warnings about two parameters are filtered from the result set if the names of the parameters are either prefixes or suffixes of each other, with at most k letters difference on the non-common end. (Assuming that the names themselves are at least k long.)

The above text1, text2 is an example of this. (Live finding from Xerces.)
LHS and RHS are also fitting the bill here. (Live finding from... virtually any project.)
So does Qmat, Tmat, Rmat. (Live finding from I think OpenCV.)

On average, 15% reduction in findings were achieved with this feature turned on.

Similarly to the other filtering patch on the "relatedness modelling", this option is implemented as a check option, NamePrefixSuffixSilenceDissimilarityTreshold. If 0, the heuristic is turned off. Defaults to 1, i.e. a single letter difference ("pattern") on either end of the parameter name suffice for silence. This is the most reasonable default.

---

[1] It has been identified before by other research that such patterned names carry no viable information and such names are useless for a name-based analysis where argument vs. parameter names are contrasted with one another. [Rice2017]

[Rice2017]: Andrew Rice, et al.: Detecting argument selection defects. In: Proceedings of the ACM on Programming Languages, 1, pp. 104:1-104:23, 2017.

[whisperity]

• [NFC] Realised I forgot to add the new option to the check's documentation. This is fixed now.

[Eugene.Zelenko]

Please mention new option in Release Notes.

clang-tools-extra/docs/clang-tidy/checks/bugprone-easily-swappable-parameters.rst

89

Please use single back-ticks for option values. Same below.

[whisperity]

In D97297#2583391, @Eugene.Zelenko wrote:

Please mention new option in Release Notes.

The base check is not yet accepted or in. I plan to land the entire thing in one go once everything is accepted because a partial landing would result in a useless check (in one way or another).

clang-tools-extra/docs/clang-tidy/checks/bugprone-easily-swappable-parameters.rst

89

All values (including above the `_Bool and such, or only the numeric constants? The LHS and RHS` below are examples of source code, not a valid value for the option.

[Eugene.Zelenko]

clang-tools-extra/docs/clang-tidy/checks/bugprone-easily-swappable-parameters.rst

89

All option values.

[whisperity]

• [NFC] Reformat the documentation so option values are in single backticks.

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

364–365

Should we be checking that .size() - N doesn't cause wraparound?

371

Same question here as above.

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

364–365

Wraparound as in underflow? Like 2 - 8 becoming multiple millions? The incoming strings are padded to the common length.

take_xxx won't let you go out of bounds, even if the parameter is greater than the string's length. It will just silently return the entire string.

[aaron.ballman]

LGTM!

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

364–365

Wraparound as in underflow? Like 2 - 8 becoming multiple millions? The incoming strings are padded to the common length.

They are, but I didn't see anything checking that Threshhold (which gets passed as N) isn't larger than the common string length.

take_xxx won't let you go out of bounds, even if the parameter is greater than the string's length. It will just silently return the entire string.

Aha, that's the important bit, thanks for verifying that this is safe!

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

364–365

Nevertheless I'll clarify this, specifically because I have to make sure (I was thinking for a few minutes then realised the !S1Prefix.empty() is actually making sure of this...) that if you got parameter names of length 1 (let's say) and a threshold of 1, it really shouldn't say that A and B are "related" because the common prefix is "" and the non-common end differs in one character, A vs. B.

384

@aaron.ballman I think I'll do something like if (BiggerLength < Threshold) return false;, how does that sound? The comparison is moot in that case, imagine having strings of 2 and 4, padded to 4, with a threshold of 6, for example.

That way even if someone accidentally makes StringRef overflow the buffer, we'll be safe on the call paths we have here.

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

384

I think that'd make the behavior much more obvious, but should that be <=?

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

384

No, because being = to the threshold means that the common prefix/suffix is empty string. It'd make variables such as "A" and "X" deemed related. Generally not something we want, because that's too broad of an assumption that they are "meant to be used together". (Generally you shouldn't name variables like so, but still...)

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

384

Ah, that's a good point, thank you!

[whisperity]

• Made a precondition check explicit, and added an early return to not evaluate a case where it would return false anyways...

[whisperity]

NFC: Rebase & update.

While this patch conceptually only depends on D69560, the diff itself has become linear during the code review and subsequent updates, and as such, must be applied on top of D78652.

[whisperity]

NC Rebase and buildbot trigger.

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.h

public:
   const std::size_t MinimumLength;
 
   /// The parameter names (as written in the source text) to be ignored.
   const std::vector<std::string> IgnoredParameterNames;
 
   /// The parameter typename suffixes (as written in the source code) to be
   /// ignored.
   const std::vector<std::string> IgnoredParameterTypeSuffixes;
+
+  /// The number of characters two parameter names might be dissimilar at
+  /// either end for the report about the parameters to be silenced.
+  /// E.g. the names "LHS" and "RHS" are 1-dissimilar suffixes of each other,
+  /// while "Text1" and "Text2" are 1-dissimilar prefixes of each other.
+  const std::size_t NamePrefixSuffixSilenceDissimilarityTreshold;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EASILYSWAPPABLEPARAMETERSCHECK_H

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

 #include "clang/Lex/Lexer.h"
 
 #define DEBUG_TYPE "EasilySwappableParametersCheck"
 #include "llvm/Support/Debug.h"
 
 namespace optutils = clang::tidy::utils::options;
 
 /// The default value for the MinimumLength check option.
-static constexpr unsigned DefaultMinimumLength = 2;
+static constexpr std::size_t DefaultMinimumLength = 2;
 
 /// The default value for ignored parameter names.
 static const std::string DefaultIgnoredParameterNames =
     optutils::serializeStringList({"\"\"", "iterator", "Iterator", "begin",
                                    "Begin", "end", "End", "first", "First",
                                    "last", "Last", "lhs", "LHS", "rhs", "RHS"});
 
 /// The default value for ignored parameter type suffixes.
optutils::serializeStringList({"bool",
                                    "ConstIterator",
                                    "RandomIt",
                                    "randomit",
                                    "random_iterator",
                                    "ReverseIt",
                                    "reverse_iterator",
                                    "reverse_const_iterator"});
 
+/// The default value for the NamePrefixSuffixSilenceDissimilarityTreshold
+/// check option.
+static constexpr std::size_t
+    DefaultNamePrefixSuffixSilenceDissimilarityTreshold = 1;
+
 #ifndef NDEBUG
 
 template <std::size_t Width>
 static inline std::string formatBitsImpl(std::size_t Num) {
   constexpr std::size_t WidthWithPadding = Width + (Width / 4);
   char S[WidthWithPadding];
   for (std::size_t CurPos = 0; CurPos < WidthWithPadding; ++CurPos) {
     if (CurPos % 5 == 0) {

 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 using TheCheck = EasilySwappableParametersCheck;
 
 namespace filter {
 static bool isIgnoredParameter(const TheCheck &Check, const ParmVarDecl *Node);
+static bool prefixSuffixCoverUnderThreshold(std::size_t Threshold,
+                                            StringRef Str1, StringRef Str2);
 } // namespace filter
 
 namespace model {
 
 /// The language features involved in allowing the mix between two parameters.
 enum MixFlags : unsigned char {
   MIX_Invalid = 0, //< Sentinel bit pattern. DO NOT USE!
 
static MixableParameterRange modelMixingRange(const TheCheck &Check,
   const ASTContext &Ctx = FD->getASTContext();
 
   MixableParameterRange Ret;
   // A parameter at index 'StartIndex' had been trivially "checked".
   Ret.NumParamsChecked = 1;
 
   for (std::size_t I = StartIndex + 1; I < NumParams; ++I) {
     const ParmVarDecl *Ith = FD->getParamDecl(I);
-    LLVM_DEBUG(llvm::dbgs() << "Check param #" << I << "...\n");
-
+    StringRef ParamName = Ith->getName();
+    LLVM_DEBUG(llvm::dbgs()
+               << "Check param #" << I << " '" << ParamName << "'...\n");
     if (filter::isIgnoredParameter(Check, Ith)) {
       LLVM_DEBUG(llvm::dbgs() << "Param #" << I << " is ignored. Break!\n");
       break;
     }
 
+    StringRef PrevParamName = FD->getParamDecl(I - 1)->getName();
+    if (!ParamName.empty() && !PrevParamName.empty() &&
+        filter::prefixSuffixCoverUnderThreshold(
+            Check.NamePrefixSuffixSilenceDissimilarityTreshold, PrevParamName,
+            ParamName)) {
+      LLVM_DEBUG(llvm::dbgs() << "Parameter '" << ParamName
+                              << "' follows a pattern with previous parameter '"
+                              << PrevParamName << "'. Break!\n");
+      break;
+    }
+
     // Now try to go forward and build the range of [Start, ..., I, I + 1, ...]
     // parameters that can be messed up at a call site.
     MixableParameterRange::MixVector MixesOfIth;
     for (std::size_t J = StartIndex; J < I; ++J) {
       const ParmVarDecl *Jth = FD->getParamDecl(J);
       LLVM_DEBUG(llvm::dbgs()
                  << "Check mix of #" << J << " against #" << I << "...\n");
 
if (llvm::any_of(Check.IgnoredParameterTypeSuffixes,
                      })) {
       LLVM_DEBUG(llvm::dbgs() << "\tType suffix ignored.\n");
       return true;
     }
   }
 
   return false;
 }
+
+static void padStringAtEnd(SmallVectorImpl<char> &Str, std::size_t ToLen) {
+  while (Str.size() < ToLen)
+    Str.emplace_back('\0');
+}
+
+static void padStringAtBegin(SmallVectorImpl<char> &Str, std::size_t ToLen) {
+  while (Str.size() < ToLen)
+    Str.insert(Str.begin(), '\0');
+}
+
+static bool isCommonPrefixWithoutSomeCharacters(std::size_t N, StringRef S1,
+                                                StringRef S2) {
+  StringRef S1Prefix = S1.take_front(S1.size() - N),
+            S2Prefix = S2.take_front(S2.size() - N);
+  return S1Prefix == S2Prefix && !S1Prefix.empty();
+}
+
+static bool isCommonSuffixWithoutSomeCharacters(std::size_t N, StringRef S1,
+                                                StringRef S2) {
+  StringRef S1Suffix = S1.take_back(S1.size() - N),
+            S2Suffix = S2.take_back(S2.size() - N);
+  return S1Suffix == S2Suffix && !S1Suffix.empty();
+}
+
+/// Returns whether the two strings are prefixes or suffixes of each other with
+/// at most Threshold characters differing on the non-common end.
+static bool prefixSuffixCoverUnderThreshold(std::size_t Threshold,
+                                            StringRef Str1, StringRef Str2) {
+  if (Threshold == 0)
+    return false;
+
+  // Pad the two strings to the longer length.
+  std::size_t BiggerLength = std::max(Str1.size(), Str2.size());
+  SmallString<32> S1PadE{Str1}, S2PadE{Str2};
+  padStringAtEnd(S1PadE, BiggerLength);
+  padStringAtEnd(S2PadE, BiggerLength);
+
+  if (isCommonPrefixWithoutSomeCharacters(
+          Threshold, StringRef{S1PadE.begin(), BiggerLength},
+          StringRef{S2PadE.begin(), BiggerLength}))
+    return true;
+
+  SmallString<32> S1PadB{Str1}, S2PadB{Str2};
+  padStringAtBegin(S1PadB, BiggerLength);
+  padStringAtBegin(S2PadB, BiggerLength);
+
+  if (isCommonSuffixWithoutSomeCharacters(
+          Threshold, StringRef{S1PadB.begin(), BiggerLength},
+          StringRef{S2PadB.begin(), BiggerLength}))
+    return true;
+
+  return false;
+}
 } // namespace filter
 
 /// Matches functions that have at least the specified amount of parameters.
 AST_MATCHER_P(FunctionDecl, parameterCountGE, unsigned, N) {
   return Node.getNumParams() >= N;
 }
 
 /// Matches *any* overloaded unary and binary operators.
EasilySwappableParametersCheck::EasilySwappableParametersCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       MinimumLength(clampMinimumLength(
           Options.get("MinimumLength", DefaultMinimumLength))),
       IgnoredParameterNames(optutils::parseStringList(
           Options.get("IgnoredParameterNames", DefaultIgnoredParameterNames))),
       IgnoredParameterTypeSuffixes(optutils::parseStringList(
           Options.get("IgnoredParameterTypeSuffixes",
-                      DefaultIgnoredParameterTypeSuffixes))) {}
+                      DefaultIgnoredParameterTypeSuffixes))),
+      NamePrefixSuffixSilenceDissimilarityTreshold(
+          Options.get("NamePrefixSuffixSilenceDissimilarityTreshold",
+                      DefaultNamePrefixSuffixSilenceDissimilarityTreshold)) {}
 
 void EasilySwappableParametersCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MinimumLength", MinimumLength);
   Options.store(Opts, "IgnoredParameterNames",
                 optutils::serializeStringList(IgnoredParameterNames));
   Options.store(Opts, "IgnoredParameterTypeSuffixes",
                 optutils::serializeStringList(IgnoredParameterTypeSuffixes));
+  Options.store(Opts, "NamePrefixSuffixSilenceDissimilarityTreshold",
+                NamePrefixSuffixSilenceDissimilarityTreshold);
 }
 
 void EasilySwappableParametersCheck::registerMatchers(MatchFinder *Finder) {
   const auto BaseConstraints = functionDecl(
       // Only report for definition nodes, as fixing the issues reported
       // requires the user to be able to change code.
       isDefinition(), parameterCountGE(MinimumLength),
       unless(isOverloadedUnaryOrBinaryOperator()));

clang-tools-extra/docs/clang-tidy/checks/bugprone-easily-swappable-parameters.rst

.. option:: IgnoredParameterTypeSuffixes
     `bool`, `It`, `Iterator`, `InputIt`, `ForwardIt`, `BidirIt`, `RandomIt`,
     `random_iterator`, `ReverseIt`, `reverse_iterator`,
     `reverse_const_iterator`, `RandomIt`, `random_iterator`, `ReverseIt`,
     `reverse_iterator`, `reverse_const_iterator`, `Const_Iterator`,
     `ConstIterator`.
     In addition, `_Bool` (but not `_bool`) is also part of the default value.
 
 
+.. option:: NamePrefixSuffixSilenceDissimilarityTreshold
+
+    The number of characters two parameter names might be different on *either*
+    the head or the tail end with the rest of the name the same so that the
+    warning about the two parameters are silenced.
+    Defaults to `1`.
+    Might be any positive integer.
+    If `0`, the filtering heuristic based on the parameters' names is turned
+    off.
+
+    This option can be used to silence warnings about parameters where the
+    naming scheme indicates that the order of those parameters do not matter.
+
+    For example, the parameters ``LHS`` and ``RHS`` are 1-dissimilar suffixes
+    of each other: ``L`` and ``R`` is the different character, while ``HS``
+    is the common suffix.
+    Similarly, parameters ``text1, text2, text3`` are 1-dissimilar prefixes
+    of each other, with the numbers at the end being the dissimilar part.
+    If the value is at least `1`, such cases will not be reported.
+
+
 Limitations
 -----------
 
 **This check is designed to check function signatures!**
 
 The check does not investigate functions that are generated by the compiler
 in a context that is only determined from a call site.
 These cases include variadic functions, functions in C code that do not have

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-ignore.cpp

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: "\"\";Foo;Bar"}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: "T"} \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: "T"}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 void ignoredUnnamed(int I, int, int) {} // NO-WARN: No >= 2 length of non-unnamed.
 
 void nothingIgnored(int I, int J) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: 2 adjacent parameters of 'nothingIgnored' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
 // CHECK-MESSAGES: :[[@LINE-2]]:25: note: the first parameter in the range is 'I'
 // CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in the range is 'J'

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-len2.cpp

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""} \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 #define assert(X) ((void)(X))
 
 void declaration(int Param, int Other); // NO-WARN: No chance to change this function.
 
 struct S {};
 

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-len3.cpp

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 3}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""} \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 int add(int Left, int Right) { return Left + Right; } // NO-WARN: Only 2 parameters.
 
 int magic(int Left, int Right, int X, int Y) { return 0; }
 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 4 adjacent parameters of 'magic' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
 // CHECK-MESSAGES: :[[@LINE-2]]:15: note: the first parameter in the range is 'Left'
 // CHECK-MESSAGES: :[[@LINE-3]]:43: note: the last parameter in the range is 'Y'

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-prefixsuffixname.cpp

+// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
+// RUN:   -config='{CheckOptions: [ \
+// RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 1} \
+// RUN:  ]}' --
+
+namespace std {
+struct string {};
+} // namespace std
+class Matrix {};
+
+void test1(int Foo, int Bar) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 2 adjacent parameters of 'test1' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
+// CHECK-MESSAGES: :[[@LINE-2]]:16: note: the first parameter in the range is 'Foo'
+// CHECK-MESSAGES: :[[@LINE-3]]:25: note: the last parameter in the range is 'Bar'
+
+void test2(int A, int B) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 2 adjacent parameters of 'test2' of similar type ('int')
+// CHECK-MESSAGES: :[[@LINE-2]]:16: note: the first parameter in the range is 'A'
+// CHECK-MESSAGES: :[[@LINE-3]]:23: note: the last parameter in the range is 'B'
+
+void test3(int Val1, int Val2) {} // NO-WARN.
+
+void test4(int ValA, int Valb) {} // NO-WARN.
+
+void test5(int Val1, int ValZ) {} // NO-WARN.
+
+void test6(int PValue, int QValue) {} // NO-WARN.
+
+void test7(std::string Astr, std::string Bstr) {} // NO-WARN.
+
+void test8(int Aladdin, int Alabaster) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 2 adjacent parameters of 'test8' of similar type ('int')
+// CHECK-MESSAGES: :[[@LINE-2]]:16: note: the first parameter in the range is 'Aladdin'
+// CHECK-MESSAGES: :[[@LINE-3]]:29: note: the last parameter in the range is 'Alabaster'
+
+void test9(Matrix Qmat, Matrix Rmat, Matrix Tmat) {} // NO-WARN.
+
+void test10(int Something, int Other, int Foo, int Bar1, int Bar2, int Baz, int Qux) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 4 adjacent parameters of 'test10' of similar type ('int') are
+// CHECK-MESSAGES: :[[@LINE-2]]:17: note: the first parameter in the range is 'Something'
+// CHECK-MESSAGES: :[[@LINE-3]]:52: note: the last parameter in the range is 'Bar1'
+//
+// CHECK-MESSAGES: :[[@LINE-5]]:58: warning: 3 adjacent parameters of 'test10' of similar type ('int') are
+// CHECK-MESSAGES: :[[@LINE-6]]:62: note: the first parameter in the range is 'Bar2'
+// CHECK-MESSAGES: :[[@LINE-7]]:81: note: the last parameter in the range is 'Qux'
+
+void test11(int Foobar, int Foo) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 2 adjacent parameters of 'test11' of similar type ('int')
+// CHECK-MESSAGES: :[[@LINE-2]]:17: note: the first parameter in the range is 'Foobar'
+// CHECK-MESSAGES: :[[@LINE-3]]:29: note: the last parameter in the range is 'Foo'

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters.c

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: "bool;MyBool;struct U;MAKE_LOGICAL_TYPE(int)"} \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: "bool;MyBool;struct U;MAKE_LOGICAL_TYPE(int)"}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' -- -x c
 
 #define bool _Bool
 #define true 1
 #define false 0
 
 typedef bool MyBool;