[ASTMatchers] Introduce hasAnyNameIn matcher: like hasAnyName, but accepts a vector

[george.karpenkov]

Summary

For callers, supplying a vector is often more convenient than working with a variadic function

[alexfh]

The existing matcher works with a std::vector<StringRef>. If you need to pass a std::vector<std::string>, there's a way to convert it:

hasAnyName(std::vector<llvm::StringRef>(v.begin(), v.end()))

[george.karpenkov]

OK, abandoning.
I'm still confused as to why all matchers insist on accepting non-owning containers, just to convert them to owning ones later on.

docs/LibASTMatchersReference.html

     int a;
     static int b;
   };
 memberExpr(isArrow())
   matches this->x, x, y.x, a, this->b
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyNameIn0')"><a name="hasAnyNameIn0Anchor">hasAnyNameIn</a></td><td>std::vector&lt;std::string&gt; Names</td></tr>
+<tr><td colspan="4" class="doc" id="hasAnyNameIn0"><pre>Matches NamedDecl nodes that have any of the names specified in
+`Names`. Functionally identical to `hasAnyName`, but allows the caller
+to pass in a container directly.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;</td><td class="name" onclick="toggle('hasExternalFormalLinkage0')"><a name="hasExternalFormalLinkage0Anchor">hasExternalFormalLinkage</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="hasExternalFormalLinkage0"><pre>Matches a declaration that has external formal linkage.
 
 Example matches only z (matcher = varDecl(hasExternalFormalLinkage()))
 void f() {
   int x;
   static int y;
 }

 a specific number of arguments (including absent default arguments).
 
 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
   void f(int x, int y);
   f(0, 0);
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnySelectorIn0')"><a name="hasAnySelectorIn0Anchor">hasAnySelectorIn</a></td><td>std::vector&lt;std::string&gt; Matches</td></tr>
+<tr><td colspan="4" class="doc" id="hasAnySelectorIn0"><pre>Matches when Selector.getAsString() is inside of the supplied
+vector of strings.
+
+ matcher = objCMessageExpr(hasSelectorIn({"methodA:", "methodB:"}));
+ matches both of the expressions below:
+    [myObj methodA:argA];
+    [myObj methodB:argB];
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;</td><td class="name" onclick="toggle('hasKeywordSelector0')"><a name="hasKeywordSelector0Anchor">hasKeywordSelector</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="hasKeywordSelector0"><pre>Matches when the selector is a keyword selector
 
 objCMessageExpr(hasKeywordSelector()) matches the generated setFrame
 message expression in
 
   UIWebView *webView = ...;
   CGRect bodyFrame = webView.frame;

 
 This matcher is only provided as a performance optimization of hasName.
     hasAnyName(a, b, c)
  is equivalent to, but faster than
     anyOf(hasName(a), hasName(b), hasName(c))
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;internal::Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;&gt;</td><td class="name" onclick="toggle('hasAnySelector0')"><a name="hasAnySelector0Anchor">hasAnySelector</a></td><td>StringRef, ..., StringRef</td></tr>
+<tr><td colspan="4" class="doc" id="hasAnySelector0"><pre>A variant of `hasAnySelectorIn` accepting a variadic number of
+arguments, useful for dynamic matching.
+Matches when at least one of the supplied string equals to the selector
+name.
+
+ matcher = objCMessageExpr(hasSelector("methodA:", "methodB:"));
+ matches both of the expressions below:
+    [myObj methodA:argA];
+    [myObj methodB:argB];
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;internal::Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;&gt;</td><td class="name" onclick="toggle('isInTemplateInstantiation0')"><a name="isInTemplateInstantiation0Anchor">isInTemplateInstantiation</a></td><td></td></tr>
 <tr><td colspan="4" class="doc" id="isInTemplateInstantiation0"><pre>Matches statements inside of a template instantiation.
 
 Given
   int j;
   template&lt;typename T&gt; void A(T t) { T i; j += 42;}
   A(0);
   A(0U);

include/clang/ASTMatchers/ASTMatchers.h

 /// \brief Same as unaryExprOrTypeTraitExpr, but only matching
 /// sizeof.
 inline internal::Matcher<Stmt> sizeOfExpr(
     const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
   return stmt(unaryExprOrTypeTraitExpr(
       allOf(ofKind(UETT_SizeOf), InnerMatcher)));
 }
 
+/// \brief Matches NamedDecl nodes that have any of the names specified in
+/// `Names`. Functionally identical to `hasAnyName`, but allows the caller
+/// to pass in a container directly.
+inline internal::Matcher<NamedDecl>
+hasAnyNameIn(std::vector<std::string> Names) {
+  return internal::Matcher<NamedDecl>(new internal::HasNameMatcher(Names));
+}
+
 /// \brief Matches NamedDecl nodes that have the specified name.
 ///
 /// Supports specifying enclosing namespaces or classes by prefixing the name
 /// with '<enclosing>::'.
 /// Does not match typedefs of an underlying type with the given name.
 ///
 /// Example matches X (Name == "X")
 /// \code
 ///   class X;
 /// \endcode
 ///
 /// Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
 /// \code
 ///   namespace a { namespace b { class X; } }
 /// \endcode
 inline internal::Matcher<NamedDecl> hasName(const std::string &Name) {
-  std::vector<std::string> Names;
-  Names.push_back(Name);
-  return internal::Matcher<NamedDecl>(new internal::HasNameMatcher(Names));
+  return hasAnyNameIn({Name});
 }
 
 /// \brief Matches NamedDecl nodes that have any of the specified names.
 ///
 /// This matcher is only provided as a performance optimization of hasName.
 /// \code
 ///     hasAnyName(a, b, c)
 /// \endcode

lib/ASTMatchers/ASTMatchersInternal.cpp

std::vector<std::string> vectorFromRefs(ArrayRef<const StringRef *> NameRefs) {
   std::vector<std::string> Names;
   for (auto *Name : NameRefs)
     Names.emplace_back(*Name);
   return Names;
 }
 
 Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs) {
   std::vector<std::string> Names = vectorFromRefs(NameRefs);
-  return internal::Matcher<NamedDecl>(
-      new internal::HasNameMatcher(std::move(Names)));
+  return hasAnyNameIn(Names);
 }
 
 Matcher<ObjCMessageExpr> hasAnySelectorFunc(
     ArrayRef<const StringRef *> NameRefs) {
   std::vector<std::string> Names = vectorFromRefs(NameRefs);
   return hasAnySelectorIn(Names);
 }
 

unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

 
 TEST(Matcher, HasAnyName) {
   const std::string Code = "namespace a { namespace b { class C; } }";
 
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "a::b::C"))));
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("a::b::C", "XX"))));
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX::C", "a::b::C"))));
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "C"))));
+  EXPECT_TRUE(matches(Code, recordDecl(hasAnyNameIn({"XX", "C"}))));
 
   EXPECT_TRUE(notMatches(Code, recordDecl(hasAnyName("::C", "::b::C"))));
+  EXPECT_TRUE(notMatches(Code, recordDecl(hasAnyNameIn({"::C", "::b::C"}))));
   EXPECT_TRUE(
     matches(Code, recordDecl(hasAnyName("::C", "::b::C", "::a::b::C"))));
 
   std::vector<StringRef> Names = {"::C", "::b::C", "::a::b::C"};
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName(Names))));
 }
 
 TEST(Matcher, IsDefinition) {