[clang-tidy] Added hasAnyListedName matcher

[njames93]

Summary

Adds a utils matcher called hasAnyListedName to alleviate all the hackery using the hasAnyName matcher with types that are already vector<string>

[njames93]

• Fix formatting

[gribozavr2]

clang-tools-extra/clang-tidy/utils/Matchers.cpp

18

This matcher sounds generally useful. I think it would be better placed in ASTMatchers.h, WDYT? Can we make it an overload of hasAnyName?

[njames93]

clang-tools-extra/clang-tidy/utils/Matchers.cpp

18

hasAnyName is a const variable who's type is VariadicFunction so it can't be overloaded unfortunately. I personally didn't want it in ASTMatchers.h as its mainly useful for clang-tidy checks that load in configurations. It doesn't have a place in say clang-query.

[gribozavr2]

clang-tools-extra/clang-tidy/utils/Matchers.cpp

18

hasAnyName is a const variable who's type is VariadicFunction so it can't be overloaded unfortunately.

I thought we had facilities to declare polymorphic matchers that could help here.

I personally didn't want it in ASTMatchers.h as its mainly useful for clang-tidy checks that load in configurations.

A lot of user-defined tools are quite similar.

[njames93]

clang-tools-extra/clang-tidy/utils/Matchers.cpp

18

Polymorphic matchers are matchers that can match against different types of nodes, what we want here is match against one type of node, but different overloads. I am thinking though that With some nifty retooling of VariadicFunction you could possible change it so that you can call its operator() with types that are convertible to its ArgT. However that is a deep rabbit hole to go down for the purpose of what this patch is trying to do

[alexfh]

clang-tools-extra/clang-tidy/utils/Matchers.h

53–55

