[ASTMatchers] Upgrading typedef matching to c++11

[courbet]

Summary

• hasType() should be able to match the types of TypedefAliasDecl in addition to TypedefDecl, so made it work on TypedefNameDecl.
• new typedefNameDecl() matcher, which should be mostly used in place of typedefDecl (most people will want to match any typedef names, and not just those introduces through pre-c++11 typedefs).
• new typeAliasDecl() matcher, to match only the type alias syntax.

[aaron.ballman]

If we're going to add this (which I think is a good idea), perhaps we should also add typeAliasDecl() at the same time?

unittests/ASTMatchers/ASTMatchersTest.cpp

5417

Can you add a test that ensures the typedef decl matcher does not match a type alias (and vice versa)?

[courbet]

Added typeAliasDecl. More tests.

[courbet]

In D19113#401095, @aaron.ballman wrote:

If we're going to add this (which I think is a good idea), perhaps we should also add typeAliasDecl() at the same time?

Makes sense, done.

[courbet]

Example of where this is useful as a drop-in replacement for typedefDecl():

http://reviews.llvm.org/D19117

[aaron.ballman]

A few minor nits remain.

Please run clang\docs\tools\dump_ast_matchers.py to regenerate the AST matcher documentation with your changes.

unittests/ASTMatchers/ASTMatchersTest.cpp

5420

Should be EXPECT_TRUE with notMatches().

5427

Should be EXPECT_TRUE with notMatches

[courbet]

Regenerate doc, cosmetics.

[aaron.ballman]

LGTM, thank you for working on this!

[courbet]

Thanks for the review ! I don't have write access, could you please submit this for me ?

[aaron.ballman]

Committed in r266331

include/clang/ASTMatchers/ASTMatchers.h

 const internal::VariadicDynCastAllOfMatcher<Decl, TranslationUnitDecl>
     translationUnitDecl;
 
 /// \brief Matches typedef declarations.
 ///
 /// Given
 /// \code
 ///   typedef int X;
+//    using Y = int;
 /// \endcode
 /// typedefDecl()
-///   matches "typedef int X"
+///   matches "typedef int X", but not "using Y = int"
 const internal::VariadicDynCastAllOfMatcher<Decl, TypedefDecl> typedefDecl;
 
+/// \brief Matches typedef name declarations.
+///
+/// Given
+/// \code
+///   typedef int X;
+//    using Y = int;
+/// \endcode
+/// typedefNameDecl()
+///   matches "typedef int X" and "using Y = int"
+const internal::VariadicDynCastAllOfMatcher<Decl, TypedefNameDecl>
+    typedefNameDecl;
+
+/// \brief Matches type alias declarations.
+///
+/// Given
+/// \code
+///   typedef int X;
+//    using Y = int;
+/// \endcode
+/// typeAliasDecl()
+///   matches "using Y = int", but not "typedef int X"
+const internal::VariadicDynCastAllOfMatcher<Decl, TypeAliasDecl> typeAliasDecl;
+
 /// \brief Matches AST nodes that were expanded within the main-file.
 ///
 /// Example matches X but not Y
 ///   (matcher = cxxRecordDecl(isExpansionInMainFile())
 /// \code
 ///   #include <Y.h>
 ///   class X {};
 /// \endcode

 ///             and z (matcher = varDecl(hasType(cxxRecordDecl(hasName("X")))))
 ///             and U (matcher = typedefDecl(hasType(asString("int")))
 /// \code
 ///  class X {};
 ///  void y(X &x) { x; X z; }
 ///  typedef int U;
 /// \endcode
 AST_POLYMORPHIC_MATCHER_P_OVERLOAD(
-    hasType, AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, TypedefDecl, ValueDecl),
+    hasType, AST_POLYMORPHIC_SUPPORTED_TYPES(Expr, TypedefNameDecl, ValueDecl),
     internal::Matcher<QualType>, InnerMatcher, 0) {
-  return InnerMatcher.matches(internal::getUnderlyingType<NodeType>(Node),
+  return InnerMatcher.matches(internal::getUnderlyingType(Node),
                               Finder, Builder);
 }
 
 /// \brief 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

include/clang/ASTMatchers/ASTMatchersInternal.h

private:
   template <typename... ArgsT> ResultT Execute(const ArgsT &... Args) const {
     const ArgT *const ArgsArray[] = {&Args...};
     return Func(ArrayRef<const ArgT *>(ArgsArray, sizeof...(ArgsT)));
   }
 };
 
 /// \brief Unifies obtaining the underlying type of a regular node through
 /// `getType` and a TypedefNameDecl node through `getUnderlyingType`.
