[ASTMatchers] Introduce a matcher for matching any given Objective-C selector

[alexfh]

include/clang/ASTMatchers/ASTMatchers.h

2737 ↗

(On Diff #139688)

I'd suggest to do the same as with hasAnyName: leave just the std::vector<llvm::StringRef> overload. WDYT?

[george.karpenkov]

include/clang/ASTMatchers/ASTMatchers.h

2737 ↗

(On Diff #139688)

OK.
I think it much more sense to accepts a vector of std::string in the first place, since we need an owning container for the matcher anyway.

[george.karpenkov]

@alexfh OK to commit?

[alexfh]

In D44858#1049928, @george.karpenkov wrote:

@alexfh OK to commit?

Not yet. A few more comments.

lib/ASTMatchers/ASTMatchersInternal.cpp

327 ↗

(On Diff #139856)

What's the point of this variable? Maybe just use its initializer directly?

334 ↗

(On Diff #139856)

const std::string & / const auto & ?

335 ↗

(On Diff #139856)

S == SelString?

342 ↗

(On Diff #139856)

What's the point of this variable? Maybe just use its initializer directly?

416 ↗

(On Diff #139856)

What was wrong with the partially qualified name here?

[george.karpenkov]

lib/ASTMatchers/ASTMatchersInternal.cpp

327 ↗

(On Diff #139856)

The principle of not having too many things magically happening in one line would be IMO violated if we write internal::Matcher<NamedDecl>(new internal::HasNameMatcher(vectorFromRefs(NameRefs)))

416 ↗

(On Diff #139856)

It does not work.
Using an AST_MATCHER_P macro in ASTMatchersInternal constructs a matcher inside the internal namespace, breaking the previous version of this function.

[alexfh]

LG

lib/ASTMatchers/ASTMatchersInternal.cpp

327 ↗

(On Diff #139856)

I wouldn't consider any of this stuff magical, but I also won't object to retaining this variable.

cfe/trunk/docs/LibASTMatchersReference.html

 
 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>Matches when at least one of the supplied string equals to the
+Selector.getAsString()
+
+ 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);

cfe/trunk/include/clang/ASTMatchers/ASTMatchers.h

 ///   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 internal::Matcher<NamedDecl>(new internal::HasNameMatcher({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

 ///   UIWebView *webView = ...
 ///   [webView stringByEvaluatingJavaScriptFromString:webViewJavascript];
 /// \endcode
 AST_MATCHER_P(ObjCMessageExpr, hasReceiverType, internal::Matcher<QualType>,
               InnerMatcher) {
   const QualType TypeDecl = Node.getReceiverType();
   return InnerMatcher.matches(TypeDecl, Finder, Builder);
 }
-  
 /// \brief Matches when BaseName == Selector.getAsString()
 ///
 ///  matcher = objCMessageExpr(hasSelector("loadHTMLString:baseURL:"));
 ///  matches the outer message expr in the code below, but NOT the message
 ///  invocation for self.bodyView.
 /// \code
 ///     [self.bodyView loadHTMLString:html baseURL:NULL];
 /// \endcode
 AST_MATCHER_P(ObjCMessageExpr, hasSelector, std::string, BaseName) {
   Selector Sel = Node.getSelector();
   return BaseName.compare(Sel.getAsString()) == 0;
 }
 
-  
+/// \brief Matches when at least one of the supplied string equals to the
+/// Selector.getAsString()
+///
+///  matcher = objCMessageExpr(hasSelector("methodA:", "methodB:"));
+///  matches both of the expressions below:
+/// \code
+///     [myObj methodA:argA];
+///     [myObj methodB:argB];
+/// \endcode
+extern const internal::VariadicFunction<internal::Matcher<ObjCMessageExpr>,
+                                        StringRef,
+                                        internal::hasAnySelectorFunc>
+                                        hasAnySelector;
+
 /// \brief Matches ObjC selectors whose name contains
 /// a substring matched by the given RegExp.
 ///  matcher = objCMessageExpr(matchesSelector("loadHTMLString\:baseURL?"));
 ///  matches the outer message expr in the code below, but NOT the message
 ///  invocation for self.bodyView.
 /// \code
 ///     [self.bodyView loadHTMLString:html baseURL:NULL];
 /// \endcode

cfe/trunk/include/clang/ASTMatchers/ASTMatchersInternal.h

private:
   const bool UseUnqualifiedMatch;
   const std::vector<std::string> Names;
 };
 
 /// \brief Trampoline function to use VariadicFunction<> to construct a
 ///        HasNameMatcher.
 Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs);
 
+/// \brief Trampoline function to use VariadicFunction<> to construct a
+///        hasAnySelector matcher.
+Matcher<ObjCMessageExpr> hasAnySelectorFunc(
+    ArrayRef<const StringRef *> NameRefs);
+
 /// \brief Matches declarations for QualType and CallExpr.
 ///
 /// Type argument DeclMatcherT is required by PolymorphicMatcherWithParam1 but
 /// not actually used.
 template <typename T, typename DeclMatcherT>
 class HasDeclarationMatcher : public WrapperMatcherInterface<T> {
   static_assert(std::is_same<DeclMatcherT, Matcher<Decl>>::value,
                 "instantiated with wrong types");

cfe/trunk/lib/ASTMatchers/ASTMatchersInternal.cpp

for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
     if (InnerMatcher.matches(DynNode, Finder, &Result)) {
       *Builder = std::move(Result);
       return true;
     }
   }
   return false;
 }
 
-Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs) {
+inline static
+std::vector<std::string> vectorFromRefs(ArrayRef<const StringRef *> NameRefs) {
   std::vector<std::string> Names;
   for (auto *Name : NameRefs)
     Names.emplace_back(*Name);
-  return internal::Matcher<NamedDecl>(
-      new internal::HasNameMatcher(std::move(Names)));
+  return Names;
+}
+
+Matcher<NamedDecl> hasAnyNameFunc(ArrayRef<const StringRef *> NameRefs) {
+  std::vector<std::string> Names = vectorFromRefs(NameRefs);
+  return internal::Matcher<NamedDecl>(new internal::HasNameMatcher(Names));
+}
+
+AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector<std::string>,
+              Matches) {
+  std::string SelString = Node.getSelector().getAsString();
+  for (const std::string &S : Matches)
+    if (S == SelString)
+      return true;
+  return false;
+}
+
+Matcher<ObjCMessageExpr> hasAnySelectorFunc(
+    ArrayRef<const StringRef *> NameRefs) {
+  return hasAnySelectorMatcher(vectorFromRefs(NameRefs));
 }
 
 HasNameMatcher::HasNameMatcher(std::vector<std::string> N)
     : UseUnqualifiedMatch(std::all_of(
           N.begin(), N.end(),
           [](StringRef Name) { return Name.find("::") == Name.npos; })),
       Names(std::move(N)) {
 #ifndef NDEBUG
for (StringRef Name : Names)
       Patterns.push_back({Name, Name.startswith("::")});
   }
 
   /// Consumes the name suffix from each pattern in the set and removes the ones
   /// that didn't match.
   /// Return true if there are still any patterns left.
   bool consumeNameSuffix(StringRef NodeName, bool CanSkip) {
     for (size_t I = 0; I < Patterns.size();) {
-      if (internal::consumeNameSuffix(Patterns[I].P, NodeName) ||
+      if (::clang::ast_matchers::internal::consumeNameSuffix(Patterns[I].P,
+                                                             NodeName) ||
           CanSkip) {
         ++I;
       } else {
         Patterns.erase(Patterns.begin() + I);
       }
     }
     return !Patterns.empty();
   }

cfe/trunk/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(hasParent);
   REGISTER_MATCHER(hasQualifier);
   REGISTER_MATCHER(hasRangeInit);
   REGISTER_MATCHER(hasReceiverType);
   REGISTER_MATCHER(hasReplacementType);
   REGISTER_MATCHER(hasReturnValue);
   REGISTER_MATCHER(hasRHS);
   REGISTER_MATCHER(hasSelector);
+  REGISTER_MATCHER(hasAnySelector);
   REGISTER_MATCHER(hasSingleDecl);
   REGISTER_MATCHER(hasSize);
   REGISTER_MATCHER(hasSizeExpr);
   REGISTER_MATCHER(hasSourceExpression);
   REGISTER_MATCHER(hasStaticStorageDuration);
   REGISTER_MATCHER(hasSyntacticForm);
   REGISTER_MATCHER(hasTargetDecl);
   REGISTER_MATCHER(hasTemplateArgument);

cfe/trunk/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

"@interface Str "
       "- (void) meth:(Str *)text { "
       "  [self contents];"
       "  Str *up = [text uppercaseString];"
       "} "
       "@end ";
   EXPECT_TRUE(matchesObjC(
     Objc1String,
     objcMessageExpr(anything())));
+  EXPECT_TRUE(matchesObjC(Objc1String,
+                          objcMessageExpr(hasAnySelector({
+                                          "contents", "meth:"}))
+
+                         ));
   EXPECT_TRUE(matchesObjC(
     Objc1String,
     objcMessageExpr(hasSelector("contents"))));
   EXPECT_TRUE(matchesObjC(
     Objc1String,
+    objcMessageExpr(hasAnySelector("contents", "contentsA"))));
+  EXPECT_FALSE(matchesObjC(
+    Objc1String,
+    objcMessageExpr(hasAnySelector("contentsB", "contentsC"))));
+  EXPECT_TRUE(matchesObjC(
+    Objc1String,
     objcMessageExpr(matchesSelector("cont*"))));
   EXPECT_FALSE(matchesObjC(
     Objc1String,
     objcMessageExpr(matchesSelector("?cont*"))));
   EXPECT_TRUE(notMatchesObjC(
     Objc1String,
     objcMessageExpr(hasSelector("contents"), hasNullSelector())));
   EXPECT_TRUE(matchesObjC(

cfe/trunk/unittests/ASTMatchers/Dynamic/ParserTest.cpp

TEST(ParserTest, FullParserTest) {
   EXPECT_EQ("1:1: Error parsing argument 1 for matcher hasInitializer.\n"
             "2:5: Error parsing argument 1 for matcher binaryOperator.\n"
             "2:20: Error building matcher hasLHS.\n"
             "2:27: Incorrect type for arg 1. "
             "(Expected = Matcher<Expr>) != (Actual = String)",
             Error.toStringFull());
 }
 
+TEST(ParserTest, VariadicMatchTest) {
+  Diagnostics Error;
+  llvm::Optional<DynTypedMatcher> OM(Parser::parseMatcherExpression(
+      "stmt(objcMessageExpr(hasAnySelector(\"methodA\", \"methodB:\")))",
+      &Error));
+  EXPECT_EQ("", Error.toStringFull());
+  auto M = OM->unconditionalConvertTo<Stmt>();
+  EXPECT_TRUE(matchesObjC("@interface I @end "
+                          "void foo(I* i) { [i methodA]; }", M));
+}
+
 std::string ParseWithError(StringRef Code) {
   Diagnostics Error;
   VariantValue Value;
   Parser::parseExpression(Code, &Value, &Error);
   return Error.toStringFull();
 }
 
 std::string ParseMatcherWithError(StringRef Code) {