We could change all checks to use the other overload and drop this one (and the utils::options::parseStringList() call in each check's constructor). WDYT?

[njames93]

clang-tools-extra/clang-tidy/utils/Matchers.h

53–55

I'm not sold on that, I'd like the conventions of all checks to be the same wrt option lists, however those option lists aren't only used for names of decls.

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

 //===--- StringFindStartswithCheck.cc - clang-tidy---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "StringFindStartswithCheck.h"
 
+#include "../utils/Matchers.h"
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Frontend/CompilerInstance.h"
 
 #include <cassert>
 
 using namespace clang::ast_matchers;
: ClangTidyCheck(Name, Context),
           Options.get("StringLikeClasses", "::std::basic_string"))),
       IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
           Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
       AbseilStringsMatchHeader(
           Options.get("AbseilStringsMatchHeader", "absl/strings/match.h")) {}
 
 void StringFindStartswithCheck::registerMatchers(MatchFinder *Finder) {
   auto ZeroLiteral = integerLiteral(equals(0));
-  auto StringClassMatcher = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 4>(
-      StringLikeClasses.begin(), StringLikeClasses.end())));
+  auto StringClassMatcher =
+      cxxRecordDecl(matchers::hasAnyListedName(StringLikeClasses));
   auto StringType = hasUnqualifiedDesugaredType(
       recordType(hasDeclaration(StringClassMatcher)));
 
   auto StringFind = cxxMemberCallExpr(
       // .find()-call on a string...
       callee(cxxMethodDecl(hasName("find"))),
       on(hasType(StringType)),
       // ... with some search expression ...

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

 } // anonymous namespace
 
 DanglingHandleCheck::DanglingHandleCheck(StringRef Name,
                                          ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       HandleClasses(utils::options::parseStringList(Options.get(
           "HandleClasses",
           "std::basic_string_view;std::experimental::basic_string_view"))),
-      IsAHandle(cxxRecordDecl(hasAnyName(std::vector<StringRef>(
-                                  HandleClasses.begin(), HandleClasses.end())))
+      IsAHandle(cxxRecordDecl(matchers::hasAnyListedName(HandleClasses))
                     .bind("handle")) {}
 
 void DanglingHandleCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HandleClasses",
                 utils::options::serializeStringList(HandleClasses));
 }
 
 void DanglingHandleCheck::registerMatchersForVariables(MatchFinder *Finder) {

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

void SuspiciousStringCompareCheck::registerMatchers(MatchFinder *Finder) {
   // Add the list of known string compare-like functions and add user-defined
   // functions.
   std::vector<std::string> FunctionNames = utils::options::parseStringList(
       (llvm::Twine(KnownStringCompareFunctions) + StringCompareLikeFunctions)
           .str());
 
   // Match a call to a string compare functions.
   const auto FunctionCompareDecl =
-      functionDecl(hasAnyName(std::vector<StringRef>(FunctionNames.begin(),
-                                                     FunctionNames.end())))
+      functionDecl(matchers::hasAnyListedName(FunctionNames))
           .bind("decl");
   const auto DirectStringCompareCallExpr =
       callExpr(hasDeclaration(FunctionCompareDecl)).bind("call");
   const auto MacroStringCompareCallExpr = conditionalOperator(anyOf(
       hasTrueExpression(ignoringParenImpCasts(DirectStringCompareCallExpr)),
       hasFalseExpression(ignoringParenImpCasts(DirectStringCompareCallExpr))));
   // The implicit cast is not present in C.
   const auto StringCompareCallExpr = ignoringParenImpCasts(

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

 //===--- UnusedReturnValueCheck.cpp - clang-tidy---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "UnusedReturnValueCheck.h"
+#include "../utils/Matchers.h"
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::internal;
 
 namespace clang {

 }
 
 void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {
   auto FunVec = utils::options::parseStringList(CheckedFunctions);
   auto MatchedCallExpr = expr(ignoringImplicit(ignoringParenImpCasts(
       callExpr(callee(functionDecl(
                    // Don't match void overloads of checked functions.
                    unless(returns(voidType())),
-                   isInstantiatedFrom(hasAnyName(
-                       std::vector<StringRef>(FunVec.begin(), FunVec.end()))))))
+                   isInstantiatedFrom(matchers::hasAnyListedName(FunVec)))))
           .bind("match"))));
 
   auto UnusedInCompoundStmt =
       compoundStmt(forEach(MatchedCallExpr),
                    // The checker can't currently differentiate between the
                    // return statement and other statements inside GNU statement
                    // expressions, so disable the checker inside them to avoid
                    // false positives.

clang-tools-extra/clang-tidy/cert/NonTrivialTypesLibcMemoryCallsCheck.cpp

 //===--- NonTrivialTypesLibcMemoryCallsCheck.cpp - clang-tidy ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "NonTrivialTypesLibcMemoryCallsCheck.h"
+#include "../utils/Matchers.h"
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "clang/ASTMatchers/ASTMatchersMacros.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace cert {
 
 namespace {
 AST_MATCHER(CXXRecordDecl, isTriviallyDefaultConstructible) {
   return Node.hasTrivialDefaultConstructor();
 }
 AST_MATCHER(CXXRecordDecl, isTriviallyCopyable) {
   return Node.hasTrivialCopyAssignment() && Node.hasTrivialCopyConstructor();
 }
-AST_MATCHER_P(NamedDecl, hasAnyNameStdString, std::vector<std::string>,
-              String) {
-  return ast_matchers::internal::HasNameMatcher(String).matchesNode(Node);
-}
 } // namespace
 
 static const char BuiltinMemSet[] = "::std::memset;"
                                     "::memset;";
 static const char BuiltinMemCpy[] = "::std::memcpy;"
                                     "::memcpy;"
                                     "::std::memmove;"
                                     "::memmove;"
void NonTrivialTypesLibcMemoryCallsCheck::registerMatchers(
   auto ArgChecker = [&](Matcher<CXXRecordDecl> RecordConstraint,
                         BindableMatcher<Stmt> SecondArg) {
     return allOf(argumentCountIs(3),
                  hasArgument(0, IsStructPointer(RecordConstraint, true)),
                  hasArgument(1, SecondArg), hasArgument(2, IsRecordSizeOf));
   };
 
   Finder->addMatcher(
-      callExpr(callee(namedDecl(hasAnyNameStdString(
+      callExpr(callee(namedDecl(matchers::hasAnyListedName(
                    parseStringListPair(BuiltinMemSet, MemSetNames)))),
                ArgChecker(unless(isTriviallyDefaultConstructible()),
                           expr(integerLiteral(equals(0)))))
           .bind("lazyConstruct"),
       this);
   Finder->addMatcher(
-      callExpr(callee(namedDecl(hasAnyNameStdString(
+      callExpr(callee(namedDecl(matchers::hasAnyListedName(
                    parseStringListPair(BuiltinMemCpy, MemCpyNames)))),
                ArgChecker(unless(isTriviallyCopyable()), IsStructPointer()))
           .bind("lazyCopy"),
       this);
   Finder->addMatcher(
-      callExpr(callee(namedDecl(hasAnyNameStdString(
+      callExpr(callee(namedDecl(matchers::hasAnyListedName(
                    parseStringListPair(BuiltinMemCmp, MemCmpNames)))),
                ArgChecker(hasMethod(hasAnyName(ComparisonOperators)),
                           IsStructPointer()))
           .bind("lazyCompare"),
       this);
 }
 
 void NonTrivialTypesLibcMemoryCallsCheck::check(

clang-tools-extra/clang-tidy/cppcoreguidelines/NoMallocCheck.cpp

 
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::internal;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-namespace {
-Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(FunctionNames);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-} // namespace
-
 void NoMallocCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "Allocations", AllocList);
   Options.store(Opts, "Reallocations", ReallocList);
   Options.store(Opts, "Deallocations", DeallocList);
 }
 
 void NoMallocCheck::registerMatchers(MatchFinder *Finder) {
   // Registering malloc, will suggest RAII.
-  Finder->addMatcher(callExpr(callee(functionDecl(hasAnyListedName(AllocList))))
-                         .bind("allocation"),
-                     this);
+  Finder->addMatcher(
+      callExpr(callee(functionDecl(matchers::hasAnyListedName(AllocList))))
 
   // Registering realloc calls, suggest std::vector or std::string.
   Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyListedName(ReallocList))))
+      callExpr(callee(functionDecl(matchers::hasAnyListedName(ReallocList))))
           .bind("realloc"),
       this);
 
   // Registering free calls, will suggest RAII instead.
   Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyListedName(DeallocList))))
+      callExpr(callee(functionDecl(matchers::hasAnyListedName(DeallocList))))
           .bind("free"),
       this);
 }
 
 void NoMallocCheck::check(const MatchFinder::MatchResult &Result) {
   const CallExpr *Call = nullptr;
   StringRef Recommendation;
 

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

 
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::internal;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-// FIXME: Copied from 'NoMallocCheck.cpp'. Has to be refactored into 'util' or
-// something like that.
-namespace {
-Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(FunctionNames);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-} // namespace
-
 void OwningMemoryCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "LegacyResourceProducers", LegacyResourceProducers);
   Options.store(Opts, "LegacyResourceConsumers", LegacyResourceConsumers);
 }
 
 /// Match common cases, where the owner semantic is relevant, like function
 /// calls, delete expressions and others.
 void OwningMemoryCheck::registerMatchers(MatchFinder *Finder) {
   const auto OwnerDecl = typeAliasTemplateDecl(hasName("::gsl::owner"));
   const auto IsOwnerType = hasType(OwnerDecl);
 
-  const auto LegacyCreatorFunctions = hasAnyListedName(LegacyResourceProducers);
+  const auto LegacyCreatorFunctions =
+      matchers::hasAnyListedName(LegacyResourceProducers);
   const auto LegacyConsumerFunctions =
-      hasAnyListedName(LegacyResourceConsumers);
+      matchers::hasAnyListedName(LegacyResourceConsumers);
 
   // Legacy functions that are use for resource management but cannot be
   // updated to use `gsl::owner<>`, like standard C memory management.
   const auto CreatesLegacyOwner =
       callExpr(callee(functionDecl(LegacyCreatorFunctions)));
   // C-style functions like `::malloc()` sometimes create owners as void*
   // which is expected to be cast to the correct type in C++. This case
   // must be catched explicitly.

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.cpp

 //===--- UseEmplaceCheck.cpp - clang-tidy----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "UseEmplaceCheck.h"
+#include "../utils/Matchers.h"
 #include "../utils/OptionsUtils.h"
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 namespace {
void UseEmplaceCheck::registerMatchers(MatchFinder *Finder) {
   // and std::deque.
   // + add handling of `push` for std::stack, std::queue, std::priority_queue
   // + add handling of `insert` for stl associative container, but be careful
   // because this requires special treatment (it could cause performance
   // regression)
   // + match for emplace calls that should be replaced with insertion
   auto CallPushBack = cxxMemberCallExpr(
       hasDeclaration(functionDecl(hasName("push_back"))),
-      on(hasType(cxxRecordDecl(hasAnyName(SmallVector<StringRef, 5>(
-          ContainersWithPushBack.begin(), ContainersWithPushBack.end()))))));
+      on(hasType(
+          cxxRecordDecl(matchers::hasAnyListedName(ContainersWithPushBack)))));
 
   // We can't replace push_backs of smart pointer because
   // if emplacement fails (f.e. bad_alloc in vector) we will have leak of
   // passed pointer because smart pointer won't be constructed
   // (and destructed) as in push_back case.
-  auto IsCtorOfSmartPtr = hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(
-      SmallVector<StringRef, 5>(SmartPointers.begin(), SmartPointers.end())))));
+  auto IsCtorOfSmartPtr = hasDeclaration(
+      cxxConstructorDecl(ofClass(matchers::hasAnyListedName(SmartPointers))));
 
   // Bitfields binds only to consts and emplace_back take it by universal ref.
   auto BitFieldAsArgument = hasAnyArgument(
       ignoringImplicit(memberExpr(hasDeclaration(fieldDecl(isBitField())))));
 
   // Initializer list can't be passed to universal reference.
   auto InitializerListAsArgument = hasAnyArgument(
       ignoringImplicit(cxxConstructExpr(isListInitialization())));
void UseEmplaceCheck::registerMatchers(MatchFinder *Finder) {
   auto SoughtConstructExpr =
       cxxConstructExpr(
           unless(anyOf(IsCtorOfSmartPtr, HasInitList, BitFieldAsArgument,
                        InitializerListAsArgument, NewExprAsArgument,
                        ConstructingDerived, IsPrivateCtor)))
           .bind("ctor");
   auto HasConstructExpr = has(ignoringImplicit(SoughtConstructExpr));
 
-  auto MakeTuple = ignoringImplicit(
-      callExpr(
-          callee(expr(ignoringImplicit(declRefExpr(
+  auto MakeTuple =
+      ignoringImplicit(callExpr(callee(expr(ignoringImplicit(declRefExpr(
                                     unless(hasExplicitTemplateArgs()),
-              to(functionDecl(hasAnyName(SmallVector<StringRef, 2>(
-                  TupleMakeFunctions.begin(), TupleMakeFunctions.end())))))))))
+                                    to(functionDecl(matchers::hasAnyListedName(
+                                        TupleMakeFunctions))))))))
                            .bind("make"));
 
   // make_something can return type convertible to container's element type.
   // Allow the conversion only on containers of pairs.
-  auto MakeTupleCtor = ignoringImplicit(cxxConstructExpr(
-      has(materializeTemporaryExpr(MakeTuple)),
-      hasDeclaration(cxxConstructorDecl(ofClass(hasAnyName(
-          SmallVector<StringRef, 2>(TupleTypes.begin(), TupleTypes.end())))))));
+  auto MakeTupleCtor = ignoringImplicit(
+      cxxConstructExpr(has(materializeTemporaryExpr(MakeTuple)),
+                       hasDeclaration(cxxConstructorDecl(
+                           ofClass(matchers::hasAnyListedName(TupleTypes))))));
 
   auto SoughtParam = materializeTemporaryExpr(
       anyOf(has(MakeTuple), has(MakeTupleCtor),
             HasConstructExpr, has(cxxFunctionalCastExpr(HasConstructExpr))));
 
   Finder->addMatcher(cxxMemberCallExpr(CallPushBack, has(SoughtParam),
                                        unless(isInTemplateInstantiation()))
                          .bind("call"),

clang-tools-extra/clang-tidy/objc/ForbiddenSubclassingCheck.cpp

 //===--- ForbiddenSubclassingCheck.cpp - clang-tidy -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ForbiddenSubclassingCheck.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallVector.h"
-#include "../utils/OptionsUtils.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace objc {
 
 namespace {
: ClangTidyCheck(Name, Context),
       ForbiddenSuperClassNames(
           utils::options::parseStringList(
               Options.get("ClassNames", DefaultForbiddenSuperClassNames))) {
 }
 
 void ForbiddenSubclassingCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       objcInterfaceDecl(
-          isDerivedFrom(
-              objcInterfaceDecl(
-                  hasAnyName(
-                      std::vector<StringRef>(
-                          ForbiddenSuperClassNames.begin(),
-                          ForbiddenSuperClassNames.end())))
+          isDerivedFrom(objcInterfaceDecl(matchers::hasAnyListedName(
+                                              ForbiddenSuperClassNames))
                             .bind("superclass")))
           .bind("subclass"),
       this);
 }
 
 void ForbiddenSubclassingCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *SubClass = Result.Nodes.getNodeAs<ObjCInterfaceDecl>(
       "subclass");
   assert(SubClass != nullptr);

clang-tools-extra/clang-tidy/performance/FasterStringFindCheck.cpp

 //===--- FasterStringFindCheck.cpp - clang-tidy----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "FasterStringFindCheck.h"
+#include "../utils/Matchers.h"
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang::ast_matchers;
 
void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {
 
   Finder->addMatcher(
       cxxMemberCallExpr(
           callee(functionDecl(StringFindFunctions).bind("func")),
           anyOf(argumentCountIs(1), argumentCountIs(2)),
           hasArgument(0, SingleChar),
           on(expr(
               hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(
-                  recordDecl(hasAnyName(SmallVector<StringRef, 4>(
-                      StringLikeClasses.begin(), StringLikeClasses.end()))))))),
+                  recordDecl(matchers::hasAnyListedName(StringLikeClasses)))))),
               unless(hasSubstitutedType())))),
       this);
 }
 
 void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal");
   const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
 