-template <typename NodeType>
-inline QualType getUnderlyingType(const NodeType &Node) {
+inline QualType getUnderlyingType(const Expr &Node) { return Node.getType(); }
+
+inline QualType getUnderlyingType(const ValueDecl &Node) {
   return Node.getType();
 }
 
-template <> inline QualType getUnderlyingType(const TypedefDecl &Node) {
+inline QualType getUnderlyingType(const TypedefNameDecl &Node) {
   return Node.getUnderlyingType();
 }
 
 /// \brief Internal version of BoundNodes. Holds all the bound nodes.
 class BoundNodesMap {
 public:
   /// \brief Adds \c Node to the map with key \c ID.
   ///

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(templateArgumentCountIs);
   REGISTER_MATCHER(templateSpecializationType);
   REGISTER_MATCHER(templateTypeParmType);
   REGISTER_MATCHER(throughUsingDecl);
   REGISTER_MATCHER(to);
   REGISTER_MATCHER(translationUnitDecl);
   REGISTER_MATCHER(type);
   REGISTER_MATCHER(typedefDecl);
+  REGISTER_MATCHER(typedefNameDecl);
   REGISTER_MATCHER(typedefType);
+  REGISTER_MATCHER(typeAliasDecl);
   REGISTER_MATCHER(typeLoc);
   REGISTER_MATCHER(unaryExprOrTypeTraitExpr);
   REGISTER_MATCHER(unaryOperator);
   REGISTER_MATCHER(unaryTransformType);
   REGISTER_MATCHER(unless);
   REGISTER_MATCHER(unresolvedUsingTypenameDecl);
   REGISTER_MATCHER(unresolvedUsingValueDecl);
   REGISTER_MATCHER(userDefinedLiteral);

unittests/ASTMatchers/ASTMatchersTest.cpp

TEST(HasType, MatchesTypedefDecl) {
   EXPECT_TRUE(matches("typedef const int T;",
                       typedefDecl(hasType(asString("const int")))));
   EXPECT_TRUE(notMatches("typedef const int T;",
                          typedefDecl(hasType(asString("int")))));
   EXPECT_TRUE(matches("typedef int foo; typedef foo bar;",
                       typedefDecl(hasType(asString("foo")), hasName("bar"))));
 }
 
+TEST(HasType, MatchesTypedefNameDecl) {
+  EXPECT_TRUE(matches("using X = int;", typedefNameDecl(hasType(asString("int")))));
+  EXPECT_TRUE(matches("using T = const int;",
+                      typedefNameDecl(hasType(asString("const int")))));
+  EXPECT_TRUE(notMatches("using T = const int;",
+                         typedefNameDecl(hasType(asString("int")))));
+  EXPECT_TRUE(matches("using foo = int; using bar = foo;",
+                      typedefNameDecl(hasType(asString("foo")), hasName("bar"))));
+}
+
 TEST(HasTypeLoc, MatchesDeclaratorDecls) {
   EXPECT_TRUE(matches("int x;",
                       varDecl(hasName("x"), hasTypeLoc(loc(asString("int"))))));
 
   // Make sure we don't crash on implicit constructors.
   EXPECT_TRUE(notMatches("class X {}; X x;",
                          declaratorDecl(hasTypeLoc(loc(asString("int"))))));
 }
EXPECT_FALSE(matches(
           on(declRefExpr(to(
               varDecl(hasType(recordDecl(hasName("StringRef")))).bind("var")))),
           unless(hasAncestor(stmt(hasDescendant(cxxMemberCallExpr(
               callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))),
               on(declRefExpr(to(varDecl(equalsBoundNode("var")))))))))))
           .bind("data")));
 }
 
-TEST(TypeDefDeclMatcher, Match) {
+TEST(TypedefDeclMatcher, Match) {
   EXPECT_TRUE(matches("typedef int typedefDeclTest;",
                       typedefDecl(hasName("typedefDeclTest"))));
+  EXPECT_FALSE(matches("using typedefDeclTest2 = int;",
+                       typedefDecl(hasName("typedefDeclTest2"))));
+}
+
+TEST(TypeAliasDeclMatcher, Match) {
+  EXPECT_TRUE(matches("using typeAliasTest2 = int;",
+                      typeAliasDecl(hasName("typeAliasTest2"))));
+  EXPECT_FALSE(matches("typedef int typeAliasTest;",
+                       typeAliasDecl(hasName("typeAliasTest"))));
+}
+
+TEST(TypedefNameDeclMatcher, Match) {
+  EXPECT_TRUE(matches("typedef int typedefNameDeclTest1;",
+                      typedefNameDecl(hasName("typedefNameDeclTest1"))));
+  EXPECT_TRUE(matches("using typedefNameDeclTest2 = int;",
+                      typedefNameDecl(hasName("typedefNameDeclTest2"))));
 }
 
 TEST(IsInlineMatcher, IsInline) {
   EXPECT_TRUE(matches("void g(); inline void f();",
                       functionDecl(isInline(), hasName("f"))));
   EXPECT_TRUE(matches("namespace n { inline namespace m {} }",
                       namespaceDecl(isInline(), hasName("m"))));
 }