[clang][ASTMatchers] Add a few type-related Matchers

[danix800]

Summary

Add a few type-related Matchers

• bitIntType
• constantMatrixType
• dependentAddressSpaceType
• dependentBitIntType
• dependentSizedMatrixType
• dependentVectorType
• hasTypeForDecl
• objcTypeParamDecl
• objcTypeParamType
• pipeType
• vectorType

[PiotrZSL]

LGTM.
Nothing fancy, looks straight forward.
You may want to wait for an Aaron Ballman opinion.

clang/docs/LibASTMatchersReference.html

2454

Maybe: "Matches a fixed int type of a specified bitwidth."

[danix800]

In D158872#4618252, @PiotrZSL wrote:

LGTM.
Nothing fancy, looks straight forward.
You may want to wait for an Aaron Ballman opinion.

Thanks for the reviewing.

Ping @aaron.ballman, could you please take a look at this revision?

[danix800]

Update docs for bitIntType & dependentBitIntType.

[danix800]

Update doc: fix improper naming in objc testcase

[aaron.ballman]

Are these matchers going to be used in-tree (by clang-tidy, or something else)? We typically do not add new AST matches until there's a need for them because the AST matchers have a pretty big impact on build times of Clang itself.

clang/include/clang/ASTMatchers/ASTMatchers.h

3971

This could use some example code that demonstrates usage.

3974

I think this needs to go through ASTContext::getTypeDeclType() for correctness, as the ASTContext is what manages the type cache and performs extra work: https://github.com/llvm/llvm-project/blob/45eb6026d979e306a12ea9e223852b28c3c9edbf/clang/include/clang/AST/ASTContext.h#L1561

7061

How about: Matches a '_BitInt' or '_ExtInt' type.

7068

Drop the i (it only matches the type, not the whole declaration).

7078

Seems like some type/declaration confusion here as well -- it matches the underlying type used by the typedef declaration of X. Same applies below.

[danix800]

In D158872#4622124, @aaron.ballman wrote:

Are these matchers going to be used in-tree (by clang-tidy, or something else)? We typically do not add new AST matches until there's a need for them because the AST matchers have a pretty big impact on build times of Clang itself.

They are used in ASTImporter testcases as shown in https://reviews.llvm.org/D158948. Though this might not be a strong reason to
add these matchers and bring on too much bad impact.

ASTImporter is more urgent since we still lack support for some of the AST nodes so I considered adding them batchly and started with
type-related nodes. I thought that matchers're OK to use in unittests as actually they are used a lot there, but I wasn't aware of the impact
on build of Clang.

If not acceptable, I'm OK with it. We can still test importing with other ways. Matchers are not mandatory.

EDIT: If acceptable, tools like clang-query can benefit from these matchers too, easy for
debugging I guess. Please let me known whether I should proceed on this revision or not. Thanks for reviewing anyway!

[aaron.ballman]

In D158872#4623193, @danix800 wrote:

In D158872#4622124, @aaron.ballman wrote:

Are these matchers going to be used in-tree (by clang-tidy, or something else)? We typically do not add new AST matches until there's a need for them because the AST matchers have a pretty big impact on build times of Clang itself.

They are used in ASTImporter testcases as shown in https://reviews.llvm.org/D158948. Though this might not be a strong reason to
add these matchers and bring on too much bad impact.

ASTImporter is more urgent since we still lack support for some of the AST nodes so I considered adding them batchly and started with
type-related nodes. I thought that matchers're OK to use in unittests as actually they are used a lot there, but I wasn't aware of the impact
on build of Clang.

If not acceptable, I'm OK with it. We can still test importing with other ways. Matchers are not mandatory.

EDIT: If acceptable, tools like clang-query can benefit from these matchers too, easy for
debugging I guess. Please let me known whether I should proceed on this revision or not. Thanks for reviewing anyway!

Pulling in a few more folks for extra opinions in case I'm off-base, but I think a good approach for right now is to add these matches to the unit test file directly in the AST importer patch and to hold off on landing this one. Then you still get the test coverage you need in the unit tests, but the extra compilation time is limited to just one .cpp file and not everything including ASTMatchers.h. As we find a need for the matchers, we can lift them from the unit test into the public matchers. It's not that there's no utility to these (there is!), it's more just the balancing act between compile times and utility.

[sammccall]

In D158872#4624821, @aaron.ballman wrote:

In D158872#4623193, @danix800 wrote:

In D158872#4622124, @aaron.ballman wrote:

Are these matchers going to be used in-tree (by clang-tidy, or something else)? We typically do not add new AST matches until there's a need for them because the AST matchers have a pretty big impact on build times of Clang itself.

They are used in ASTImporter testcases as shown in https://reviews.llvm.org/D158948. Though this might not be a strong reason to
add these matchers and bring on too much bad impact.

ASTImporter is more urgent since we still lack support for some of the AST nodes so I considered adding them batchly and started with
type-related nodes. I thought that matchers're OK to use in unittests as actually they are used a lot there, but I wasn't aware of the impact
on build of Clang.

If not acceptable, I'm OK with it. We can still test importing with other ways. Matchers are not mandatory.

EDIT: If acceptable, tools like clang-query can benefit from these matchers too, easy for
debugging I guess. Please let me known whether I should proceed on this revision or not. Thanks for reviewing anyway!

Pulling in a few more folks for extra opinions in case I'm off-base, but I think a good approach for right now is to add these matches to the unit test file directly in the AST importer patch and to hold off on landing this one. Then you still get the test coverage you need in the unit tests, but the extra compilation time is limited to just one .cpp file and not everything including ASTMatchers.h. As we find a need for the matchers, we can lift them from the unit test into the public matchers. It's not that there's no utility to these (there is!), it's more just the balancing act between compile times and utility.

