[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 ↗

(On Diff #151570)

In which cases can getUnderlyingType return a null type?

[aaron.ballman]

LGTM aside from some minor nits.

include/clang/ASTMatchers/ASTMatchers.h

2900–2904 ↗

(On Diff #151570)

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

include/clang/ASTMatchers/ASTMatchersInternal.h

128 ↗

(On Diff #151570)

tsi -> TSI

[dlj]

include/clang/ASTMatchers/ASTMatchers.h

2900–2904 ↗

(On Diff #151570)

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 ↗

(On Diff #151570)

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

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

 }
 
 /// Matches if the expression's or declaration's type matches a type
 /// matcher.
 ///
 /// 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())
     return InnerMatcher.matches(QT, Finder, Builder);
   return false;
 }
 
 /// Overloaded to match the declaration of the expression's or value
 /// declaration's type.
 ///
 /// In case of a value declaration (for example a variable declaration),
 /// this resolves one layer of indirection. For example, in the value
 /// declaration "X x;", cxxRecordDecl(hasName("X")) matches the declaration of
 /// X, while varDecl(hasType(cxxRecordDecl(hasName("X")))) matches the
 /// declaration of x.
 ///
 /// 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
 /// the inner matcher.
 ///
 /// Given
 /// \code
 ///   int x;

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

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
 #define LLVM_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"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"

 
 /// Unifies obtaining the underlying type of a regular node through
 /// `getType` and a TypedefNameDecl node through `getUnderlyingType`.
 inline QualType getUnderlyingType(const Expr &Node) { return Node.getType(); }
 
 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..
 inline const FunctionProtoType *
 getFunctionProtoType(const FunctionProtoType &Node) {
   return &Node;
 }
 

cfe/trunk/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

 
 TEST(ValueDecl, Matches) {
   EXPECT_TRUE(matches("enum EnumType { EnumValue };",
                       valueDecl(hasType(asString("enum EnumType")))));
   EXPECT_TRUE(matches("void FunctionDecl();",
                       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"))));
 }
 
 TEST(Enum, MatchesEnums) {
   EXPECT_TRUE(matches("enum X {};", enumDecl(hasName("X"))));
 }