[clang-tidy] More friendly warning in "google-runtime-references" when meeting an unnamed function parameter.

[alexfh]

Looks good. Thank you!

clang-tools-extra/trunk/clang-tidy/google/NonConstReferences.cpp

void NonConstReferences::check(const MatchFinder::MatchResult &Result) {
   // Some functions use references to comply with established standards.
   if (Function->getDeclName().isIdentifier() && Function->getName() == "swap")
     return;
 
   // iostream parameters are typically passed by non-const reference.
   if (StringRef(ReferencedType.getAsString()).endswith("stream"))
     return;
 
+  if (Parameter->getName().empty()) {
+    diag(Parameter->getLocation(),
+         "non-const reference parameter at index %0, "
+         "make it const or use a pointer")
+        << Parameter->getFunctionScopeIndex();
+  } else {
     diag(Parameter->getLocation(),
          "non-const reference parameter '%0', make it const or use a pointer")
         << Parameter->getName();
   }
+}
 
 } // namespace runtime
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/test/clang-tidy/google-runtime-references.cpp

 
 typedef int &ref;
 void g3(ref a);
 // CHECK-MESSAGES: [[@LINE-1]]:13: warning: non-const reference {{.*}}
 
 void g4(int &a, int &b, int &);
 // CHECK-MESSAGES: [[@LINE-1]]:14: warning: non-const reference parameter 'a', {{.*}}
 // CHECK-MESSAGES: [[@LINE-2]]:22: warning: non-const reference parameter 'b', {{.*}}
-// CHECK-MESSAGES: [[@LINE-3]]:30: warning: non-const reference parameter '', {{.*}}
+// CHECK-MESSAGES: [[@LINE-3]]:30: warning: non-const reference parameter at index 2, {{.*}}
 
 class B {
   B(B& a) {}
 // CHECK-MESSAGES: [[@LINE-1]]:8: warning: non-const reference {{.*}}
   virtual void f(int &a) {}
 // CHECK-MESSAGES: [[@LINE-1]]:23: warning: non-const reference {{.*}}
   void g(int &b);
 // CHECK-MESSAGES: [[@LINE-1]]:15: warning: non-const reference {{.*}}
 
   // Don't warn on the parameter of stream extractors defined as members.
   B& operator>>(int& val) { return *this; }
 };
 
 // Only warn on the first declaration of each function to reduce duplicate
 // warnings.
 void B::g(int &b) {}
 
 // Don't warn on the first parameter of stream inserters.
 A& operator<<(A& s, int&) { return s; }
-// CHECK-MESSAGES: [[@LINE-1]]:25: warning: non-const reference parameter '', {{.*}}
+// CHECK-MESSAGES: [[@LINE-1]]:25: warning: non-const reference parameter at index 1, {{.*}}
 
 // Don't warn on either parameter of stream extractors. Both need to be
 // non-const references by convention.
 A& operator>>(A& input, int& val) { return input; }
 
 // Don't warn on lambdas.
 auto lambda = [] (int&) {};