[ASTMatchers] Add matcher hasAnyName.

[sbenza]

Summary

Add matcher hasAnyName as an optimization over anyOf(hasName(),...)

[klimek]

lib/ASTMatchers/ASTMatchersInternal.cpp

408 ↗

(On Diff #47704)

That empty line confuses me for some reason.

443 ↗

(On Diff #47704)

Here and elsewhere: please annotate all bool parameters with comments about their names, or use enums /*AllowFullyQualified=*/

[alexfh]

include/clang/ASTMatchers/ASTMatchersInternal.h

644 ↗

(On Diff #47704)

Why not ArrayRef<StringRef>?

[bkramer]

include/clang/ASTMatchers/ASTMatchersInternal.h

644 ↗

(On Diff #47704)

That's an artifact of how llvm::VariadicFunction works. It gives you an array ref of pointers to the arguments.

[alexfh]

include/clang/ASTMatchers/ASTMatchersInternal.h

644 ↗

(On Diff #47704)

Thanks! Good to know. Maybe a add a comment or is it just me who doesn't know this?

[sbenza]

Minor fixes:

• Add argument comments
• Move vector contructor to callers to simply API of HasNameMatcher

include/clang/ASTMatchers/ASTMatchersInternal.h

644 ↗

(On Diff #47704)

No reason to leak the VariadicFunction design into here.
I moved the transformation into std::vector<> to the caller.

[alexfh]

Looks good. Thanks!

(I suppose, Manuel has no substantial comments on this, since he has already seen the patch).

cfe/trunk/docs/LibASTMatchersReference.html

Given:
   int *ip = 0;
   int i = 0;
 expr(nullPointerConstant())
   matches the initializer for v1, v2, v3, cp, and ip. Does not match the
   initializer for i.
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;internal::Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;&gt;</td><td class="name" onclick="toggle('hasAnyName0')"><a name="hasAnyName0Anchor">hasAnyName</a></td><td>StringRef, ..., StringRef</td></tr>
+<tr><td colspan="4" class="doc" id="hasAnyName0"><pre>Matches NamedDecl nodes that have any of the specified names.
+
+This matcher is only provided as a performance optimization of hasName.
+    hasAnyName(a, b, c)
+ is equivalent 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_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/docs/tools/dump_ast_matchers.py

m = re.match(
         r"""^.*ArgumentAdaptingMatcherFunc<.*>\s*(?:LLVM_ATTRIBUTE_UNUSED\s*)
               ([a-zA-Z]*)\s*=\s*{};$""",
         declaration, flags=re.X)
     if m:
       name = m.groups()[0]
       add_matcher('*', name, 'Matcher<*>', comment)
       return
 
+    # Parse Variadic functions.
+    m = re.match(
+        r"""^.*llvm::VariadicFunction\s*<\s*([^,]+),\s*([^,]+),\s*[^>]+>\s*
+              ([a-zA-Z]*)\s*=\s*{.*};$""",
+        declaration, flags=re.X)
+    if m:
+      result, arg, name = m.groups()[:3]
+      add_matcher(result, name, '%s, ..., %s' % (arg, arg), comment)
+      return
+
     # Parse Variadic operator matchers.
     m = re.match(
         r"""^.*VariadicOperatorMatcherFunc\s*<\s*([^,]+),\s*([^\s>]+)\s*>\s*
               ([a-zA-Z]*)\s*=\s*{.*};$""",
         declaration, flags=re.X)
     if m:
       min_args, max_args, name = m.groups()[:3]
       if max_args == '1':

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

 /// \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(std::string Name) {
-  return internal::Matcher<NamedDecl>(
-      new internal::HasNameMatcher(std::move(Name)));
+inline internal::Matcher<NamedDecl> hasName(const std::string &Name) {
+  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
+///  is equivalent to, but faster than
+/// \code
+///     anyOf(hasName(a), hasName(b), hasName(c))
+/// \endcode
+const llvm::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
+                             internal::hasAnyNameFunc>
+    hasAnyName = {};
+
 /// \brief Matches NamedDecl nodes whose fully qualified names contain
 /// a substring matched by the given RegExp.
 ///
 /// 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 (regexp == "::X")

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

return Node.isOverloadedOperator() &&
            getOperatorSpelling(Node.getOverloadedOperator()) == Name;
   }
 
   std::string Name;
 };
 
 /// \brief Matches named declarations with a specific name.
 ///
-/// See \c hasName() in ASTMatchers.h for details.
+/// See \c hasName() and \c hasAnyName() in ASTMatchers.h for details.
 class HasNameMatcher : public SingleNodeMatcherInterface<NamedDecl> {
  public:
-  explicit HasNameMatcher(std::string Name);
+  explicit HasNameMatcher(std::vector<std::string> Names);
 
   bool matchesNode(const NamedDecl &Node) const override;
 
  private:
   /// \brief Unqualified match routine.
   ///
   /// It is much faster than the full match, but it only works for unqualified
   /// matches.
private:
   /// \brief Full match routine
   ///
   /// It generates the fully qualified name of the declaration (which is
   /// expensive) before trying to match.
   /// It is slower but simple and works on all cases.
   bool matchesNodeFullSlow(const NamedDecl &Node) const;
 
   const bool UseUnqualifiedMatch;
-  const std::string Name;
+  const std::vector<std::string> Names;
 };
 
+/// \brief Trampoline function to use VariadicFunction<> to construct a
+///        HasNameMatcher.
+Matcher<NamedDecl> hasAnyNameFunc(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

 //===--- ASTMatchersInternal.cpp - Structural query framework -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  Implements the base layer of the matcher framework.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ManagedStatic.h"
 
 namespace clang {
 namespace ast_matchers {
 namespace internal {
 
 bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode,
                       ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
     if (InnerMatcher.matches(DynNode, Finder, &Result)) {
       *Builder = std::move(Result);
       return true;
     }
   }
   return false;
 }
 
-HasNameMatcher::HasNameMatcher(std::string NameRef)
-    : UseUnqualifiedMatch(NameRef.find("::") == NameRef.npos),
-      Name(std::move(NameRef)) {
+Matcher<NamedDecl> hasAnyNameFunc(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)));
+}
+
+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)) {
+  for (StringRef Name : Names)
     assert(!Name.empty());
 }
 
 namespace {
 
-bool ConsumeNameSuffix(StringRef &FullName, StringRef Suffix) {
+bool consumeNameSuffix(StringRef &FullName, StringRef Suffix) {
   StringRef Name = FullName;
   if (!Name.endswith(Suffix))
     return false;
   Name = Name.drop_back(Suffix.size());
   if (!Name.empty()) {
     if (!Name.endswith("::"))
       return false;
     Name = Name.drop_back(2);
   }
   FullName = Name;
   return true;
 }
 
-bool ConsumeNodeName(StringRef &Name, const NamedDecl &Node) {
+StringRef getNodeName(const NamedDecl &Node, llvm::SmallString<128> &Scratch) {
   // Simple name.
   if (Node.getIdentifier())
-    return ConsumeNameSuffix(Name, Node.getName());
+    return Node.getName();
 
   if (Node.getDeclName()) {
     // Name needs to be constructed.
-    llvm::SmallString<128> NodeName;
-    llvm::raw_svector_ostream OS(NodeName);
+    Scratch.clear();
+    llvm::raw_svector_ostream OS(Scratch);
     Node.printName(OS);
-    return ConsumeNameSuffix(Name, OS.str());
+    return OS.str();
+  }
+
+  return "(anonymous)";
+}
+
+StringRef getNodeName(const RecordDecl &Node, llvm::SmallString<128> &Scratch) {
+  if (Node.getIdentifier()) {
+    return Node.getName();
+  }
+  Scratch.clear();
+  return ("(anonymous " + Node.getKindName() + ")").toStringRef(Scratch);
+}
+
+StringRef getNodeName(const NamespaceDecl &Node,
+                      llvm::SmallString<128> &Scratch) {
+  return Node.isAnonymousNamespace() ? "(anonymous namespace)" : Node.getName();
+}
+
+
+class PatternSet {
+public:
+  PatternSet(ArrayRef<std::string> Names) {
+    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].Pattern, NodeName) ||
+          CanSkip) {
+        ++I;
+      } else {
+        Patterns.erase(Patterns.begin() + I);
+      }
+    }
+    return !Patterns.empty();
   }
 
-  return ConsumeNameSuffix(Name, "(anonymous)");
+  /// Check if any of the patterns are a match.
+  /// A match will be a pattern that was fully consumed, that also matches the
+  /// 'fully qualified' requirement.
+  bool foundMatch(bool AllowFullyQualified) const {
+    for (auto& P: Patterns)
+      if (P.Pattern.empty() && (AllowFullyQualified || !P.IsFullyQualified))
+        return true;
+    return false;
   }
 
+private:
+  struct Pattern {
+    StringRef Pattern;
+    bool IsFullyQualified;
+  };
+  llvm::SmallVector<Pattern, 8> Patterns;
+};
+
 }  // namespace
 
 bool HasNameMatcher::matchesNodeUnqualified(const NamedDecl &Node) const {
   assert(UseUnqualifiedMatch);
-  StringRef NodeName = Name;
-  return ConsumeNodeName(NodeName, Node) && NodeName.empty();
+  llvm::SmallString<128> Scratch;
+  StringRef NodeName = getNodeName(Node, Scratch);
+  return std::any_of(Names.begin(), Names.end(), [&](StringRef Name) {
+    return consumeNameSuffix(Name, NodeName) && Name.empty();
+  });
 }
 
 bool HasNameMatcher::matchesNodeFullFast(const NamedDecl &Node) const {
+  PatternSet Patterns(Names);
+  llvm::SmallString<128> Scratch;
+
   // This function is copied and adapted from NamedDecl::printQualifiedName()
   // By matching each part individually we optimize in a couple of ways:
   //  - We can exit early on the first failure.
   //  - We can skip inline/anonymous namespaces without another pass.
   //  - We print one name at a time, reducing the chance of overflowing the
   //    inlined space of the SmallString.
-  StringRef Pattern = Name;
-  const bool IsFullyQualified = Pattern.startswith("::");
 
   // First, match the name.
-  if (!ConsumeNodeName(Pattern, Node))
+  if (!Patterns.consumeNameSuffix(getNodeName(Node, Scratch),
+                                  /*CanSkip=*/false))
     return false;
 
   // Try to match each declaration context.
   // We are allowed to skip anonymous and inline namespaces if they don't match.
   const DeclContext *Ctx = Node.getDeclContext();
 
   if (Ctx->isFunctionOrMethod())
-    return Pattern.empty() && !IsFullyQualified;
+    return Patterns.foundMatch(/*AllowFullyQualified=*/false);
 
-  for (; !Pattern.empty() && Ctx && isa<NamedDecl>(Ctx);
-       Ctx = Ctx->getParent()) {
-    if (const auto *ND = dyn_cast<NamespaceDecl>(Ctx)) {
-      StringRef NSName =
-          ND->isAnonymousNamespace() ? "(anonymous namespace)" : ND->getName();
+  for (; Ctx && isa<NamedDecl>(Ctx); Ctx = Ctx->getParent()) {
+    if (Patterns.foundMatch(/*AllowFullyQualified=*/false))
+      return true;
 
-      // If it matches, continue.
-      if (ConsumeNameSuffix(Pattern, NSName))
-        continue;
-      // If it didn't match but we can skip it, continue.
-      if (ND->isAnonymousNamespace() || ND->isInline())
+    if (const auto *ND = dyn_cast<NamespaceDecl>(Ctx)) {
+      // If it matches (or we can skip it), continue.
+      if (Patterns.consumeNameSuffix(getNodeName(*ND, Scratch),
+                                     /*CanSkip=*/ND->isAnonymousNamespace() ||
+                                         ND->isInline()))
         continue;
-
       return false;
     }
     if (const auto *RD = dyn_cast<RecordDecl>(Ctx)) {
       if (!isa<ClassTemplateSpecializationDecl>(Ctx)) {
-        if (RD->getIdentifier()) {
-          if (ConsumeNameSuffix(Pattern, RD->getName()))
-            continue;
-        } else {
-          llvm::SmallString<128> NodeName;
-          NodeName += StringRef("(anonymous ");
-          NodeName += RD->getKindName();
-          NodeName += ')';
-          if (ConsumeNameSuffix(Pattern, NodeName))
-            continue;
-        }
+        if (Patterns.consumeNameSuffix(getNodeName(*RD, Scratch),
+                                       /*CanSkip=*/false))
 
         return false;
       }
     }
 
     // We don't know how to deal with this DeclContext.
     // Fallback to the slow version of the code.
     return matchesNodeFullSlow(Node);
   }
 
-  // If we are fully qualified, we must not have any leftover context.
-  if (IsFullyQualified && Ctx && isa<NamedDecl>(Ctx))
-    return false;
-
-  return Pattern.empty();
+  return Patterns.foundMatch(/*AllowFullyQualified=*/true);
 }
 
 bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const {
-  const StringRef Pattern = Name;
-
   const bool SkipUnwrittenCases[] = {false, true};
   for (bool SkipUnwritten : SkipUnwrittenCases) {
     llvm::SmallString<128> NodeName = StringRef("::");
     llvm::raw_svector_ostream OS(NodeName);
 
     if (SkipUnwritten) {
       PrintingPolicy Policy = Node.getASTContext().getPrintingPolicy();
       Policy.SuppressUnwrittenScope = true;
       Node.printQualifiedName(OS, Policy);
     } else {
       Node.printQualifiedName(OS);
     }
 
     const StringRef FullName = OS.str();
 
+    for (const StringRef Pattern : Names) {
       if (Pattern.startswith("::")) {
         if (FullName == Pattern)
           return true;
       } else if (FullName.endswith(Pattern) &&
                  FullName.drop_back(Pattern.size()).endswith("::")) {
         return true;
       }
     }
+  }
 
   return false;
 }
 
 bool HasNameMatcher::matchesNode(const NamedDecl &Node) const {
   assert(matchesNodeFullFast(Node) == matchesNodeFullSlow(Node));
   if (UseUnqualifiedMatch) {
     assert(matchesNodeUnqualified(Node) == matchesNodeFullFast(Node));
     return matchesNodeUnqualified(Node);
   }
   return matchesNodeFullFast(Node);
 }
 
 } // end namespace internal
 } // end namespace ast_matchers
 } // end namespace clang

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

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(functionTemplateDecl);
   REGISTER_MATCHER(functionType);
   REGISTER_MATCHER(gnuNullExpr);
   REGISTER_MATCHER(gotoStmt);
   REGISTER_MATCHER(has);
   REGISTER_MATCHER(hasAncestor);
   REGISTER_MATCHER(hasAnyArgument);
   REGISTER_MATCHER(hasAnyConstructorInitializer);
