[ASTMatchers] Add support for matching the type of a friend decl.

[dlj]

Summary

This allows matchers like:

friendDecl(hasType(cxxRecordDecl(...)))
friendDecl(hasType(asString(...)))

It seems that hasType is probably the most reasonable narrowing matcher to
overload, since it is already used to narrow to other declaration kinds.

[klimek]

include/clang/ASTMatchers/ASTMatchers.h

2904

In which cases can getUnderlyingType return a null type?

[aaron.ballman]

LGTM aside from some minor nits.

include/clang/ASTMatchers/ASTMatchers.h

2900–2904

I actually prefer the previous formatting, can you restore that?

include/clang/ASTMatchers/ASTMatchersInternal.h

128

tsi -> TSI

[dlj]

include/clang/ASTMatchers/ASTMatchers.h

2900–2904

Hmmm, it barely fits in 80 cols if I use the previous flow, but looks worse to me (it adds another line just for FriendDecl). I've updated to exactly what clang-format prefers, which happens to be fairly consistent with the other declaration of hasType.

2904

QT can be null for a FriendDecl that that doesn't name a type. That seems to DTRT here.

[dlj]

Ping for Manuel...

[klimek]

lg, thx

include/clang/ASTMatchers/ASTMatchers.h

 /// Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
 ///             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
 ///             and U (matcher = typedefDecl(hasType(asString("int")))
+///             and friend class X (matcher = friendDecl(hasType("X"))
 /// \code
 ///  class X {};
 ///  void y(X &x) { x; X z; }
 ///  typedef int U;
+///  class Y { friend class X; };
 /// \endcode
 AST_POLYMORPHIC_MATCHER_P_OVERLOAD(
-    hasType, AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, TypedefNameDecl, ValueDecl),
+    hasType,
+    AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, FriendDecl, TypedefNameDecl,
+                                    ValueDecl),
     internal::Matcher<QualType>, InnerMatcher, 0) {
   QualType QT = internal::getUnderlyingType(Node);
   if (!QT.isNull())

 ///
 /// Example matches x (matcher = expr(hasType(cxxRecordDecl(hasName("X")))))
 ///             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
+///             and friend class X (matcher = friendDecl(hasType("X"))
 /// \code
 ///  class X {};
 ///  void y(X &x) { x; X z; }
+///  class Y { friend class X; };
 /// \endcode
 ///
 /// Usable as: Matcher<Expr>, Matcher<ValueDecl>
-AST_POLYMORPHIC_MATCHER_P_OVERLOAD(hasType,
-                                   AST_POLYMORPHIC_SUPPORTED_TYPES(Expr,
-                                                                   ValueDecl),
-                                   internal::Matcher<Decl>, InnerMatcher, 1) {
-  return qualType(hasDeclaration(InnerMatcher))
-      .matches(Node.getType(), Finder, Builder);
+AST_POLYMORPHIC_MATCHER_P_OVERLOAD(
+    hasType,
+    AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, FriendDecl, ValueDecl),
+  QualType QT = internal::getUnderlyingType(Node);
+  if (!QT.isNull())
+    return qualType(hasDeclaration(InnerMatcher)).matches(QT, Finder, Builder);
+  return false;
 }
 
 /// Matches if the type location of the declarator decl's type matches

include/clang/ASTMatchers/ASTMatchersInternal.h

 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"

 inline QualType getUnderlyingType(const ValueDecl &Node) {
   return Node.getType();
 }
-
 inline QualType getUnderlyingType(const TypedefNameDecl &Node) {
   return Node.getUnderlyingType();
 }
+inline QualType getUnderlyingType(const FriendDecl &Node) {
+  if (const TypeSourceInfo *tsi = Node.getFriendType())
+    return tsi->getType();
+  return QualType();
+}
 
 /// Unifies obtaining the FunctionProtoType pointer from both
 /// FunctionProtoType and FunctionDecl nodes..

unittests/ASTMatchers/ASTMatchersNodeTest.cpp

                       valueDecl(hasType(asString("void (void)")))));
 }
 
+TEST(FriendDecl, Matches) {
+  EXPECT_TRUE(matches("class Y { friend class X; };",
+                      friendDecl(hasType(asString("class X")))));
+  EXPECT_TRUE(matches("class Y { friend class X; };",
+                      friendDecl(hasType(recordDecl(hasName("X"))))));
+
+  EXPECT_TRUE(matches("class Y { friend void f(); };",
+                      functionDecl(hasName("f"), hasParent(friendDecl()))));
+}
+
 TEST(Enum, DoesNotMatchClasses) {
   EXPECT_TRUE(notMatches("class X {};", enumDecl(hasName("X"))));
 }