[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

177

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

177

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

177

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

1454–1455

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

1461

Same question here as above.

[whisperity]

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

1454–1455

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

1454–1455

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

1454–1455

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.

1474

@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

1474

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

[whisperity]

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

1474

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

1474

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:
   /// Whether to model implicit conversions "in full" (conditions apply)
   /// during analysis and consider types that are implicitly convertible to
   /// one another mixable.
   const bool ModelImplicitConversions;
 
   /// If enabled, diagnostics for parameters that are used together in a
   /// similar way are not emitted.
   const bool SuppressParametersUsedTogether;
+
+  /// 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

 
 /// The default value for the ModelImplicitConversions check option.
 static constexpr bool DefaultModelImplicitConversions = true;
 
 /// The default value for suppressing diagnostics about parameters that are
 /// used together.
 static constexpr bool DefaultSuppressParametersUsedTogether = true;
 
+/// The default value for the NamePrefixSuffixSilenceDissimilarityTreshold
+/// check option.
+static constexpr std::size_t
+    DefaultNamePrefixSuffixSilenceDissimilarityTreshold = 1;
+
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 using TheCheck = EasilySwappableParametersCheck;
 
 namespace filter {
 class SimilarlyUsedParameterPairSuppressor;
 
 static bool isIgnoredParameter(const TheCheck &Check, const ParmVarDecl *Node);
 static inline bool
 isSimilarlyUsedParameter(const SimilarlyUsedParameterPairSuppressor &Suppressor,
                          const ParmVarDecl *Param1, const ParmVarDecl *Param2);
+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 class MixFlags : unsigned char {
   Invalid = 0, //< Sentinel bit pattern. DO NOT USE!
 
static MixableParameterRange modelMixingRange(
   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");
 

 static constexpr std::size_t SmallDataStructureSize = 4;
 
 template <typename T, std::size_t N = SmallDataStructureSize>
 using ParamToSmallSetMap =
     llvm::DenseMap<const ParmVarDecl *, llvm::SmallSet<T, N>>;
 
 /// Returns whether the sets mapped to the two elements in the map have at
 /// least one element in common.
 template <typename MapTy, typename ElemTy>
 bool lazyMapOfSetsIntersectionExists(const MapTy &Map, const ElemTy &E1,
                                      const ElemTy &E2) {
   auto E1Iterator = Map.find(E1);
   auto E2Iterator = Map.find(E2);
   if (E1Iterator == Map.end() || E2Iterator == Map.end())
     return false;
 
   for (const auto &E1SetElem : E1Iterator->second)
     if (llvm::find(E2Iterator->second, E1SetElem) != E2Iterator->second.end())
       return true;
 
   return false;
 }
 
 /// Implements the heuristic that marks two parameters related if there is
 /// a usage for both in the same strict expression subtree. A strict
 /// expression subtree is a tree which only includes Expr nodes, i.e. no
 /// Stmts and no Decls.
 class AppearsInSameExpr : public RecursiveASTVisitor<AppearsInSameExpr> {
   using Base = RecursiveASTVisitor<AppearsInSameExpr>;
 
   const FunctionDecl *FD;
   const Expr *CurrentExprOnlyTreeRoot = nullptr;
   llvm::DenseMap<const ParmVarDecl *,
                  llvm::SmallPtrSet<const Expr *, SmallDataStructureSize>>
       ParentExprsForParamRefs;
 
 public:

 // (This function hoists the call to operator() of the wrapper, so we do not
 // need to define the previous class at the top of the file.)
 static inline bool
 isSimilarlyUsedParameter(const SimilarlyUsedParameterPairSuppressor &Suppressor,
                          const ParmVarDecl *Param1, const ParmVarDecl *Param2) {
   return Suppressor(Param1, Param2);
 }
 
+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) {
+  assert(S1.size() >= N && S2.size() >= N);
+  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) {
+  assert(S1.size() >= N && S2.size() >= N);
+  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());
+
+  if (BiggerLength <= Threshold)
+    // If the length of the strings is still smaller than the threshold, they
+    // would be covered by an empty prefix/suffix with the rest differing.
+    // (E.g. "A" and "X" with Threshold = 1 would mean we think they are
+    // similar and do not warn about them, which is a too eager assumption.)
+    return false;
+
+  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.
: ClangTidyCheck(Name, Context),
       IgnoredParameterTypeSuffixes(optutils::parseStringList(
           Options.get("IgnoredParameterTypeSuffixes",
                       DefaultIgnoredParameterTypeSuffixes))),
       QualifiersMix(Options.get("QualifiersMix", DefaultQualifiersMix)),
       ModelImplicitConversions(Options.get("ModelImplicitConversions",
                                            DefaultModelImplicitConversions)),
       SuppressParametersUsedTogether(
           Options.get("SuppressParametersUsedTogether",
-                      DefaultSuppressParametersUsedTogether)) {}
+                      DefaultSuppressParametersUsedTogether)),
+      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, "QualifiersMix", QualifiersMix);
   Options.store(Opts, "ModelImplicitConversions", ModelImplicitConversions);
   Options.store(Opts, "SuppressParametersUsedTogether",
                 SuppressParametersUsedTogether);
+  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

* The parameters are further passed to the same function to the same
         called with the parameters, it will still be regarded as
         "same function".
 
     * The same member field is accessed, or member method is called of the
       two parameters, e.g. ``a.foo()`` and ``b.foo()``.
     * Separate ``return`` statements return either of the parameters on
       different code paths.
 
+.. 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.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// 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-implicit-qualifiers.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.QualifiersMix, value: 1}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 void numericAndQualifierConversion(int I, const double CD) { numericAndQualifierConversion(CD, I); }
 // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'numericAndQualifierConversion' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters]
 // CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'I'
 // CHECK-MESSAGES: :[[@LINE-3]]:56: note: the last parameter in the range is 'CD'
 // CHECK-MESSAGES: :[[@LINE-4]]:43: note: 'int' and 'const double' parameters accept and bind the same kind of values
 // CHECK-MESSAGES: :[[@LINE-5]]:43: note: 'int' and 'const double' may be implicitly converted: 'int' -> 'const double' (as 'double'), 'const double' (as 'double') -> 'int'

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-implicits.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: ""}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 void implicitDoesntBreakOtherStuff(int A, int B) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'implicitDoesntBreakOtherStuff' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
 // CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'A'
 // CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'B'
 
 void arrayAndPtr1(int *IP, int IA[]) { arrayAndPtr1(IA, IP); }

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

 // RUN: %check_clang_tidy -std=c++17 %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.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 void implicitDoesntBreakOtherStuff(int A, int B) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'implicitDoesntBreakOtherStuff' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
 // CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'A'
 // CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'B'
 
 void arrayAndPtr1(int *IP, int IA[]) { arrayAndPtr1(IA, IP); }

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.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 namespace std {
 using size_t = decltype(sizeof(int));
 } // namespace std
 
 #define assert(X) ((void)(X))
 

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.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// 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.QualifiersMix, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// 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-qualifiermixing.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.QualifiersMix, value: 1}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 typedef int MyInt1;
 typedef int MyInt2;
 using CInt = const int;
 using CMyInt1 = const MyInt1;
 using CMyInt2 = const MyInt2;
 

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-relatedness.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: ""}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 1} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 1}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' -- -x c
 
 int myprint();
 int add(int X, int Y);
 
 void notRelated(int A, int B) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: 2 adjacent parameters of 'notRelated' of similar type ('int')
 // CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in the range is 'A'

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-relatedness.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.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 1} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 1}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' --
 
 namespace std {
 template <typename T>
 T max(const T &A, const T &B);
 } // namespace std
 
 bool coin();

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.QualifiersMix, value: 0}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.SuppressParametersUsedTogether, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.NamePrefixSuffixSilenceDissimilarityTreshold, value: 0} \
 // RUN:  ]}' -- -x c
 
 #define bool _Bool
 #define true 1
 #define false 0
 
 typedef bool MyBool;