[clang-tidy] Add a whitelist option in google-runtime-references.

[hokein]

friendly ping. Aaron, could you take a look on this patch?

[aaron.ballman]

LGTM with a small nit.

clang-tidy/google/NonConstReferences.cpp

71–75

I think this would be a bit easier to read with std::find_if rather than a manual loop. If you decide to stick with the manual loop, the colon in the range-based for loop needs a preceding space.

[hokein]

Address review comments.

[Eugene.Zelenko]

Committed in rL283777.

[alexfh]

clang-tidy/google/NonConstReferences.cpp

73

It should be possible to check the whitelist in the matcher (qualType(unless(anyOf(isConstQualified(), hasDeclaration(namedDecl(hasAnyName(WhiteListTypes)))))) or something similar).

clang-tidy/google/NonConstReferences.h

 namespace google {
 namespace runtime {
 
 /// \brief Checks the usage of non-constant references in function parameters.
 ///
 /// https://google.github.io/styleguide/cppguide.html#Reference_Arguments
 class NonConstReferences : public ClangTidyCheck {
 public:
-  NonConstReferences(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
+  NonConstReferences(StringRef Name, ClangTidyContext *Context);
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  const std::vector<std::string> WhiteListTypes;
 };
 
 } // namespace runtime
 } // namespace google
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_NON_CONST_REFERENCES_H

clang-tidy/google/NonConstReferences.cpp

 //===--- NonConstReferences.cpp - clang-tidy --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NonConstReferences.h"
+#include "../utils/OptionsUtils.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace runtime {
 
+NonConstReferences::NonConstReferences(StringRef Name,
+                                       ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      WhiteListTypes(
+          utils::options::parseStringList(Options.get("WhiteListTypes", ""))) {}
+
+void NonConstReferences::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+   Options.store(Opts, "WhiteListTypes",
+                 utils::options::serializeStringList(WhiteListTypes));
+}
+
 void NonConstReferences::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+
   Finder->addMatcher(
       parmVarDecl(
           unless(isInstantiated()),
           hasType(references(
               qualType(unless(isConstQualified())).bind("referenced_type"))),
           unless(hasType(rValueReferenceType())))
           .bind("param"),
       this);
if (Method->begin_overridden_methods() != Method->end_overridden_methods())
       return;
     // Don't warn on lambdas, as they frequently have to conform to the
     // interface defined elsewhere.
     if (Method->getParent()->isLambda())
       return;
   }
 
   auto ReferencedType = *Result.Nodes.getNodeAs<QualType>("referenced_type");
+
+  if (std::find_if(WhiteListTypes.begin(), WhiteListTypes.end(),
+                   [&](llvm::StringRef WhiteListType) {
+                     return ReferencedType.getCanonicalType().getAsString(
+                                Result.Context->getPrintingPolicy()) ==
+                            WhiteListType;
+                   }) != WhiteListTypes.end())
+    return;
+
   // Don't warn on function references, they shouldn't be constant.
   if (ReferencedType->isFunctionProtoType())
     return;
 
   // Don't warn on dependent types in templates.
   if (ReferencedType->isDependentType())
     return;
 

docs/clang-tidy/checks/google-runtime-references.rst

 .. title:: clang-tidy - google-runtime-references
 
 google-runtime-references
 =========================
 
 Checks the usage of non-constant references in function parameters.
 
 The corresponding style guide rule:
 https://google.github.io/styleguide/cppguide.html#Reference_Arguments
+
+
+Options
+-------
+
+.. option:: WhiteListTypes
+
+   A semicolon-separated list of names of whitelist types. Defualt is empty.

test/clang-tidy/google-runtime-references.cpp

-// RUN: %check_clang_tidy %s google-runtime-references %t
+// RUN: %check_clang_tidy %s google-runtime-references %t -- \
+// RUN:   -extra-arg="-std=c++11" \
+// RUN:   -config="{CheckOptions: \
+// RUN:             [{key: google-runtime-references.WhiteListTypes, \
+// RUN:               value: 'whitelist::A; whitelist::B'}]}" --
 
 int a;
 int &b = a;
 int *c;
 void f1(int a);
 void f2(int *b);
 void f3(const int &c);
 void f4(int const &d);

 A& operator*=(A& a, const A& b) { return a; }
 A& operator/=(A& a, const A& b) { return a; }
 A& operator%=(A& a, const A& b) { return a; }
 A& operator<<=(A& a, const A& b) { return a; }
 A& operator>>=(A& a, const A& b) { return a; }
 A& operator|=(A& a, const A& b) { return a; }
 A& operator^=(A& a, const A& b) { return a; }
 A& operator&=(A& a, const A& b) { return a; }
+
+namespace whitelist {
+class A {};
+class B {};
+void f7(A &);
+void f8(B &);
+}
+void f9(whitelist::A &);
+void f10(whitelist::B &);