[ASTMatcher] Add matcher for 'MacroQualifiedType'

[danix800]

Summary

Add matcher for 'MacroQualifiedType'

[danix800]

Add import of MacroQualifiedType.

[aaron.ballman]

clang/include/clang/ASTMatchers/ASTMatchers.h

7261

How about: Matches qualified types when the qualifier is applied via a macro.

and then a second example like:

int * const qual_ptr;

#define nonnull _Nonnull
int * const nonnull macro_qual_ptr;

where we match macro_qual_ptr but not qual_ptr.

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

1842–1847

I'd appreciate extra test coverage from the example I posted above.

[danix800]

clang/include/clang/ASTMatchers/ASTMatchers.h

7261

How about: Matches qualified types when the qualifier is applied via a macro.

Forgive my broken English! :-)

and then a second example like:

int * const qual_ptr;

#define nonnull _Nonnull
int * const nonnull macro_qual_ptr;

where we match macro_qual_ptr but not qual_ptr.

Thanks for reminding me of the counter-example, it's critical for better test coverage.

I'll pertain to the original one but with counter-example appended, because the macro
nonnull in this case will not generate a MacroQualifiedType for macro_qual_ptr.

[danix800]

1. Improve matcher description
2. Add a counter-example for test

[aaron.ballman]

LGTM!

clang/include/clang/ASTMatchers/ASTMatchers.h

7261

Forgive my broken English! :-)

There's nothing to forgive! :-)

I'll pertain to the original one but with counter-example appended, because the macro nonnull in this case will not generate a MacroQualifiedType for macro_qual_ptr.

Oh, interesting! (I didn't test my example, so that's neat to learn.)

clang/docs/LibASTMatchersReference.html

Given:
   auto &&f = 2;
   int g = 5;
 
 lValueReferenceType() matches the types of b, d, and e. e is
 matched since the type is deduced as int& by reference collapsing rules.
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('macroQualifiedType0')"><a name="macroQualifiedType0Anchor">macroQualifiedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MacroQualifiedType.html">MacroQualifiedType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="macroQualifiedType0"><pre>Matches qualified types when the qualifier is applied via a macro.
+
+Given
+  #define CDECL __attribute__((cdecl))
+  typedef void (CDECL *X)();
+  typedef void (__attribute__((cdecl)) *Y)();
+macroQualifiedType()
+  matches the type of the typedef declaration of X but not Y.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('memberPointerType0')"><a name="memberPointerType0Anchor">memberPointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="memberPointerType0"><pre>Matches member pointer types.
 Given
   struct A { int i; }
   A::* ptr = A::i;
 memberPointerType()
   matches "A::* ptr"
 </pre></td></tr>

clang/docs/ReleaseNotes.rst

 - Add ``__builtin_elementwise_pow`` builtin for floating point types only.
 - Add ``__builtin_elementwise_bitreverse`` builtin for integer types only.
 - Add ``__builtin_elementwise_sqrt`` builtin for floating point types only.
 
 AST Matchers
 ------------
 - Add ``convertVectorExpr``.
 - Add ``dependentSizedExtVectorType``.
+- Add ``macroQualifiedType``.
 
 clang-format
 ------------
 
 libclang
 --------
 
 - Exposed arguments of ``clang::annotate``.

clang/include/clang/ASTMatchers/ASTMatchers.h

 /// Given
 /// \code
 ///   typedef int X;
 /// \endcode
 /// typedefType()
 ///   matches "typedef int X"
 extern const AstTypeMatcher<TypedefType> typedefType;
 
+/// Matches qualified types when the qualifier is applied via a macro.
+///
+/// Given
+/// \code
+///   #define CDECL __attribute__((cdecl))
+///   typedef void (CDECL *X)();
+///   typedef void (__attribute__((cdecl)) *Y)();
+/// \endcode
+/// macroQualifiedType()
+///   matches the type of the typedef declaration of \c X but not \c Y.
+extern const AstTypeMatcher<MacroQualifiedType> macroQualifiedType;
+
 /// Matches enum types.
 ///
 /// Given
 /// \code
 ///   enum C { Green };
 ///   enum class S { Red };
 ///
 ///   C c;

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

 const AstTypeMatcher<VariableArrayType> variableArrayType;
 const AstTypeMatcher<AtomicType> atomicType;
 const AstTypeMatcher<AutoType> autoType;
 const AstTypeMatcher<DecltypeType> decltypeType;
 const AstTypeMatcher<FunctionType> functionType;
 const AstTypeMatcher<FunctionProtoType> functionProtoType;
 const AstTypeMatcher<ParenType> parenType;
 const AstTypeMatcher<BlockPointerType> blockPointerType;
+const AstTypeMatcher<MacroQualifiedType> macroQualifiedType;
 const AstTypeMatcher<MemberPointerType> memberPointerType;
 const AstTypeMatcher<PointerType> pointerType;
 const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
 const AstTypeMatcher<ReferenceType> referenceType;
 const AstTypeMatcher<LValueReferenceType> lValueReferenceType;
 const AstTypeMatcher<RValueReferenceType> rValueReferenceType;
 const AstTypeMatcher<TypedefType> typedefType;
 const AstTypeMatcher<EnumType> enumType;

clang/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(isWeak);
   REGISTER_MATCHER(isWritten);
   REGISTER_MATCHER(lValueReferenceType);
   REGISTER_MATCHER(labelDecl);
   REGISTER_MATCHER(labelStmt);
   REGISTER_MATCHER(lambdaCapture);
   REGISTER_MATCHER(lambdaExpr);
   REGISTER_MATCHER(linkageSpecDecl);
+  REGISTER_MATCHER(macroQualifiedType);
   REGISTER_MATCHER(materializeTemporaryExpr);
   REGISTER_MATCHER(member);
   REGISTER_MATCHER(memberExpr);
   REGISTER_MATCHER(memberHasSameNameAsBoundNode);
   REGISTER_MATCHER(memberPointerType);
   REGISTER_MATCHER(namedDecl);
   REGISTER_MATCHER(namesType);
   REGISTER_MATCHER(namespaceAliasDecl);

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

 }
 
 TEST_P(ASTMatchersTest, TypedefType) {
   EXPECT_TRUE(matches("typedef int X; X a;",
                       varDecl(hasName("a"), hasType(elaboratedType(
                                                 namesType(typedefType()))))));
 }
 
+TEST_P(ASTMatchersTest, MacroQualifiedType) {
+  EXPECT_TRUE(matches(
+      R"(
+        #define CDECL __attribute__((cdecl))
+        typedef void (CDECL *X)();
+      )",
+      typedefDecl(hasType(pointerType(pointee(macroQualifiedType()))))));
+  EXPECT_TRUE(notMatches(
+      R"(
+        typedef void (__attribute__((cdecl)) *Y)();
+      )",
+      typedefDecl(hasType(pointerType(pointee(macroQualifiedType()))))));
+}
+
 TEST_P(ASTMatchersTest, TemplateSpecializationType) {
   if (!GetParam().isCXX()) {
     return;
   }
   EXPECT_TRUE(matches("template <typename T> class A{}; A<int> a;",
                       templateSpecializationType()));
 }