+  REGISTER_MATCHER(hasAnyName);
   REGISTER_MATCHER(hasAnyParameter);
   REGISTER_MATCHER(hasAnySubstatement);
   REGISTER_MATCHER(hasAnyTemplateArgument);
   REGISTER_MATCHER(hasAnyUsingShadowDecl);
   REGISTER_MATCHER(hasArgument);
   REGISTER_MATCHER(hasArgumentOfType);
   REGISTER_MATCHER(hasAttr);
   REGISTER_MATCHER(hasAutomaticStorageDuration);

cfe/trunk/unittests/ASTMatchers/ASTMatchersTest.cpp

TEST(Matcher, HasNameSupportsFunctionScope) {
 
   EXPECT_TRUE(matches(code, fieldDecl(hasName("m"))));
   EXPECT_TRUE(matches(code, fieldDecl(hasName("S::m"))));
   EXPECT_TRUE(matches(code, fieldDecl(hasName("F(int)::S::m"))));
   EXPECT_TRUE(matches(code, fieldDecl(hasName("a::F(int)::S::m"))));
   EXPECT_TRUE(matches(code, fieldDecl(hasName("::a::F(int)::S::m"))));
 }
 
+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(notMatches(Code, recordDecl(hasAnyName("::C", "::b::C"))));
+  EXPECT_TRUE(
+      matches(Code, recordDecl(hasAnyName("::C", "::b::C", "::a::b::C"))));
+}
+
 TEST(Matcher, IsDefinition) {
   DeclarationMatcher DefinitionOfClassA =
       recordDecl(hasName("A"), isDefinition());
   EXPECT_TRUE(matches("class A {};", DefinitionOfClassA));
   EXPECT_TRUE(notMatches("class A;", DefinitionOfClassA));
 
   DeclarationMatcher DefinitionOfVariableA =
       varDecl(hasName("a"), isDefinition());