[ASTMatchers] Make hasOverloadedOperatorName also match freestanding overloads.

[bkramer]

Summary

Freestanding overloads are represented as FunctionDecls in the AST, make
the matcher also match them.

[djasper]

Looks good. Thank you!

[bkramer]

Closed by commit rL212940 (authored by d0k).

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

 ///   A a;
 ///   a << a;   // <-- This matches
 /// \endcode
 ///
 /// \c operatorCallExpr(hasOverloadedOperatorName("<<"))) matches the specified
 /// line and \c recordDecl(hasMethod(hasOverloadedOperatorName("*"))) matches
 /// the declaration of \c A.
 ///
-/// Usable as: Matcher<CXXOperatorCallExpr>, Matcher<CXXMethodDecl>
+/// Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl>
 inline internal::PolymorphicMatcherWithParam1<
     internal::HasOverloadedOperatorNameMatcher, StringRef,
-    AST_POLYMORPHIC_SUPPORTED_TYPES_2(CXXOperatorCallExpr, CXXMethodDecl)>
+    AST_POLYMORPHIC_SUPPORTED_TYPES_2(CXXOperatorCallExpr, FunctionDecl)>
 hasOverloadedOperatorName(const StringRef Name) {
   return internal::PolymorphicMatcherWithParam1<
       internal::HasOverloadedOperatorNameMatcher, StringRef,
-      AST_POLYMORPHIC_SUPPORTED_TYPES_2(CXXOperatorCallExpr, CXXMethodDecl)>(
+      AST_POLYMORPHIC_SUPPORTED_TYPES_2(CXXOperatorCallExpr, FunctionDecl)>(
       Name);
 }
 
 /// \brief Matches C++ classes that are directly or indirectly derived from
 /// a class matching \c Base.
 ///
 /// Note that a class is not considered to be derived from itself.
 ///

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

 
 /// \brief Matches overloaded operators with a specific name.
 ///
 /// The type argument ArgT is not used by this matcher but is used by
 /// PolymorphicMatcherWithParam1 and should be StringRef.
 template <typename T, typename ArgT>
 class HasOverloadedOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
   static_assert(std::is_same<T, CXXOperatorCallExpr>::value ||
-                std::is_same<T, CXXMethodDecl>::value,
+                std::is_base_of<FunctionDecl, T>::value,
                 "unsupported class for matcher");
   static_assert(std::is_same<ArgT, StringRef>::value,
                 "argument type must be StringRef");
 
 public:
   explicit HasOverloadedOperatorNameMatcher(const StringRef Name)
       : SingleNodeMatcherInterface<T>(), Name(Name) {}
 
   bool matchesNode(const T &Node) const override {
     return matchesSpecialized(Node);
   }
 
 private:
 
   /// \brief CXXOperatorCallExpr exist only for calls to overloaded operators
   /// so this function returns true if the call is to an operator of the given
   /// name.
   bool matchesSpecialized(const CXXOperatorCallExpr &Node) const {
     return getOperatorSpelling(Node.getOperator()) == Name;
   }
 
   /// \brief Returns true only if CXXMethodDecl represents an overloaded
   /// operator and has the given operator name.
-  bool matchesSpecialized(const CXXMethodDecl &Node) const {
+  bool matchesSpecialized(const FunctionDecl &Node) const {
     return Node.isOverloadedOperator() &&
            getOperatorSpelling(Node.getOverloadedOperator()) == Name;
   }
 
   std::string Name;
 };
 
 /// \brief Matches declarations for QualType and CallExpr.

cfe/trunk/unittests/ASTMatchers/ASTMatchersTest.cpp

EXPECT_TRUE(matches("class Y { }; "
               "bool operator&&(Y x, Y y) { return true; }; "
               "Y a; Y b; bool c = a && b;", OpCallAndAnd));
   StatementMatcher OpCallLessLess =
       operatorCallExpr(hasOverloadedOperatorName("<<"));
   EXPECT_TRUE(notMatches("class Y { }; "
               "bool operator&&(Y x, Y y) { return true; }; "
               "Y a; Y b; bool c = a && b;",
               OpCallLessLess));
+  StatementMatcher OpStarCall =
+      operatorCallExpr(hasOverloadedOperatorName("*"));
+  EXPECT_TRUE(matches("class Y; int operator*(Y &); void f(Y &y) { *y; }",
+              OpStarCall));
   DeclarationMatcher ClassWithOpStar =
     recordDecl(hasMethod(hasOverloadedOperatorName("*")));
   EXPECT_TRUE(matches("class Y { int operator*(); };",
                       ClassWithOpStar));
   EXPECT_TRUE(notMatches("class Y { void myOperator(); };",
               ClassWithOpStar)) ;
+  DeclarationMatcher AnyOpStar = functionDecl(hasOverloadedOperatorName("*"));
+  EXPECT_TRUE(matches("class Y; int operator*(Y &);", AnyOpStar));
+  EXPECT_TRUE(matches("class Y { int operator*(); };", AnyOpStar));
 }
 
 TEST(Matcher, NestedOverloadedOperatorCalls) {
   EXPECT_TRUE(matchAndVerifyResultTrue(
         "class Y { }; "
         "Y& operator&&(Y& x, Y& y) { return x; }; "
         "Y a; Y b; Y c; Y d = a && b && c;",
         operatorCallExpr(hasOverloadedOperatorName("&&")).bind("x"),