clang-tools-extra/clang-tidy/readability/RedundantStringInitCheck.cpp

 using namespace clang::tidy::matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 const char DefaultStringNames[] = "::std::basic_string";
 
-static ast_matchers::internal::Matcher<NamedDecl>
-hasAnyNameStdString(std::vector<std::string> Names) {
-  return ast_matchers::internal::Matcher<NamedDecl>(
-      new ast_matchers::internal::HasNameMatcher(std::move(Names)));
-}
-
 static std::vector<std::string>
 removeNamespaces(const std::vector<std::string> &Names) {
   std::vector<std::string> Result;
   Result.reserve(Names.size());
   for (const std::string &Name : Names) {
     std::string::size_type ColonPos = Name.rfind(':');
     Result.push_back(
         Name.substr(ColonPos == std::string::npos ? 0 : ColonPos + 1));
: ClangTidyCheck(Name, Context),
       StringNames(utils::options::parseStringList(
           Options.get("StringNames", DefaultStringNames))) {}
 
 void RedundantStringInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StringNames", DefaultStringNames);
 }
 
 void RedundantStringInitCheck::registerMatchers(MatchFinder *Finder) {
-  const auto hasStringTypeName = hasAnyNameStdString(StringNames);
+  const auto hasStringTypeName = matchers::hasAnyListedName(StringNames);
   const auto hasStringCtorName =
-      hasAnyNameStdString(removeNamespaces(StringNames));
+      matchers::hasAnyListedName(removeNamespaces(StringNames));
 
   // Match string constructor.
   const auto StringConstructorExpr = expr(
       anyOf(cxxConstructExpr(argumentCountIs(1),
                              hasDeclaration(cxxMethodDecl(hasStringCtorName))),
             // If present, the second argument is the alloc object which must
             // not be present explicitly.
             cxxConstructExpr(argumentCountIs(2),

clang-tools-extra/clang-tidy/readability/SimplifySubscriptExprCheck.cpp

 //===--- SimplifySubscriptExprCheck.cpp - clang-tidy-----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SimplifySubscriptExprCheck.h"
+#include "../utils/Matchers.h"
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 static const char kDefaultTypes[] =
     "::std::basic_string;::std::basic_string_view;::std::vector;::std::array";
 
 SimplifySubscriptExprCheck::SimplifySubscriptExprCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), Types(utils::options::parseStringList(
                                          Options.get("Types", kDefaultTypes))) {
 }
 
 void SimplifySubscriptExprCheck::registerMatchers(MatchFinder *Finder) {
-  const auto TypesMatcher = hasUnqualifiedDesugaredType(
-      recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
-          llvm::SmallVector<StringRef, 8>(Types.begin(), Types.end()))))));
+  const auto TypesMatcher = hasUnqualifiedDesugaredType(recordType(
+      hasDeclaration(cxxRecordDecl(matchers::hasAnyListedName(Types)))));
 
   Finder->addMatcher(
       arraySubscriptExpr(hasBase(ignoringParenImpCasts(
           cxxMemberCallExpr(
               has(memberExpr().bind("member")),
               on(hasType(qualType(
                   unless(anyOf(substTemplateTypeParmType(),
                                hasDescendant(substTemplateTypeParmType()))),

clang-tools-extra/clang-tidy/utils/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyUtils
   ASTUtils.cpp
   DeclRefExprUtils.cpp
   ExceptionAnalyzer.cpp
   ExprSequence.cpp
   FileExtensionsUtils.cpp
   FixItHintUtils.cpp
   HeaderGuard.cpp
   IncludeInserter.cpp
   IncludeSorter.cpp
   LexerUtils.cpp
+  Matchers.cpp
   NamespaceAliaser.cpp
   OptionsUtils.cpp
   RenamerClangTidyCheck.cpp
   TransformerClangTidyCheck.cpp
   TypeTraits.cpp
   UsingInserter.cpp
 
   LINK_LIBS
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangSema
   clangTidy
   clangTransformer
   )

clang-tools-extra/clang-tidy/utils/Matchers.h

 
 AST_MATCHER_P(NamedDecl, matchesAnyListedName, std::vector<std::string>,
               NameList) {
   return llvm::any_of(NameList, [&Node](const std::string &Name) {
       return llvm::Regex(Name).match(Node.getName());
     });
 }
 
+ast_matchers::internal::Matcher<NamedDecl>
+hasAnyListedName(std::vector<std::string> Names);
+
+// NameList must be a semi-colon; seperated list.
+ast_matchers::internal::Matcher<NamedDecl>
+hasAnyListedName(llvm::StringRef NameList);
+
 } // namespace matchers
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_MATCHERS_H

clang-tools-extra/clang-tidy/utils/Matchers.cpp

+//===--- Matchers.cpp - clang-tidy ----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Matchers.h"
+#include "OptionsUtils.h"
+
+namespace clang {
+namespace tidy {
+namespace matchers {
+using namespace ast_matchers::internal;
+
+Matcher<NamedDecl> hasAnyListedName(std::vector<std::string> Names) {
+  return Matcher<NamedDecl>(new HasNameMatcher(std::move(Names)));
+}
+
+Matcher<NamedDecl> hasAnyListedName(llvm::StringRef NameList) {
+  return hasAnyListedName(utils::options::parseStringList(NameList));
+}
+
+} // namespace matchers
+} // namespace tidy
+} // namespace clang