[clang-tidy] readability-inconsistent-declaration-parameter-name: accept approximate name matches.

[sammccall]

Summary

The goal is to reduce false positives when the difference is intentional, like:

foo(StringRef name);
foo(StringRef name_ref) {

string name = cleanup(name_ref);
...

}

Or semantically unimportant, like:
foo(StringRef full_name);
foo(StringRef name) { ... }

There are other matching names we won't recognise (e.g. syns vs synonyms) but
this catches many that we see in practice, and gives people a systematic
workaround.

[sammccall]

Make strictness (old behavior) available as an option.

[sammccall]

(First foray into clang-tidy, not sure what I'm doing...)

[hokein]

clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

96

I have a concern that this is too general -- it will cover the middle case like inBFix in you test, which seems not happen often in the real world.

Two important cases are prefix and suffix, maybe just restrict to these two cases?

[sammccall]

Restrict matches to prefix/suffix, not substring.

[hokein]

LGTM.

clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

bool checkIfFixItHintIsApplicable(
   if (OriginalDeclaration->getTemplatedKind() ==
       FunctionDecl::TK_FunctionTemplateSpecialization)
     return false;
 
   // Other cases seem OK to allow replacements.
   return true;
 }
 
+// We allow two names if one is a substring of the other, ignoring case.
+// Important special case: this is true if either parameter has no name!
+bool nameMatch(StringRef L, StringRef R) {
+  return L.contains_lower(R) || R.contains_lower(L);
+}
+
 DifferingParamsContainer
 findDifferingParamsInDeclaration(const FunctionDecl *ParameterSourceDeclaration,
                                  const FunctionDecl *OtherDeclaration,
                                  const FunctionDecl *OriginalDeclaration) {
   DifferingParamsContainer DifferingParams;
 
   auto SourceParamIt = ParameterSourceDeclaration->param_begin();
   auto OtherParamIt = OtherDeclaration->param_begin();
 
   while (SourceParamIt != ParameterSourceDeclaration->param_end() &&
          OtherParamIt != OtherDeclaration->param_end()) {
     auto SourceParamName = (*SourceParamIt)->getName();
     auto OtherParamName = (*OtherParamIt)->getName();
 
     // FIXME: Provide a way to extract commented out parameter name from comment
     // next to it.
-    if (!SourceParamName.empty() && !OtherParamName.empty() &&
-        SourceParamName != OtherParamName) {
+    if (!nameMatch(SourceParamName, OtherParamName)) {
       SourceRange OtherParamNameRange =
           DeclarationNameInfo((*OtherParamIt)->getDeclName(),
                               (*OtherParamIt)->getLocation())
               .getSourceRange();
 
       bool GenerateFixItHint = checkIfFixItHintIsApplicable(
           ParameterSourceDeclaration, *SourceParamIt, OriginalDeclaration);
 

test/clang-tidy/readability-inconsistent-declaration-parameter-name.cpp

 // RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- -- -std=c++11 -fno-delayed-template-parsing
 
 void consistentFunction(int a, int b, int c);
 void consistentFunction(int a, int b, int c);
+void consistentFunction(int prefixA, int inBFix, int cSuffix);
+void consistentFunction(int a, int b, int c);
 void consistentFunction(int a, int b, int /*c*/);
 void consistentFunction(int /*c*/, int /*c*/, int /*c*/);
 
 //////////////////////////////////////////////////////
 
 // CHECK-MESSAGES: :[[@LINE+1]]:6: warning: function 'inconsistentFunction' has 2 other declarations with different parameter names [readability-inconsistent-declaration-parameter-name]
 void inconsistentFunction(int a, int b, int c);
 // CHECK-MESSAGES: :[[@LINE+2]]:6: note: the 1st inconsistent declaration seen here