[ASMMatchers] Extend hasName matcher when matching templates

Allow users to match all record instantiations by using <> as a wildcard

Author: njames93

clang/include/clang/ASTMatchers/ASTMatchers.h

@@ -3076,6 +3076,22 @@ inline internal::BindableMatcher<Stmt> sizeOfExpr(
 /// \code
 /// namespace a { namespace b { class X; } }
 /// \endcode
+///
+/// Qualified names in templated classes can be matched explicitly or implicity
+/// by specifying the template type or using empty angle brackets to match any
+/// template.
+///
+/// Example matches:
+/// - callExpr(callee(functionDecl(hasName("Foo<int>::Bar"))))
+/// - callExpr(callee(functionDecl(hasName("Foo<>::Bar"))))
+/// \code
+/// template<typename T> class Foo{
+/// static void Bar();
+/// };
+/// void Func() {
+/// Foo<int>::Bar();
+/// }
+/// \endcode
 inline internal::Matcher<NamedDecl> hasName(StringRef Name) {
  return internal::Matcher<NamedDecl>(
  new internal::HasNameMatcher({std::string(Name)}));

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

@@ -638,6 +638,39 @@ bool HasNameMatcher::matchesNodeFullFast(const NamedDecl &Node) const {
  return Patterns.foundMatch(/*AllowFullyQualified=*/true);
 }
 
+static std::optional<StringRef> consumePatternBack(StringRef Pattern,
+ StringRef Target) {
+ while (!Pattern.empty()) {
+ auto Index = Pattern.rfind("<>");
+ if (Index == StringRef::npos) {
+ if (Target.consume_back(Pattern))
+ return Target;
+ return {};
+ }
+ auto Suffix = Pattern.substr(Index + 1);
+ if (!Target.consume_back(Suffix))
+ return {};
+ auto BracketCount = 1;
+ while (BracketCount) {
+ if (Target.empty())
+ return {};
+ switch (Target.back()) {
+ case '<':
+ --BracketCount;
+ break;
+ case '>':
+ ++BracketCount;
+ break;
+ default:
+ break;
+ }
+ Target = Target.drop_back();
+ }
+ Pattern = Pattern.take_front(Index);
+ }
+ return Target;
+}
+
 bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const {
  const bool SkipUnwrittenCases[] = {false, true};
  for (bool SkipUnwritten : SkipUnwrittenCases) {
@@ -653,10 +686,12 @@ bool HasNameMatcher::matchesNodeFullSlow(const NamedDecl &Node) const {
 
  for (const StringRef Pattern : Names) {
  if (Pattern.starts_with("::")) {
- if (FullName == Pattern)
+ if (auto Result = consumePatternBack(Pattern, FullName);
+ Result && Result->empty()) {
  return true;
- } else if (FullName.ends_with(Pattern) &&
- FullName.drop_back(Pattern.size()).ends_with("::")) {
+ }
+ } else if (auto Result = consumePatternBack(Pattern, FullName);
+ Result && Result->ends_with("::")) {
  return true;
  }
  }

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

@@ -2664,6 +2664,41 @@ TEST_P(ASTMatchersTest, HasName_QualifiedStringMatchesThroughLinkage) {
  EXPECT_TRUE(notMatches(code, functionDecl(hasName("::test"))));
 }
 
+TEST_P(ASTMatchersTest, HasName_TemplateStrip) {
+ if (!GetParam().isCXX()) {
+ return;
+ }
+
+ StringRef Code = "template<typename T> struct Foo{void Bar() const;}; void "
+ "Func() { Foo<int> Item; Item.Bar(); }";
+
+ EXPECT_TRUE(matches(Code, callExpr(callee(cxxMethodDecl(hasName("Bar"))))));
+ EXPECT_TRUE(
+ matches(Code, callExpr(callee(cxxMethodDecl(hasName("Foo<int>::Bar"))))));
+ EXPECT_TRUE(matches(
+ Code, callExpr(callee(cxxMethodDecl(hasName("::Foo<int>::Bar"))))));
+ EXPECT_TRUE(
+ matches(Code, callExpr(callee(cxxMethodDecl(hasName("::Foo<>::Bar"))))));
+ EXPECT_TRUE(notMatches(
+ Code, callExpr(callee(cxxMethodDecl(hasName("::Foo<::Bar"))))));
+ EXPECT_TRUE(notMatches(
+ Code, callExpr(callee(cxxMethodDecl(hasName("::Foo<long>::Bar"))))));
+
+ if (GetParam().isCXX11OrLater()) {
+ Code = "template<typename T> struct Foo{void Bar() const;}; void Func() { "
+ "Foo<Foo<int>> Item; Item.Bar(); }";
+ EXPECT_TRUE(matches(Code, callExpr(callee(cxxMethodDecl(hasName("Bar"))))));
+ EXPECT_TRUE(
+ matches(Code, callExpr(callee(cxxMethodDecl(hasName("Foo<>::Bar"))))));
+ EXPECT_TRUE(matches(
+ Code, callExpr(callee(cxxMethodDecl(hasName("::Foo<>::Bar"))))));
+ EXPECT_TRUE(matches(
+ Code, callExpr(callee(cxxMethodDecl(hasName("Foo<Foo<>>::Bar"))))));
+ EXPECT_TRUE(matches(
+ Code, callExpr(callee(cxxMethodDecl(hasName("::Foo<Foo<>>::Bar"))))));
+ }
+}
+
 TEST_P(ASTMatchersTest, HasAnyName) {
  if (!GetParam().isCXX()) {
  // FIXME: Add a test for `hasAnyName()` that does not depend on C++.