[ASTMatchers] Allow isImplicit on all Decls.

[joey]

Summary

isImplicit is currently for CXXConstructorDecls only, but there are other Decls that can be implicit.

I tried to write a small test, but if there is a better test let me know.

[pcc]

unittests/ASTMatchers/ASTMatchersTest.cpp

1776

This comment does not match what you are testing for.

[joey]

Fixed the comment! Ok now?

[pcc]

LGTM

The only comment I would make is that in principle the compiler could change the assumption you are making in the test case about the implicit assignment operator. But (1) that observation is equally true of the other test cases (2) it would be easy to fix, say by taking a member pointer reference to the assignment operator.

[klimek]

lg

[joey]

Thanks guys, r209006!

include/clang/ASTMatchers/ASTMatchers.h

 ///   };
 /// \endcode
 /// fieldDecl(isPrivate())
 ///   matches 'int c;' 
 AST_MATCHER(Decl, isPrivate) {
   return Node.getAccess() == AS_private;
 }
 
+/// \brief Matches a declaration that has been implicitly added
+/// by the compiler (eg. implicit default/copy constructors).
+AST_MATCHER(Decl, isImplicit) {
+  return Node.isImplicit();
+}
+
 /// \brief Matches classTemplateSpecializations that have at least one
 /// TemplateArgument matching the given InnerMatcher.
 ///
 /// Given
 /// \code
 ///   template<typename T> class A {};
 ///   template<> class A<double> {};
 ///   A<int> a;

 ///   };
 /// \endcode
 /// constructorDecl(hasAnyConstructorInitializer(isWritten()))
 ///   will match Foo(int), but not Foo()
 AST_MATCHER(CXXCtorInitializer, isWritten) {
   return Node.isWritten();
 }
 
-/// \brief Matches a constructor declaration that has been implicitly added
-/// by the compiler (eg. implicit default/copy constructors).
-AST_MATCHER(CXXConstructorDecl, isImplicit) {
-  return Node.isImplicit();
-}
-
 /// \brief Matches any argument of a call expression or a constructor call
 /// expression.
 ///
 /// Given
 /// \code
 ///   void x(int, int, int) { int y; x(1, y, 42); }
 /// \endcode
 /// callExpr(hasAnyArgument(declRefExpr()))

unittests/ASTMatchers/ASTMatchersTest.cpp

TEST(ConstructorDeclaration, IsImplicit) {
   // compiler (it is not needed).
   EXPECT_TRUE(notMatches("class Foo { };",
                          constructorDecl(isImplicit())));
   // The compiler added the implicit default constructor.
   EXPECT_TRUE(matches("class Foo { }; Foo* f = new Foo();",
                       constructorDecl(isImplicit())));
   EXPECT_TRUE(matches("class Foo { Foo(){} };",
                       constructorDecl(unless(isImplicit()))));
+  // The compiler added an implicit assignment operator.
+  EXPECT_TRUE(matches("struct A { int x; } a = {0}, b = a; void f() { a = b; }",
+                      methodDecl(isImplicit(), hasName("operator="))));
 }
 
 TEST(DestructorDeclaration, MatchesVirtualDestructor) {
   EXPECT_TRUE(matches("class Foo { virtual ~Foo(); };",
                       destructorDecl(ofClass(hasName("Foo")))));
 }
 
 TEST(DestructorDeclaration, DoesNotMatchImplicitDestructor) {