[clang-tidy] Fixed misc-unused-parameters omitting parameters square brackets

[PriMee]

Summary

Bug: https://bugs.llvm.org/show_bug.cgi?id=34449

Problem:

Clang-tidy check misc-unused-parameters comments out parameter name omitting following characters (e.g. square brackets) what results in its complete removal. Compilation errors might occur after clang-tidy fix as well.

Patch description:

Changed removal range. The range should end after parameter name, not after whole parameter declarator (which might be followed by e.g. square brackets).

[PriMee]

It turned out that removal range has to be even shorter than in https://reviews.llvm.org/D37566

[alexfh]

Once we got that far, could you also ensure this works for function pointer arguments (e.g. void f(void (*fn)()) {})?

[alexfh]

clang-tidy/misc/UnusedParametersCheck.cpp

141

BTW, can we just remove a single token representing the parameter name? E.g. SourceRange RemovalRange(Param->getLocation());.

[PriMee]

Diff will be updated as soon as possible.

clang-tidy/misc/UnusedParametersCheck.cpp

141

Yes, you're right :)

[PriMee]

Done :)

[alexfh]

LG. I'll commit the patch for you.

[PriMee]

Thank you!

clang-tidy/misc/UnusedParametersCheck.cpp

if (!Indexer) {
     Indexer = llvm::make_unique<IndexerVisitor>(
         Result.Context->getTranslationUnitDecl());
   }
 
   // Comment out parameter name for non-local functions.
   if (Function->isExternallyVisible() ||
       !Result.SourceManager->isInMainFile(Function->getLocation()) ||
       !Indexer->getOtherRefs(Function).empty() || isOverrideMethod(Function)) {
-    SourceRange RemovalRange(Param->getLocation(),
-                             Param->DeclaratorDecl::getSourceRange().getEnd());
+    SourceRange RemovalRange(Param->getLocation());
     // Note: We always add a space before the '/*' to not accidentally create a
     // '*/*' for pointer types, which doesn't start a comment. clang-format will
     // clean this up afterwards.
     MyDiag << FixItHint::CreateReplacement(
         RemovalRange, (Twine(" /*") + Param->getName() + "*/").str());
     return;
   }
 

test/clang-tidy/misc-unused-parameters.cpp

 void b(int i = 1) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]
 // CHECK-FIXES: {{^}}void b(int  /*i*/ = 1) {}{{$}}
 
 void c(int *i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: parameter 'i' is unused [misc-unused-parameters]
 // CHECK-FIXES: {{^}}void c(int * /*i*/) {}{{$}}
 
+void d(int i[]) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]
+// CHECK-FIXES: {{^}}void d(int  /*i*/[]) {}{{$}}
+
+void e(int i[1]) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'i' is unused [misc-unused-parameters]
+// CHECK-FIXES: {{^}}void e(int  /*i*/[1]) {}{{$}}
+
+void f(void (*fn)()) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: parameter 'fn' is unused [misc-unused-parameters]
+// CHECK-FIXES: {{^}}void f(void (* /*fn*/)()) {}{{$}}
+
 // Unchanged cases
 // ===============
 void f(int i); // Don't remove stuff in declarations
 void g(int i = 1);
-void h(int i) { (void)i; } // Don't remove used parameters
+void h(int i[]);
+void s(int i[1]);
+void u(void (*fn)());
+void w(int i) { (void)i; } // Don't remove used parameters
 
 bool useLambda(int (*fn)(int));
 static bool static_var = useLambda([] (int a) { return a; });
 
 // Remove parameters of local functions
 // ====================================
 static void staticFunctionA(int i);
 // CHECK-FIXES: {{^}}static void staticFunctionA();

 // CHECK-FIXES: {{^}}static void staticFunctionE()
 
 static void staticFunctionF(int i = 4);
 // CHECK-FIXES: {{^}}static void staticFunctionF();
 static void staticFunctionF(int i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:33: warning
 // CHECK-FIXES: {{^}}static void staticFunctionF()
 
+static void staticFunctionG(int i[]);
+// CHECK-FIXES: {{^}}static void staticFunctionG();
+static void staticFunctionG(int i[]) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:33: warning
+// CHECK-FIXES: {{^}}static void staticFunctionG()
+
+static void staticFunctionH(void (*fn)());
+// CHECK-FIXES: {{^}}static void staticFunctionH();
+static void staticFunctionH(void (*fn)()) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:36: warning
+// CHECK-FIXES: {{^}}static void staticFunctionH()
+
 static void someCallSites() {
   staticFunctionA(1);
 // CHECK-FIXES: staticFunctionA();
   staticFunctionB(1, 2);
 // CHECK-FIXES: staticFunctionB(1);
   staticFunctionC(1, 2);
 // CHECK-FIXES: staticFunctionC(2);
   staticFunctionD(1, 2, 3);
 // CHECK-FIXES: staticFunctionD(1, 3);
   staticFunctionE(1);
 // CHECK-FIXES: staticFunctionE();
   staticFunctionF(1);
 // CHECK-FIXES: staticFunctionF();
   staticFunctionF();
 // CHECK-FIXES: staticFunctionF();
+  int t[] = {1};
+  staticFunctionG(t);
+// CHECK-FIXES: staticFunctionG();
+  void func();
+  staticFunctionH(&func);
+// CHECK-FIXES: staticFunctionH();  
 }
 
 /*
  * FIXME: This fails because the removals overlap and ClangTidy doesn't apply
  *        them.
  * static void bothVarsUnused(int a, int b) {}
  */
 

 
 class SomeClass {
   static void f(int i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning
 // CHECK-FIXES: static void f(int  /*i*/) {}
   static void g(int i = 1) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning
 // CHECK-FIXES: static void g(int  /*i*/ = 1) {}
+  static void h(int i[]) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning
+// CHECK-FIXES: static void h(int  /*i*/[]) {}
+  static void s(void (*fn)()) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:24: warning
+// CHECK-FIXES: static void s(void (* /*fn*/)()) {}
 };
 
 namespace {
 class C {
 public:
   void f(int i);
 // CHECK-FIXES: void f();
   void g(int i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning
 // CHECK-FIXES: void g() {}
   void h(int i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning
 // CHECK-FIXES: void h(int  /*i*/) {}
   void s(int i = 1) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning
 // CHECK-FIXES: void s(int  /*i*/ = 1) {}
+  void u(int i[]) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning
+// CHECK-FIXES: void u(int  /*i*/[]) {}
+  void w(void (*fn)()) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning
+// CHECK-FIXES: void w(void (* /*fn*/)()) {}
 };
 
 void C::f(int i) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning
 // CHECK-FIXES: void C::f() {}
 
 template <typename T>
 void useFunction(T t);
 
 void someMoreCallSites() {
   C c;
   c.f(1);
 // CHECK-FIXES: c.f();
   c.g(1);
 // CHECK-FIXES: c.g();
 
   useFunction(&C::h);
-  useFunction(&C::s);;
+  useFunction(&C::s);
+  useFunction(&C::u);
+  useFunction(&C::w);
 }
 
 class Base {
   virtual void f(int i);
 };
 
 class Derived : public Base {
   void f(int i) override {}