This is a sad state of affairs :-(
Not having "obvious" matchers for some types/properties in the AST is a real problem inhibiting use of matchers IME. People will use fragile hacks or give up entirely rather than write custom matchers, and missing base matchers for certain types is perceived as a bug.
To have someone recognize a gap & contribute matchers, and not accept the patch because matchers are too slow to compile, is pretty painful.
But the compile time issue is real!

A few ideas:

• could we move these (and possibly other rarely-used matchers) to ObscureMatchers.h or something? It's definitely ugly, but maybe not as bad as missing them entirely.
• seems like we should extract an ASTMatchersBase.h or so to separate "matcher framework" from "all the slow matchers" so headers that expose matcher-based APIs don't have to transitively expose everything, reducing the cost of such changes
• (long shot) maybe we can work out which code patterns are particularly terrible for parse times and change them

[aaron.ballman]

In D158872#4625425, @sammccall wrote:

In D158872#4624821, @aaron.ballman wrote:

In D158872#4623193, @danix800 wrote:

In D158872#4622124, @aaron.ballman wrote:

Are these matchers going to be used in-tree (by clang-tidy, or something else)? We typically do not add new AST matches until there's a need for them because the AST matchers have a pretty big impact on build times of Clang itself.

They are used in ASTImporter testcases as shown in https://reviews.llvm.org/D158948. Though this might not be a strong reason to
add these matchers and bring on too much bad impact.

ASTImporter is more urgent since we still lack support for some of the AST nodes so I considered adding them batchly and started with
type-related nodes. I thought that matchers're OK to use in unittests as actually they are used a lot there, but I wasn't aware of the impact
on build of Clang.

If not acceptable, I'm OK with it. We can still test importing with other ways. Matchers are not mandatory.

EDIT: If acceptable, tools like clang-query can benefit from these matchers too, easy for
debugging I guess. Please let me known whether I should proceed on this revision or not. Thanks for reviewing anyway!

Pulling in a few more folks for extra opinions in case I'm off-base, but I think a good approach for right now is to add these matches to the unit test file directly in the AST importer patch and to hold off on landing this one. Then you still get the test coverage you need in the unit tests, but the extra compilation time is limited to just one .cpp file and not everything including ASTMatchers.h. As we find a need for the matchers, we can lift them from the unit test into the public matchers. It's not that there's no utility to these (there is!), it's more just the balancing act between compile times and utility.

This is a sad state of affairs :-(

Agreed, but it's also not a new state of affairs; we've held this position for as long as we've had AST matchers. (For reference, ASTMatchers.h creates so many symbols we needed to enable /bigobj just to be able to generate an object file that could represent it -- you use that option when you have > 65k addressable sections in an object file!)

Not having "obvious" matchers for some types/properties in the AST is a real problem inhibiting use of matchers IME. People will use fragile hacks or give up entirely rather than write custom matchers, and missing base matchers for certain types is perceived as a bug.
To have someone recognize a gap & contribute matchers, and not accept the patch because matchers are too slow to compile, is pretty painful.
But the compile time issue is real!

Agreed. :-(

A few ideas:

• could we move these (and possibly other rarely-used matchers) to ObscureMatchers.h or something? It's definitely ugly, but maybe not as bad as missing them entirely.
• seems like we should extract an ASTMatchersBase.h or so to separate "matcher framework" from "all the slow matchers" so headers that expose matcher-based APIs don't have to transitively expose everything, reducing the cost of such changes
• (long shot) maybe we can work out which code patterns are particularly terrible for parse times and change them

The problem is the pile of templates that is used to generate the DSL and used for dynamic matchers by clang-query. IIRC, we looked into reducing the overhead and eventually punted on it, some background can be found here: https://reviews.llvm.org/D84038 when we finally decided to enable /bigobj everywhere. I know we did a pass to split ASTMatchers.h up so we now have ASTMatchersInternal.h, so I think we might have done about as much extraction as we can (though it'd be worth seeing if there's more we can do now that we've got access to C++17 in source; I think we were still on C++11 when we last did this).

Ideally, I would love to table generate more of the AST matchers from source such as https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/TypeNodes.td and https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/DeclNodes.td so that we automatically get all of the type and declaration matchers (at least the top-level matchers) without any extra maintenance overhead to keep them in sync. But I've always had the impression this idea was dead in the water because of overhead. I suspect moving things around into multiple headers won't help all that much (and it will likely cause confusion as to what header file to put any given AST matcher into) because Clang itself will still need to include all of those headers (and thus will still hit all the compile time and object size problems).

[sammccall]

Thanks for the history, I wasn't aware this was such a big deal for such a long time!

In D158872#4625555, @aaron.ballman wrote:

A few ideas:

• could we move these (and possibly other rarely-used matchers) to ObscureMatchers.h or something? It's definitely ugly, but maybe not as bad as missing them entirely.
• seems like we should extract an ASTMatchersBase.h or so to separate "matcher framework" from "all the slow matchers" so headers that expose matcher-based APIs don't have to transitively expose everything, reducing the cost of such changes
• (long shot) maybe we can work out which code patterns are particularly terrible for parse times and change them

The problem is the pile of templates that is used to generate the DSL and used for dynamic matchers by clang-query. IIRC, we looked into reducing the overhead and eventually punted on it, some background can be found here: https://reviews.llvm.org/D84038 when we finally decided to enable /bigobj everywhere.

Thanks, I'll take a look and see if C++17 gives us new tools, but seems likely it's just too complicated.
Clearly the answer here is to force everyone to use the dynamic matchers and string literals. (Only half kidding - if we didn't try to express all constraints at compile time this would all be so much easier...)

I know we did a pass to split ASTMatchers.h up so we now have ASTMatchersInternal.h, so I think we might have done about as much extraction as we can

The thing I think is possible is to have a header that defines DeclMatcher, BoundNodes, anything etc without including all the concrete matchers. This is the header that ASTMatchFinder.h should include.

(At the moment we have some insane include chains like Analysis/FlowSensitive/DataflowAnalysis.h => MatchSwitch.h (for TransferState) => ASTMatchers.h` (for anything etc). Thus the main header of an ~unrelated library exports all matcher types).

Ideally, I would love to table generate more of the AST matchers ... Clang itself will still need to include all of those headers (and thus will still hit all the compile time and object size problems).

That would be great. For compile times, I'd expect we could include fewer matchers into fewer TUs - very little of clang should be using most of the matchers, and the sum of TU compile times is usually somewhat more important than the max.
I have less understanding of the object size issues. My understanding is that the current matchers are written ~entirely as templates in headers, the API surface is that way to achieve the decidedly un-C++-like DSL, but the implementation just because it's convenient. Fundamentally it doesn't seem like basic node-type matchers should have to instantiate many templates!

[sammccall]

I did some testing on my machine (host compiler clang-14), and I'm not sure the specifics justify the level of caution here:

ASTMatchers.h parses in 6.5s (with clang-check)
If I comment out the code + internal ASTMatcher includes, then just the deps (mostly AST headers) parses in 4.9s.
1.6s for matchers impl is slow but not build-breakingly so. I don't think we should be scared of the marginal parse time increase from this change. (ASTMatchers is not in all that many TUs anyhow - no "core" headers re-export it).

The bug referenced is about object size. The connection with matchers seems to be that matcher tests had their section limit increased, before this applied to the whole project.
However this is specifically for tests that test most of the matchers, you only pay for what you use.
I verified that a cpp file that includes ASTMatchers.h and does nothing else generates a trivial-sized object file (<1kb). So again, I don't think we need to fear this change: if it's used in many places, it's justified, and if it's not used, it's not expensive.

(If compilation of files like NodeMatchersTest.cpp are significant build bottlenecks, we'd need to address that, but *those* would be fine to split up in unprincipled ways, so I'm not too concerned)

[aaron.ballman]

In D158872#4626065, @sammccall wrote:

I did some testing on my machine (host compiler clang-14), and I'm not sure the specifics justify the level of caution here:

Thank you for doing some research on this!

ASTMatchers.h parses in 6.5s (with clang-check)
If I comment out the code + internal ASTMatcher includes, then just the deps (mostly AST headers) parses in 4.9s.
1.6s for matchers impl is slow but not build-breakingly so. I don't think we should be scared of the marginal parse time increase from this change. (ASTMatchers is not in all that many TUs anyhow - no "core" headers re-export it).

Out of curiosity, are you testing on Windows with MSVC? My understanding on build time performance impacts was that it's debug builds with MSVC that get hit especially hard. (I can test that setup but I could use some help figuring out how you tested compile times so I can do a similar test instead of something totally different from what you tried.)

It would be fantastic if the build time issues were not a problem!

The bug referenced is about object size. The connection with matchers seems to be that matcher tests had their section limit increased, before this applied to the whole project.
However this is specifically for tests that test most of the matchers, you only pay for what you use.
I verified that a cpp file that includes ASTMatchers.h and does nothing else generates a trivial-sized object file (<1kb). So again, I don't think we need to fear this change: if it's used in many places, it's justified, and if it's not used, it's not expensive.

(If compilation of files like NodeMatchersTest.cpp are significant build bottlenecks, we'd need to address that, but *those* would be fine to split up in unprincipled ways, so I'm not too concerned)

FWIW, we had to increase the limits on various files until we finally broke down and did it project-wide. So it wasn't just limited to testing files having the issue; I think the big problem was templated symbols from instantiations. But as you say, if it's pay-for-what-you-use, that's pretty reasonable.

CC @PiotrZSL @LegalizeAdulthood @carlosgalvezp as folks who work on clang-tidy, which uses AST matchers all over the place. They may also have some good insights or preferences here.

[sammccall]

In D158872#4626095, @aaron.ballman wrote:

Out of curiosity, are you testing on Windows with MSVC? My understanding on build time performance impacts was that it's debug builds with MSVC that get hit especially hard. (I can test that setup but I could use some help figuring out how you tested compile times so I can do a similar test instead of something totally different from what you tried.)

I'm not :-( I don't have a windows machine, and the VM I used to have has bitrotted beyond repair (not sure how useful benchmarks from there would be anyway).

This is with clang on linux, just running time clang-check-14 include/clang/ASTMatchers/ASTMatchers.h a few times.
The "deps only" test was #if 0 ing out all the code in ASTMatcher.h, and commenting out the ASTMatchers/* includes, and repeating the same.
For object files I just added a dummy ASTMatchers.cpp with only #include "clang/ASTMatchers/ASTMatchers.h".

I guess the equivalent of clang-check would be /Zs, not sure the best way to feed it the right flags...

[danix800]

In D158872#4626272, @sammccall wrote:

In D158872#4626095, @aaron.ballman wrote:

Out of curiosity, are you testing on Windows with MSVC? My understanding on build time performance impacts was that it's debug builds with MSVC that get hit especially hard. (I can test that setup but I could use some help figuring out how you tested compile times so I can do a similar test instead of something totally different from what you tried.)

I'm not :-( I don't have a windows machine, and the VM I used to have has bitrotted beyond repair (not sure how useful benchmarks from there would be anyway).

This is with clang on linux, just running time clang-check-14 include/clang/ASTMatchers/ASTMatchers.h a few times.
The "deps only" test was #if 0 ing out all the code in ASTMatcher.h, and commenting out the ASTMatchers/* includes, and repeating the same.
For object files I just added a dummy ASTMatchers.cpp with only #include "clang/ASTMatchers/ASTMatchers.h".

I guess the equivalent of clang-check would be /Zs, not sure the best way to feed it the right flags...

Thanks for the testing. I can do the windows part with MSVC cl.exe.

1. ASTMatchers.h: ~3.5s
2. "Deps only": ~3.2s
3. ASTMatchers.cpp obj: 8K

$ uname -a
MINGW64_NT-10.0-20348 WIN-LH267487PAC 3.3.3-341.x86_64 2022-01-17 11:45 UTC x86_64 Msys

$ echo $SHELL
/usr/bin/bash

$ cat test.ps1
& "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.37.32822\bin\Hostx64\x64\cl.exe" /permissive- /MP /we"4238" /GS /Zc:preprocessor /W4 /wd"4141" /wd"4146" /wd"4244" /wd"4267" /wd"4291" /wd"4351" /wd"4456" /wd"4457" /wd"4458" /wd"4459" /wd"4503" /wd"4624" /wd"4722" /wd"4100" /wd"4127" /wd"4512" /wd"4505" /wd"4610" /wd"4510" /wd"4702" /wd"4245" /wd"4706" /wd"4310" /wd"4701" /wd"4703" /wd"4389" /wd"4611" /wd"4805" /wd"4204" /wd"4577" /wd"4091" /wd"4592" /wd"4319" /wd"4709" /wd"5105" /wd"4324" /Zc:wchar_t /I"C:\Users\Administrator\source\repos\llvm-project\build-main-vs2022\tools\clang\lib\ASTMatchers" /I"C:\Users\Administrator\source\repos\llvm-project\clang\lib\ASTMatchers" /I"C:\Users\Administrator\source\repos\llvm-project\clang\include" /I"C:\Users\Administrator\source\repos\llvm-project\build-main-vs2022\tools\clang\include" /I"C:\Users\Administrator\source\repos\llvm-project\build-main-vs2022\include" /I"C:\Users\Administrator\source\repos\llvm-project\llvm\include" /Gm- /O2 /Ob2 /Zc:inline /fp:precise /U"NDEBUG" /D "_UNICODE" /D "UNICODE" /D "WIN32" /D "_WINDOWS" /D "_GLIBCXX_ASSERTIONS" /D "_LIBCPP_ENABLE_ASSERTIONS" /D "_CRT_SECURE_NO_DEPRECATE" /D "_CRT_SECURE_NO_WARNINGS" /D "_CRT_NONSTDC_NO_DEPRECATE" /D "_CRT_NONSTDC_NO_WARNINGS" /D "_SCL_SECURE_NO_DEPRECATE" /D "_SCL_SECURE_NO_WARNINGS" /D "__STDC_CONSTANT_MACROS" /D "__STDC_FORMAT_MACROS" /D "__STDC_LIMIT_MACROS" /D CMAKE_INTDIR=\"Release\" /errorReport:prompt /WX- /Zc:forScope /GR /Gd /Oi /MD /std:c++17 /EHsc /nologo /Fp"obj.clangASTMatchers.dir\Release\obj.clangASTMatchers.pch" /diagnostics:column /Zc:__cplusplus /bigobj -w14062 /Gw /I"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.37.32822\include" /I"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.37.32822\atlmfc\include" /I"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\VS\include" /I"C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\ucrt" /I"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\VS\UnitTest\include" /I"C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\um" /I"C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\shared" /I"C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\winrt" /I"C:\Program Files (x86)\Windows Kits\10\Include\10.0.22621.0\cppwinrt" /c ..\clang\include\clang\ASTMatchers\ASTMatchers.h /TP

 $ time powershell ./test.ps1
ASTMatchers.h

real    0m3.143s
user    0m0.015s
sys     0m0.000s

EDIT: Obj size is incorrect, sorry!

# incorrect
$ du -h ASTMatchers.obj
8.0K    ASTMatchers.obj

$ du -b ASTMatchers.obj
5283    ASTMatchers.obj

About 5.3k.

[PiotrZSL]

From a mine perspective when it comes to clang-tidy:

• I personally do not care about Objective-C specific matchers - I do not plan to use them.
• I personally avoid using "Type" based matchers if I can (due to mess with elaborated/wrapped types), it's easier to create custom local matcher for QualType and do there anything is needed. QualType/Type class got very helpful API.
• There is nothing more annoying than not having a main matcher for specific Stmt, Decl, Expr, TypeLoc (places that actually got SourceLocation) and some basic matchers for traversal into parents/childs.
• There are lot of local matchers defined in Clang-tidy, those would be a best candidates to push upwards.
• I'm missing some matchers related to AST traversal: noneOf, equalOrDescendant, hasFirstAncestor(PositiveMatcher, NegativeMatcher), isBeforeInTransationUnit, isInSameScopeAsBoundNode, ...

As for matchers in this change, except maybe hasTypeForDecl, I do not think that I will be using them.

[danix800]

In D158872#4627313, @PiotrZSL wrote:

From a mine perspective when it comes to clang-tidy:

• I personally do not care about Objective-C specific matchers - I do not plan to use them.
• I personally avoid using "Type" based matchers if I can (due to mess with elaborated/wrapped types), it's easier to create custom local matcher for QualType and do there anything is needed. QualType/Type class got very helpful API.
• There is nothing more annoying than not having a main matcher for specific Stmt, Decl, Expr, TypeLoc (places that actually got SourceLocation) and some basic matchers for traversal into parents/childs.
• There are lot of local matchers defined in Clang-tidy, those would be a best candidates to push upwards.
• I'm missing some matchers related to AST traversal: noneOf, equalOrDescendant, hasFirstAncestor(PositiveMatcher, NegativeMatcher), isBeforeInTransationUnit, isInSameScopeAsBoundNode, ...

As for matchers in this change, except maybe hasTypeForDecl, I do not think that I will be using them.

All right, I'll abandon this revison. Thanks for reviewing.

clang/docs/LibASTMatchersReference.html

 <tr><td colspan="4" class="doc" id="objcProtocolDecl0"><pre>Matches Objective-C protocol declarations.
 
 Example matches FooDelegate
   @protocol FooDelegate
   @end
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcTypeParamDecl0')"><a name="objcTypeParamDecl0Anchor">objcTypeParamDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCTypeParamDecl.html">ObjCTypeParamDecl</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="objcTypeParamDecl0"><pre>Matches the declaration of an Objective-C type parameter.
+
+Given
+  @interface Dictionary &lt;FirstParam: id&gt;
+  @end
+objcTypeParamDecl()
+  matches the type-parameter declaration "FirstParam".
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('parmVarDecl0')"><a name="parmVarDecl0Anchor">parmVarDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="parmVarDecl0"><pre>Matches parameter variable declarations.
 
 Given
   void f(int x);
 parmVarDecl()
   matches int x.
 </pre></td></tr>

   auto n = 4;
   int v[] = { 2, 3 }
   for (auto i : v) { }
 autoType()
   matches "auto n" and "auto i"
 </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('bitIntType0')"><a name="bitIntType0Anchor">bitIntType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BitIntType.html">BitIntType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="bitIntType0"><pre>Matches _BitInt types.
+
+Given:
+  _BitInt(10) i;
+bitIntType()
+  matches "_BitInt(10) i".
+</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('blockPointerType0')"><a name="blockPointerType0Anchor">blockPointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="blockPointerType0"><pre>Matches block pointer types, i.e. types syntactically represented as
 "void (^)(int)".
 
 The pointee is always required to be a FunctionType.
 </pre></td></tr>
 
 

     int b[] = { 2, 3 };
     int c[b[0]];
   }
 constantArrayType()
   matches "int a[2]"
 </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('constantMatrixType0')"><a name="constantMatrixType0Anchor">constantMatrixType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConstantMatrixType.html">ConstantMatrixType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="constantMatrixType0"><pre>Matches matrix types of constant size.
+
+Given:
+  typedef int __attribute__((matrix_type(5, 5))) X;
+constantMatrixType()
+  matches the type of the typedef declaration "X".
+</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('decayedType0')"><a name="decayedType0Anchor">decayedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecayedType.html">DecayedType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="decayedType0"><pre>Matches decayed type
 Example matches i[] in declaration of f.
     (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
 Example matches i[1].
     (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
   void f(int i[]) {
     i[1] = 0;

   class C { public: C(T); };
 
   C c(123);
 deducedTemplateSpecializationType() matches the type in the declaration
 of the variable c.
 </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('dependentAddressSpaceType0')"><a name="dependentAddressSpaceType0Anchor">dependentAddressSpaceType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentAddressSpaceType.html">DependentAddressSpaceType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="dependentAddressSpaceType0"><pre>Matches an extended address space qualifier where the
+input address space value is dependent.
+
+Given
+  template&lt;typename T, int AddrSpace&gt;
+  class AddressSpace {
+    typedef T __attribute__((address_space(AddrSpace))) X;
+  };
+dependentAddressSpaceType()
+  matches the type of the typedef declaration "X".
+</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('dependentBitIntType0')"><a name="dependentBitIntType0Anchor">dependentBitIntType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentBitIntType.html">DependentBitIntType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="dependentBitIntType0"><pre>Matches _BitInt types where the bit width is dependent.
+
+Given
+  template<int Width> using X = _BitInt(Width);
+dependentBitIntType()
+  matches the type of the type alias declaration "X".
+</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('dependentSizedArrayType0')"><a name="dependentSizedArrayType0Anchor">dependentSizedArrayType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentSizedArrayType.html">DependentSizedArrayType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
 
 Given
   template&lt;typename T, int Size&gt;
   class array {
     T data[Size];
   };

   class vector {
     typedef T __attribute__((ext_vector_type(Size))) type;
   };
 dependentSizedExtVectorType()
   matches "T __attribute__((ext_vector_type(Size)))"
 </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('dependentSizedMatrixType0')"><a name="dependentSizedMatrixType0Anchor">dependentSizedMatrixType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentSizedMatrixType.html">DependentSizedMatrixType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="dependentSizedMatrixType0"><pre>Matches a matrix type where the type and the number of rows
+and columns is dependent.
+
+Given
+  template&lt;typename T, int Rows, int Cols&gt;
+  class matrix {
+    typedef T __attribute__((matrix_type(Rows, Cols))) X;
+  };
+  typedef int __attribute__((matrix_type(3, 3))) Y;
+dependentSizedMatrixType()
+  matches the type of the typedef declaration "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('dependentVectorType0')"><a name="dependentVectorType0Anchor">dependentVectorType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentVectorType.html">DependentVectorType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="dependentVectorType0"><pre>Matches vector types where either the type or size is dependent.
+
+Given
+  template&lt;typename T, int Size&gt;
+  class vector {
+    typedef T __attribute__((vector_size(Size))) X;
+  };
+  typedef int __attribute__((vector_size(12))) Y;
+dependentVectorType()
+  matches the type of the typedef declaration "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('elaboratedType0')"><a name="elaboratedType0Anchor">elaboratedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
 qualified name.
 
 Given
   namespace N {
     namespace M {
       class D {};

 a pointer type, despite being syntactically similar.
 
 Given
   int *a;
 
   @interface Foo
   @end
   Foo *f;
-pointerType()
+objcObjectPointerType()
   matches "Foo *f", but does not match "int *a".
 </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('objcTypeParamType0')"><a name="objcTypeParamType0Anchor">objcTypeParamType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCTypeParamType.html">ObjCTypeParamType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="objcTypeParamType0"><pre>Matches Objective-C type parameter types.
+
+Given
+  @interface Dictionary &lt;FirstParam: id&gt;
+  @end
+objcTypeParamType()
+  matches the type of type-parameter "FirstParam".
+</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('parenType0')"><a name="parenType0Anchor">parenType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="parenType0"><pre>Matches ParenType nodes.
 
 Given
   int (*ptr_to_array)[4];
   int *array_of_ptrs[4];
 
 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
 array_of_ptrs.
 </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('pipeType0')"><a name="pipeType0Anchor">pipeType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PipeType.html">PipeType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="pipeType0"><pre>Matches OpenCL pipe types.
+
+Given
+  typedef pipe int X;
+  typedef int Y;
+pipeType()
+  matches the type of the typedef declaration "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('pointerType0')"><a name="pointerType0Anchor">pointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="pointerType0"><pre>Matches pointer types, but does not match Objective-C object pointer
 types.
 
 Given
   int *a;
   int &amp;b = *a;
   int c = 5;

     int a[] = { 2, 3 }
     int b[42];
     int c[a[0]];
   }
 variableArrayType()
   matches "int c[a[0]]"
 </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('vectorType0')"><a name="vectorType0Anchor">vectorType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VectorType.html">VectorType</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="vectorType0"><pre>Matches vector types.
+
+Given
+  typedef int __attribute__((vector_size(12))) X;
+vectorType()
+  matches the type of the typedef declaration "X".
+</pre></td></tr>
+
 <!--END_DECL_MATCHERS -->
 </table>
 
 <!-- ======================================================================= -->
 <h2 id="narrowing-matchers">Narrowing Matchers</h2>
 <!-- ======================================================================= -->
 
 <p>Narrowing matchers match certain attributes on the current node, thus

 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('loc0')"><a name="loc0Anchor">loc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="loc0"><pre>Matches TypeLocs for which the given inner
 QualType-matcher matches.
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeDecl.html">TypeDecl</a>&gt;</td><td class="name" onclick="toggle('hasTypeForDecl0')"><a name="hasTypeForDecl0Anchor">hasTypeForDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
+<tr><td colspan="4" class="doc" id="hasTypeForDecl0"><pre>Matches the type object that represents this TypeDecl.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;</td><td class="name" onclick="toggle('hasTypeLoc13')"><a name="hasTypeLoc13Anchor">hasTypeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt; Inner</td></tr>
 <tr><td colspan="4" class="doc" id="hasTypeLoc13"><pre>Matches if the type location of a node matches the inner matcher.
 
 Examples:
   int x;
 declaratorDecl(hasTypeLoc(loc(asString("int"))))
   matches int x
 

clang/docs/ReleaseNotes.rst

 - Add ``__builtin_elementwise_exp2`` builtin for floating point types only.
 - Add ``__builtin_set_flt_rounds`` builtin for X86, x86_64, Arm and AArch64 only.
 - 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 ``bitIntType``.
+- Add ``constantMatrixType``.
 - Add ``convertVectorExpr``.
+- Add ``dependentAddressSpaceType``.
+- Add ``dependentBitIntType``.
 - Add ``dependentSizedExtVectorType``.
+- Add ``dependentSizedMatrixType``.
+- Add ``dependentVectorType``.
 - Add ``macroQualifiedType``.
+- Add ``hasTypeForDecl``.
+- Add ``objcTypeParamDecl``.
+- Add ``objcTypeParamType``.
+- Add ``pipeType``.
+- Add ``vectorType``.
 
 clang-format
 ------------
 
 libclang
 --------
 
 - Exposed arguments of ``clang::annotate``.

clang/include/clang/ASTMatchers/ASTMatchers.h

                                     ValueDecl, CXXBaseSpecifier),
     internal::Matcher<QualType>, InnerMatcher, 0) {
   QualType QT = internal::getUnderlyingType(Node);
   if (!QT.isNull())
     return InnerMatcher.matches(QT, Finder, Builder);
   return false;
 }
 
+/// Matches the type object that represents this TypeDecl.
+AST_MATCHER_P(TypeDecl, hasTypeForDecl, internal::Matcher<QualType>,
+              InnerMatcher) {
+  QualType QT(Node.getTypeForDecl(), 0);
+  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.

 ///   short i = 1;
 ///   int j = 42;
 ///   decltype(i + j) result = i + j;
 /// \endcode
 /// decltypeType()
 ///   matches "decltype(i + j)"
 extern const AstTypeMatcher<DecltypeType> decltypeType;
 
+/// Matches _BitInt types.
+///
+/// Given
+/// \code
+///   _BitInt(10) i;
+/// \endcode
+/// bitIntType()
+///   matches "_BitInt(10) i"
+extern const AstTypeMatcher<BitIntType> bitIntType;
+
+/// Matches matrix types of constant size.
+///
+/// Given
+/// \code
+///   typedef int __attribute__((matrix_type(5, 5))) X;
+/// \endcode
+/// constantMatrixType()
+///   matches the type of the typedef declaration "X".
+extern const AstTypeMatcher<ConstantMatrixType> constantMatrixType;
+
+/// Matches an extended address space qualifier where the input address space
+/// value is dependent.
+///
+/// Given
+/// \code
+///   template<typename T, int AddrSpace>
+///   class AddressSpace {
+///     typedef T __attribute__((address_space(AddrSpace))) X;
+///   };
+/// \endcode
+/// dependentAddressSpaceType()
+///   matches the type of the typedef declaration "X".
+extern const AstTypeMatcher<DependentAddressSpaceType>
+    dependentAddressSpaceType;
+
+/// Matches bitint types where the bitwidth is dependent.
+///
+/// Given
+/// \code
+///   template<int Width> using X = _BitInt(Width);
+/// \endcode
+/// dependentBitIntType()
+///   matches the type of the type alias declaration "X".
+extern const AstTypeMatcher<DependentBitIntType> dependentBitIntType;
+
+/// Matches vector types where either the type or size is dependent.
+///
+/// Given
+/// \code
+///   template<typename T, int Size>
+///   class vector {
+///     typedef T __attribute__((vector_size(Size))) X;
+///   };
+///   typedef int __attribute__((vector_size(12))) Y;
+/// \endcode
+/// dependentVectorType()
+///   matches the type of the typedef declaration "X" but not "Y".
+extern const AstTypeMatcher<DependentVectorType> dependentVectorType;
+
+/// Matches a matrix type where the type and the number of rows and columns
+/// is dependent.
+///
+/// Given
+/// \code
+///   template<typename T, int Rows, int Cols>
+///   class matrix {
+///     typedef T __attribute__((matrix_type(Rows, Cols))) X;
+///   };
+///   typedef int __attribute__((matrix_type(3, 3))) Y;
+/// \endcode
+/// dependentSizedMatrixType()
+///   matches the type of the typedef declaration "X" but not "Y".
+extern const AstTypeMatcher<DependentSizedMatrixType> dependentSizedMatrixType;
+
+/// Matches vector types.
+///
+/// Given
+/// \code
+///   typedef int __attribute__((vector_size(12))) X;
+/// \endcode
+/// vectorType()
+///   matches the type of the typedef declaration "X".
+extern const AstTypeMatcher<VectorType> vectorType;
+
+/// Matches Objective-C type parameter types.
+///
+/// Given
+/// \code
+///   @interface Dictionary <FirstParam: id>
+///   @end
+/// \endcode
+/// objcTypeParamType()
+///   matches the type of type-parameter "FirstParam".
+extern const AstTypeMatcher<ObjCTypeParamType> objcTypeParamType;
+
+/// Matches the declaration of an Objective-C type parameter.
+///
+/// Given
+/// \code
+///   @interface Dictionary <FirstParam: id>
+///   @end
+/// \endcode
+/// objcTypeParamDecl()
+///   matches the type-parameter declaration "FirstParam".
+extern const internal::VariadicDynCastAllOfMatcher<Decl, ObjCTypeParamDecl>
+    objcTypeParamDecl;
+
+/// Matches OpenCL pipe types.
+///
+/// Given
+/// \code
+///   typedef pipe int X;
+///   typedef int Y;
+/// \endcode
+/// pipeType()
+///   matches the type of the typedef declaration \c X but not \c Y.
+extern const AstTypeMatcher<PipeType> pipeType;
+
 /// Matches \c AutoType nodes where the deduced type is a specific type.
 ///
 /// Note: There is no \c TypeLoc for the deduced type and thus no
 /// \c getDeducedLoc() matcher.
 ///
 /// Given
 /// \code
 ///   auto a = 1;

clang/lib/ASTMatchers/ASTMatchFinder.cpp

public:
   bool TraverseDecl(Decl *DeclNode);
   bool TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue = nullptr);
   bool TraverseType(QualType TypeNode);
   bool TraverseTypeLoc(TypeLoc TypeNode);
   bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS);
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
   bool TraverseConstructorInitializer(CXXCtorInitializer *CtorInit);
   bool TraverseTemplateArgumentLoc(TemplateArgumentLoc TAL);
+  bool TraverseObjCTypeParamDecl(ObjCTypeParamDecl *TPD);
   bool TraverseAttr(Attr *AttrNode);
 
   bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue) {
     if (auto *RF = dyn_cast<CXXForRangeStmt>(S)) {
       {
         ASTNodeNotAsIsSourceScope RAII(this, true);
         TraverseStmt(RF->getInit());
         // Don't traverse under the loop variable
return RecursiveASTVisitor<MatchASTVisitor>::TraverseConstructorInitializer(
       CtorInit);
 }
 
 bool MatchASTVisitor::TraverseTemplateArgumentLoc(TemplateArgumentLoc Loc) {
   match(Loc);
   return RecursiveASTVisitor<MatchASTVisitor>::TraverseTemplateArgumentLoc(Loc);
 }
 
+bool MatchASTVisitor::TraverseObjCTypeParamDecl(ObjCTypeParamDecl *TPD) {
+  match(*TPD);
+  return RecursiveASTVisitor<MatchASTVisitor>::TraverseObjCTypeParamDecl(TPD);
+}
+
 bool MatchASTVisitor::TraverseAttr(Attr *AttrNode) {
   match(*AttrNode);
   return RecursiveASTVisitor<MatchASTVisitor>::TraverseAttr(AttrNode);
 }
 
 class MatchASTConsumer : public ASTConsumer {
 public:
   MatchASTConsumer(MatchFinder *Finder,

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

const internal::VariadicDynCastAllOfMatcher<Decl, ObjCCategoryImplDecl>
     objcCategoryImplDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCMethodDecl>
     objcMethodDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, BlockDecl>
     blockDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCIvarDecl> objcIvarDecl;
 const internal::VariadicDynCastAllOfMatcher<Decl, ObjCPropertyDecl>
     objcPropertyDecl;
+const internal::VariadicDynCastAllOfMatcher<Decl, ObjCTypeParamDecl>
+    objcTypeParamDecl;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
     objcThrowStmt;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt> objcTryStmt;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
     objcCatchStmt;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
     objcFinallyStmt;
 const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>

 const AstTypeMatcher<BuiltinType> builtinType;
 const AstTypeMatcher<ArrayType> arrayType;
 const AstTypeMatcher<ComplexType> complexType;
 const AstTypeMatcher<ConstantArrayType> constantArrayType;
 const AstTypeMatcher<DeducedTemplateSpecializationType>
     deducedTemplateSpecializationType;
 const AstTypeMatcher<DependentSizedArrayType> dependentSizedArrayType;
 const AstTypeMatcher<DependentSizedExtVectorType> dependentSizedExtVectorType;
+const AstTypeMatcher<BitIntType> bitIntType;
+const AstTypeMatcher<DependentBitIntType> dependentBitIntType;
+const AstTypeMatcher<DependentAddressSpaceType> dependentAddressSpaceType;
+const AstTypeMatcher<ConstantMatrixType> constantMatrixType;
+const AstTypeMatcher<DependentSizedMatrixType> dependentSizedMatrixType;
+const AstTypeMatcher<DependentVectorType> dependentVectorType;
+const AstTypeMatcher<VectorType> vectorType;
+const AstTypeMatcher<PipeType> pipeType;
+const AstTypeMatcher<ObjCTypeParamType> objcTypeParamType;
 const AstTypeMatcher<IncompleteArrayType> incompleteArrayType;
 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;

clang/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(atomicType);
   REGISTER_MATCHER(attr);
   REGISTER_MATCHER(autoType);
   REGISTER_MATCHER(autoreleasePoolStmt)
   REGISTER_MATCHER(binaryConditionalOperator);
   REGISTER_MATCHER(binaryOperator);
   REGISTER_MATCHER(binaryOperation);
   REGISTER_MATCHER(bindingDecl);
+  REGISTER_MATCHER(bitIntType);
   REGISTER_MATCHER(blockDecl);
   REGISTER_MATCHER(blockExpr);
   REGISTER_MATCHER(blockPointerType);
   REGISTER_MATCHER(booleanType);
   REGISTER_MATCHER(breakStmt);
   REGISTER_MATCHER(builtinType);
   REGISTER_MATCHER(cStyleCastExpr);
   REGISTER_MATCHER(callExpr);
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(complexType);
   REGISTER_MATCHER(compoundLiteralExpr);
   REGISTER_MATCHER(compoundStmt);
   REGISTER_MATCHER(coawaitExpr);
   REGISTER_MATCHER(conceptDecl);
   REGISTER_MATCHER(conditionalOperator);
   REGISTER_MATCHER(constantArrayType);
   REGISTER_MATCHER(constantExpr);
+  REGISTER_MATCHER(constantMatrixType);
   REGISTER_MATCHER(containsDeclaration);
   REGISTER_MATCHER(continueStmt);
   REGISTER_MATCHER(convertVectorExpr);
   REGISTER_MATCHER(coreturnStmt);
   REGISTER_MATCHER(coroutineBodyStmt);
   REGISTER_MATCHER(coyieldExpr);
   REGISTER_MATCHER(cudaKernelCallExpr);
   REGISTER_MATCHER(cxxBaseSpecifier);
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(decompositionDecl);
   REGISTER_MATCHER(declCountIs);
   REGISTER_MATCHER(declRefExpr);
   REGISTER_MATCHER(declStmt);
   REGISTER_MATCHER(declaratorDecl);
   REGISTER_MATCHER(decltypeType);
   REGISTER_MATCHER(deducedTemplateSpecializationType);
   REGISTER_MATCHER(defaultStmt);
+  REGISTER_MATCHER(dependentAddressSpaceType);
+  REGISTER_MATCHER(dependentBitIntType);
   REGISTER_MATCHER(dependentCoawaitExpr);
   REGISTER_MATCHER(dependentSizedArrayType);
   REGISTER_MATCHER(dependentSizedExtVectorType);
+  REGISTER_MATCHER(dependentSizedMatrixType);
+  REGISTER_MATCHER(dependentVectorType);
   REGISTER_MATCHER(designatedInitExpr);
   REGISTER_MATCHER(designatorCountIs);
   REGISTER_MATCHER(doStmt);
   REGISTER_MATCHER(eachOf);
   REGISTER_MATCHER(elaboratedType);
   REGISTER_MATCHER(elaboratedTypeLoc);
   REGISTER_MATCHER(usingType);
   REGISTER_MATCHER(enumConstantDecl);
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(hasSyntacticForm);
   REGISTER_MATCHER(hasTargetDecl);
   REGISTER_MATCHER(hasTemplateArgument);
   REGISTER_MATCHER(hasTemplateArgumentLoc);
   REGISTER_MATCHER(hasThen);
   REGISTER_MATCHER(hasThreadStorageDuration);
   REGISTER_MATCHER(hasTrailingReturn);
   REGISTER_MATCHER(hasTrueExpression);
+  REGISTER_MATCHER(hasTypeForDecl);
   REGISTER_MATCHER(hasTypeLoc);
   REGISTER_MATCHER(hasUnaryOperand);
   REGISTER_MATCHER(hasUnarySelector);
   REGISTER_MATCHER(hasUnderlyingDecl);
   REGISTER_MATCHER(hasUnderlyingType);
   REGISTER_MATCHER(hasUnqualifiedDesugaredType);
   REGISTER_MATCHER(hasUnqualifiedLoc);
   REGISTER_MATCHER(hasValueType);
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(objcMessageExpr);
   REGISTER_MATCHER(objcMethodDecl);
   REGISTER_MATCHER(objcObjectPointerType);
   REGISTER_MATCHER(objcPropertyDecl);
   REGISTER_MATCHER(objcProtocolDecl);
   REGISTER_MATCHER(objcStringLiteral);
   REGISTER_MATCHER(objcThrowStmt);
   REGISTER_MATCHER(objcTryStmt);
+  REGISTER_MATCHER(objcTypeParamDecl);
+  REGISTER_MATCHER(objcTypeParamType);
   REGISTER_MATCHER(ofClass);
   REGISTER_MATCHER(ofKind);
   REGISTER_MATCHER(ompDefaultClause);
   REGISTER_MATCHER(ompExecutableDirective);
   REGISTER_MATCHER(on);
   REGISTER_MATCHER(onImplicitObjectArgument);
   REGISTER_MATCHER(opaqueValueExpr);
   REGISTER_MATCHER(optionally);
   REGISTER_MATCHER(parameterCountIs);
   REGISTER_MATCHER(parenExpr);
   REGISTER_MATCHER(parenListExpr);
   REGISTER_MATCHER(parenType);
   REGISTER_MATCHER(parmVarDecl);
+  REGISTER_MATCHER(pipeType);
   REGISTER_MATCHER(pointee);
   REGISTER_MATCHER(pointerType);
   REGISTER_MATCHER(pointerTypeLoc);
   REGISTER_MATCHER(predefinedExpr);
   REGISTER_MATCHER(qualType);
   REGISTER_MATCHER(qualifiedTypeLoc);
   REGISTER_MATCHER(rValueReferenceType);
   REGISTER_MATCHER(realFloatingPointType);
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(userDefinedLiteral);
   REGISTER_MATCHER(usesADL);
   REGISTER_MATCHER(usingDecl);
   REGISTER_MATCHER(usingEnumDecl);
   REGISTER_MATCHER(usingDirectiveDecl);
   REGISTER_MATCHER(valueDecl);
   REGISTER_MATCHER(varDecl);
   REGISTER_MATCHER(variableArrayType);
+  REGISTER_MATCHER(vectorType);
   REGISTER_MATCHER(voidType);
   REGISTER_MATCHER(whileStmt);
   REGISTER_MATCHER(withInitializer);
 }
 
 RegistryMaps::~RegistryMaps() = default;
 
 static llvm::ManagedStatic<RegistryMaps> RegistryData;

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

               traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
                                     ignoringParens(stringLiteral()))))));
 }
 
 TEST_P(ASTMatchersTest, QualType) {
   EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
 }
 
+TEST_P(ASTMatchersTest, BitIntType) {
+  StringRef code = "_BitInt(10) i;";
+  EXPECT_TRUE(matches(code, varDecl(hasType(bitIntType()))));
+  EXPECT_TRUE(notMatches(code, varDecl(hasType(builtinType()))));
+}
+
+TEST_P(ASTMatchersTest, ConstantMatrixType) {
+  StringRef Code = "typedef int __attribute__((matrix_type(5, 5))) X;";
+
+  EXPECT_TRUE(matchesWithMatrixEnabled(
+      Code, typedefDecl(hasType(constantMatrixType()))));
+  EXPECT_TRUE(
+      notMatchesWithMatrixEnabled(Code, typedefDecl(hasType(vectorType()))));
+}
+
+TEST_P(ASTMatchersTest, DependentAddressSpaceType) {
+  if (!GetParam().isCXX())
+    return;
+
+  StringRef Code = "template<typename T, int AddrSpace>"
+                   "class vector {"
+                   "  typedef T __attribute__((address_space(AddrSpace))) X;"
+                   "};";
+  EXPECT_TRUE(matches(Code, typedefDecl(hasType(dependentAddressSpaceType()))));
+
+  EXPECT_TRUE(notMatches("int __attribute__((address_space(0))) X;",
+                         typedefDecl(hasType(dependentAddressSpaceType()))));
+}
+
+TEST_P(ASTMatchersTest, DependentBitIntType) {
+  if (!GetParam().isCXX11OrLater())
+    return;
+
+  EXPECT_TRUE(matches("template<int Width> using X = _BitInt(Width);",
+                      typeAliasDecl(hasType(dependentBitIntType()))));
+
+  EXPECT_TRUE(notMatches("typedef _BitInt(10) Int10;",
+                         typedefDecl(hasType(dependentBitIntType()))));
+}
+
+TEST_P(ASTMatchersTest, DependentVectorType) {
+  if (!GetParam().isCXX())
+    return;
+
+  StringRef DepCode = "template<typename T, int Size>"
+                      "class vector {"
+                      "  typedef T __attribute__((vector_size(Size))) X;"
+                      "};";
+  EXPECT_TRUE(matches(DepCode, dependentVectorType()));
+
+  StringRef NonDepCode = "typedef int __attribute__((vector_size(16))) X;";
+  EXPECT_TRUE(notMatches(NonDepCode, dependentVectorType()));
+}
+
+TEST_P(ASTMatchersTest, VectorType) {
+  if (!GetParam().isCXX())
+    return;
+
+  StringRef NonDepCode = "typedef int __attribute__((vector_size(16))) X;";
+  EXPECT_TRUE(matches(NonDepCode, vectorType()));
+
+  StringRef DepCode = "template<typename T, int Size>"
+                      "class vector {"
+                      "  typedef T __attribute__((vector_size(Size))) X;"
+                      "};";
+  EXPECT_TRUE(notMatches(DepCode, vectorType()));
+}
+
+TEST_P(ASTMatchersTest, DependentSizedMatrixType) {
+  if (!GetParam().isCXX())
+    return;
+
+  StringRef DepCode = "template<typename T, int Rows, int Cols>"
+                      "class matrix {"
+                      "  typedef T __attribute__((matrix_type(Rows, Cols))) X;"
+                      "};";
+  EXPECT_TRUE(matchesWithMatrixEnabled(DepCode, dependentSizedMatrixType()));
+
+  StringRef NonDepCode = "typedef int __attribute__((matrix_type(3, 3))) Y;";
+  EXPECT_TRUE(
+      notMatchesWithMatrixEnabled(NonDepCode, dependentSizedMatrixType()));
+}
+
 TEST_P(ASTMatchersTest, ConstantArrayType) {
   EXPECT_TRUE(matches("int a[2];", constantArrayType()));
   EXPECT_TRUE(notMatches("void f() { int a[] = { 2, 3 }; int b[a[0]]; }",
                          constantArrayType(hasElementType(builtinType()))));
 
   EXPECT_TRUE(matches("int a[42];", constantArrayType(hasSize(42))));
   EXPECT_TRUE(matches("int b[2*21];", constantArrayType(hasSize(42))));
   EXPECT_TRUE(notMatches("int c[41], d[43];", constantArrayType(hasSize(42))));

                          "}";
 
   EXPECT_TRUE(matchesObjC(ObjCString, objcTryStmt()));
   EXPECT_TRUE(matchesObjC(ObjCString, objcThrowStmt()));
   EXPECT_TRUE(matchesObjC(ObjCString, objcCatchStmt()));
   EXPECT_TRUE(matchesObjC(ObjCString, objcFinallyStmt()));
 }
 
+TEST(ASTMatchersTestObjC, ObjCTypeParamDecl) {
+  StringRef ObjCString = "@interface Dictionary <FirstParam: id>"
+                         "@end";
+  EXPECT_TRUE(matchesObjC(ObjCString, objcTypeParamDecl()));
+  EXPECT_TRUE(notMatchesObjC(ObjCString, parmVarDecl()));
+}
+
+TEST(ASTMatchersTestObjC, ObjCTypeParamType) {
+  StringRef ObjCString = "@interface Dictionary <FirstParam: id>"
+                         "@end";
+  EXPECT_TRUE(matchesObjC(
+      ObjCString, objcTypeParamDecl(hasTypeForDecl(objcTypeParamType()))));
+  EXPECT_TRUE(notMatchesObjC(ObjCString,
+                             objcTypeParamDecl(hasTypeForDecl(builtinType()))));
+}
+
+TEST(ASTMatchersTestOpenCL, PipeType) {
+  StringRef code = "typedef pipe int X;";
+  EXPECT_TRUE(matchesOpenCL(code, typedefDecl(hasType(pipeType()))));
+  EXPECT_TRUE(notMatchesOpenCL(code, typedefDecl(hasType(isInteger()))));
+}
+
 TEST(ASTMatchersTest, DecompositionDecl) {
   StringRef Code = R"cpp(
 void foo()
 {
     int arr[3];
     auto &[f, s, t] = arr;
 
     f = 42;

clang/unittests/ASTMatchers/ASTMatchersTest.h

 template <typename T>
 testing::AssertionResult notMatchesWithOpenMP51(const Twine &Code,
                                                 const T &AMatcher) {
   return matchesConditionally(Code, AMatcher, false,
                               {"-fopenmp=libomp", "-fopenmp-version=51"});
 }
 
 template <typename T>
+testing::AssertionResult matchesOpenCL(const Twine &Code, const T &AMatcher) {
+  return matchesConditionally(Code, AMatcher, true,
+                              {"-x", "cl", "-cl-no-stdinc", "-cl-std=CL2.0"},
+                              FileContentMappings(), "input.cl");
+}
+
+template <typename T>
+testing::AssertionResult notMatchesOpenCL(const Twine &Code,
+                                          const T &AMatcher) {
+  return matchesConditionally(Code, AMatcher, false,
+                              {"-x", "cl", "-cl-no-stdinc", "-cl-std=CL2.0"},
+                              FileContentMappings(), "input.cl");
+}
+
+template <typename T>
+testing::AssertionResult matchesWithMatrixEnabled(const Twine &Code,
+                                                  const T &AMatcher) {
+  return matchesConditionally(Code, AMatcher, true, {"-fenable-matrix"});
+}
+
+template <typename T>
+testing::AssertionResult notMatchesWithMatrixEnabled(const Twine &Code,
+                                                     const T &AMatcher) {
+  return matchesConditionally(Code, AMatcher, false, {"-fenable-matrix"});
+}
+
+template <typename T>
 testing::AssertionResult matchAndVerifyResultConditionally(
     const Twine &Code, const T &AMatcher,
     std::unique_ptr<BoundNodesCallback> FindResultVerifier, bool ExpectResult) {
   bool VerifiedResult = false;
   MatchFinder Finder;
   VerifyMatch VerifyVerifiedResult(std::move(FindResultVerifier),
                                    &VerifiedResult);
   Finder.addMatcher(AMatcher, &VerifyVerifiedResult);