This is an archive of the discontinued LLVM Phabricator instance.

Differential D127411

[AST Matchers] Make dump_ast_matchers.py work on Python 3
Needs ReviewPublic

Authored by JohnTitor on Jun 9 2022, 9:02 AM.

Details

Reviewers
jdoerfert
Summary

...Also updates the output HTML.
Fixes llvm#46446

Diff Detail

Event Timeline

JohnTitor created this revision.Jun 9 2022, 9:02 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 9 2022, 9:02 AM
JohnTitor requested review of this revision.Jun 9 2022, 9:02 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJun 9 2022, 9:02 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, sstefan1. · View Herald Transcript
Harbormaster completed remote builds in B168846: Diff 435582.Jun 9 2022, 9:54 AM

Revision Contents

PathSize
clang/
docs/
91 lines
tools/
11 lines

Diff 435582

clang/docs/LibASTMatchersReference.html

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,230 Lines • ▼ Show 20 LinesGiven
#pragma omp parallel default(none) #pragma omp parallel default(none)
#pragma omp parallel default(shared) #pragma omp parallel default(shared)
#pragma omp parallel default(private) #pragma omp parallel default(private)
#pragma omp parallel default(firstprivate) #pragma omp parallel default(firstprivate)
#pragma omp parallel #pragma omp parallel
``ompDefaultClause()`` matches ``default(none)``, ``default(shared)``, ``ompDefaultClause()`` matches ``default(none)``, ``default(shared)``,
``default(private)`` and ``default(firstprivate)`` `` default(private)`` and ``default(firstprivate)``
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('qualType0')"><a name="qualType0Anchor">qualType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;...</td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('qualType0')"><a name="qualType0Anchor">qualType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;...</td></tr>
<tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST. <tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST.
</pre></td></tr> </pre></td></tr>
▲ Show 20 Lines • Show All 3,463 Lines • ▼ Show 20 LinesGiven
} }
inline int Foo = 5; inline int Foo = 5;
functionDecl(isInline()) will match ::f(). functionDecl(isInline()) will match ::f().
namespaceDecl(isInline()) will match n::m. namespaceDecl(isInline()) will match n::m.
varDecl(isInline()) will match Foo; varDecl(isInline()) will match Foo;
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isPrivateKind0')"><a name="isPrivateKind0Anchor">isFirstPrivateKind</a></td><td></td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isFirstPrivateKind0')"><a name="isFirstPrivateKind0Anchor">isFirstPrivateKind</a></td><td></td></tr>
<tr><td colspan="4" class="doc" id="isPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``private`` kind <tr><td colspan="4" class="doc" id="isFirstPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``firstprivate`` kind
specified. specified.
Given Given
#pragma omp parallel #pragma omp parallel
#pragma omp parallel default(none) #pragma omp parallel default(none)
#pragma omp parallel default(shared) #pragma omp parallel default(shared)
#pragma omp parallel default(private) #pragma omp parallel default(private)
#pragma omp parallel default(firstprivate) #pragma omp parallel default(firstprivate)
``ompDefaultClause(isFirstPrivateKind())`` matches only ``ompDefaultClause(isFirstPrivateKind())`` matches only
``default(private)``. ``default(firstprivate)``.
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isFirstPrivateKind0')"><a name="isFirstPrivateKind0Anchor">isFirstPrivateKind</a></td><td></td></tr>
<tr><td colspan="4" class="doc" id="isFirstPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``firstprivate`` kind <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isNoneKind0')"><a name="isNoneKind0Anchor">isNoneKind</a></td><td></td></tr>
specified. <tr><td colspan="4" class="doc" id="isNoneKind0"><pre>Matches if the OpenMP ``default`` clause has ``none`` kind specified.
Given Given
#pragma omp parallel #pragma omp parallel
#pragma omp parallel default(none) #pragma omp parallel default(none)
#pragma omp parallel default(shared) #pragma omp parallel default(shared)
#pragma omp parallel default(private) #pragma omp parallel default(private)
#pragma omp parallel default(firstprivate) #pragma omp parallel default(firstprivate)
``ompDefaultClause(isFirstPrivateKind())`` matches only ``ompDefaultClause(isNoneKind())`` matches only ``default(none)``.
``default(firstprivate)``.
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isNoneKind0')"><a name="isNoneKind0Anchor">isNoneKind</a></td><td></td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isPrivateKind0')"><a name="isPrivateKind0Anchor">isPrivateKind</a></td><td></td></tr>
<tr><td colspan="4" class="doc" id="isNoneKind0"><pre>Matches if the OpenMP ``default`` clause has ``none`` kind specified. <tr><td colspan="4" class="doc" id="isPrivateKind0"><pre>Matches if the OpenMP ``default`` clause has ``private`` kind
specified.
Given Given
#pragma omp parallel #pragma omp parallel
#pragma omp parallel default(none) #pragma omp parallel default(none)
#pragma omp parallel default(shared) #pragma omp parallel default(shared)
#pragma omp parallel default(private) #pragma omp parallel default(private)
#pragma omp parallel default(firstprivate) #pragma omp parallel default(firstprivate)
``ompDefaultClause(isNoneKind())`` matches only ``default(none)``. ``ompDefaultClause(isPrivateKind())`` matches only
``default(private)``.
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isSharedKind0')"><a name="isSharedKind0Anchor">isSharedKind</a></td><td></td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;</td><td class="name" onclick="toggle('isSharedKind0')"><a name="isSharedKind0Anchor">isSharedKind</a></td><td></td></tr>
<tr><td colspan="4" class="doc" id="isSharedKind0"><pre>Matches if the OpenMP ``default`` clause has ``shared`` kind specified. <tr><td colspan="4" class="doc" id="isSharedKind0"><pre>Matches if the OpenMP ``default`` clause has ``shared`` kind specified.
Given Given
▲ Show 20 Lines • Show All 2,634 Lines • ▼ Show 20 Lines
URL url = "a string"; URL url = "a string";
Example 2: matches 'b' (matcher = Example 2: matches 'b' (matcher =
opaqueValueExpr(hasSourceExpression(implicitCastExpr(declRefExpr()))) opaqueValueExpr(hasSourceExpression(implicitCastExpr(declRefExpr())))
int a = b ?: 1; int a = b ?: 1;
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument0')"><a name="forEachTemplateArgument0Anchor">forEachTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument0')"><a name="forEachTemplateArgument0Anchor">forEachTemplateArgument</a></td><td>clang::ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="forEachTemplateArgument0"><pre>Matches classTemplateSpecialization, templateSpecializationType and functionDecl nodes where the template argument matches the inner matcher. <tr><td colspan="4" class="doc" id="forEachTemplateArgument0"><pre>Matches classTemplateSpecialization, templateSpecializationType and
functionDecl nodes where the template argument matches the inner matcher.
This matcher may produce multiple matches. This matcher may produce multiple matches.
Given Given
template &lt;typename T, unsigned N, unsigned M&gt; template &lt;typename T, unsigned N, unsigned M&gt;
struct Matrix {}; struct Matrix {};
constexpr unsigned R = 2; constexpr unsigned R = 2;
Matrix&lt;int, R * 2, R * 4&gt; M; Matrix&lt;int, R * 2, R * 4&gt; M;
template &lt;typename T, typename U&gt; template &lt;typename T, typename U&gt;
void f(T&amp;&amp; t, U&amp;&amp; u) {} void f(T&amp;&amp; t, U&amp;&amp; u) {}
bool B = false; bool B = false;
f(R, B); f(R, B);
templateSpecializationType(forEachTemplateArgument(isExpr(expr()))) templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
matches twice, with expr() matching 'R * 2' and 'R * 4' matches twice, with expr() matching 'R * 2' and 'R * 4'
functionDecl(forEachTemplateArgument(refersToType(builtinType()))) functionDecl(forEachTemplateArgument(refersToType(builtinType())))
matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned' matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
and 'bool' and 'bool'
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument0')"><a name="hasAnyTemplateArgument0Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument0')"><a name="hasAnyTemplateArgument0Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="hasAnyTemplateArgument0"><pre>Matches classTemplateSpecializations, templateSpecializationType and <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument0"><pre>Matches classTemplateSpecializations, templateSpecializationType and
▲ Show 20 Lines • Show All 733 Lines • ▼ Show 20 Lines
class X {}; class X {};
void y(X &amp;x) { x; X z; } void y(X &amp;x) { x; X z; }
typedef int U; typedef int U;
class Y { friend class X; }; class Y { friend class X; };
class Z : public virtual X {}; class Z : public virtual X {};
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument2')"><a name="forEachTemplateArgument2Anchor">forEachTemplateArgument</a></td><td>clang::ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="forEachTemplateArgument2"><pre>Matches classTemplateSpecialization, templateSpecializationType and
functionDecl nodes where the template argument matches the inner matcher.
This matcher may produce multiple matches.
Given
template &lt;typename T, unsigned N, unsigned M&gt;
struct Matrix {};
constexpr unsigned R = 2;
Matrix&lt;int, R * 2, R * 4&gt; M;
template &lt;typename T, typename U&gt;
void f(T&amp;&amp; t, U&amp;&amp; u) {}
bool B = false;
f(R, B);
templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
matches twice, with expr() matching 'R * 2' and 'R * 4'
functionDecl(forEachTemplateArgument(refersToType(builtinType())))
matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
and 'bool'
</pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyBody0')"><a name="hasAnyBody0Anchor">hasAnyBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyBody0')"><a name="hasAnyBody0Anchor">hasAnyBody</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="hasAnyBody0"><pre>Matches a function declaration that has a given body present in the AST. <tr><td colspan="4" class="doc" id="hasAnyBody0"><pre>Matches a function declaration that has a given body present in the AST.
Note that this matcher matches all the declarations of a function whose Note that this matcher matches all the declarations of a function whose
body is present in the AST. body is present in the AST.
Given Given
void f(); void f();
void f() {} void f() {}
Show All 31 LinesFor blocks, given
b = ^(int y) { printf("%d", y) }; b = ^(int y) { printf("%d", y) };
the matcher blockDecl(hasAnyParameter(hasName("y"))) the matcher blockDecl(hasAnyParameter(hasName("y")))
matches the declaration of the block b with hasParameter matches the declaration of the block b with hasParameter
matching y. matching y.
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument1')"><a name="forEachTemplateArgument1Anchor">forEachTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="forEachTemplateArgument1"><pre>Matches classTemplateSpecialization, templateSpecializationType and functionDecl nodes where the template argument matches the inner matcher.
This matcher may produce multiple matches.
Given
template &lt;typename T, unsigned N, unsigned M&gt;
struct Matrix {};
constexpr unsigned R = 2;
Matrix&lt;int, R * 2, R * 4&gt; M;
template &lt;typename T, typename U&gt;
void f(T&amp;&amp; t, U&amp;&amp; u) {}
bool B = false;
f(R, B);
templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
matches twice, with expr() matching 'R * 2' and 'R * 4'
functionDecl(forEachTemplateArgument(refersToType(builtinType())))
matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
and 'bool'
</pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument2')"><a name="hasAnyTemplateArgument2Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument2')"><a name="hasAnyTemplateArgument2Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="hasAnyTemplateArgument2"><pre>Matches classTemplateSpecializations, templateSpecializationType and <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument2"><pre>Matches classTemplateSpecializations, templateSpecializationType and
functionDecl that have at least one TemplateArgument matching the given functionDecl that have at least one TemplateArgument matching the given
InnerMatcher. InnerMatcher.
Given Given
template&lt;typename T&gt; class A {}; template&lt;typename T&gt; class A {};
template&lt;&gt; class A&lt;double&gt; {}; template&lt;&gt; class A&lt;double&gt; {};
▲ Show 20 Lines • Show All 1,208 Lines • ▼ Show 20 LinesGiven
A&lt;double, int&gt; b; A&lt;double, int&gt; b;
A&lt;int, double&gt; c; A&lt;int, double&gt; c;
varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0, varDecl(hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(0,
hasTypeLoc(loc(asString("double"))))))) hasTypeLoc(loc(asString("double")))))))
matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`. matches `A&lt;double, int&gt; b`, but not `A&lt;int, double&gt; c`.
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument2')"><a name="forEachTemplateArgument2Anchor">forEachTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('forEachTemplateArgument1')"><a name="forEachTemplateArgument1Anchor">forEachTemplateArgument</a></td><td>clang::ast_matchers::Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="forEachTemplateArgument2"><pre>Matches classTemplateSpecialization, templateSpecializationType and functionDecl nodes where the template argument matches the inner matcher. <tr><td colspan="4" class="doc" id="forEachTemplateArgument1"><pre>Matches classTemplateSpecialization, templateSpecializationType and
functionDecl nodes where the template argument matches the inner matcher.
This matcher may produce multiple matches. This matcher may produce multiple matches.
Given Given
template &lt;typename T, unsigned N, unsigned M&gt; template &lt;typename T, unsigned N, unsigned M&gt;
struct Matrix {}; struct Matrix {};
constexpr unsigned R = 2; constexpr unsigned R = 2;
Matrix&lt;int, R * 2, R * 4&gt; M; Matrix&lt;int, R * 2, R * 4&gt; M;
template &lt;typename T, typename U&gt; template &lt;typename T, typename U&gt;
void f(T&amp;&amp; t, U&amp;&amp; u) {} void f(T&amp;&amp; t, U&amp;&amp; u) {}
bool B = false; bool B = false;
f(R, B); f(R, B);
templateSpecializationType(forEachTemplateArgument(isExpr(expr()))) templateSpecializationType(forEachTemplateArgument(isExpr(expr())))
matches twice, with expr() matching 'R * 2' and 'R * 4' matches twice, with expr() matching 'R * 2' and 'R * 4'
functionDecl(forEachTemplateArgument(refersToType(builtinType()))) functionDecl(forEachTemplateArgument(refersToType(builtinType())))
matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned' matches the specialization f&lt;unsigned, bool&gt; twice, for 'unsigned'
and 'bool' and 'bool'
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument1')"><a name="hasAnyTemplateArgument1Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;</td><td class="name" onclick="toggle('hasAnyTemplateArgument1')"><a name="hasAnyTemplateArgument1Anchor">hasAnyTemplateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="hasAnyTemplateArgument1"><pre>Matches classTemplateSpecializations, templateSpecializationType and <tr><td colspan="4" class="doc" id="hasAnyTemplateArgument1"><pre>Matches classTemplateSpecializations, templateSpecializationType and
▲ Show 20 Lines • Show All 415 Lines • Show Last 20 Lines

clang/docs/tools/dump_ast_matchers.py

#!/usr/bin/env python #!/usr/bin/env python
# A tool to parse ASTMatchers.h and update the documentation in # A tool to parse ASTMatchers.h and update the documentation in
# ../LibASTMatchersReference.html automatically. Run from the # ../LibASTMatchersReference.html automatically. Run from the
# directory in which this file is located to update the docs. # directory in which this file is located to update the docs.
import collections import collections
import re import re
try: try:
from urllib.request import urlopen from urllib.request import urlopen
except ImportError: except ImportError:
from urllib2 import urlopen from urllib2 import urlopen
CLASS_INDEX_PAGE_URL = 'https://clang.llvm.org/doxygen/classes.html' CLASS_INDEX_PAGE_URL = 'https://clang.llvm.org/doxygen/classes.html'
try: try:
CLASS_INDEX_PAGE = urlopen(CLASS_INDEX_PAGE_URL).read() CLASS_INDEX_PAGE = str(urlopen(CLASS_INDEX_PAGE_URL).read())
except Exception as e: except Exception as e:
raise Exception('Unable to get %s: %s' % (CLASS_INDEX_PAGE_URL, e)) raise Exception('Unable to get %s: %s' % (CLASS_INDEX_PAGE_URL, e))
MATCHERS_FILE = '../../include/clang/ASTMatchers/ASTMatchers.h' MATCHERS_FILE = '../../include/clang/ASTMatchers/ASTMatchers.h'
# Each matcher is documented in one row of the form: # Each matcher is documented in one row of the form:
# result | name | argA # result | name | argA
# The subsequent row contains the documentation and is hidden by default, # The subsequent row contains the documentation and is hidden by default,
▲ Show 20 Lines • Show All 374 Lines • ▼ Show 20 Lines m = re.match(
declaration, flags=re.X) declaration, flags=re.X)
if m: if m:
name = m.groups()[0] name = m.groups()[0]
add_matcher('*', name, 'Matcher<*>...Matcher<*>', comment) add_matcher('*', name, 'Matcher<*>...Matcher<*>', comment)
return return
# Parse free standing matcher functions, like: # Parse free standing matcher functions, like:
# Matcher<ResultType> Name(Matcher<ArgumentType> InnerMatcher) { # Matcher<ResultType> Name(Matcher<ArgumentType> InnerMatcher) {
m = re.match(r"""^\s*(?:template\s+<\s*(?:class|typename)\s+(.+)\s*>\s+)? m = re.match(r"""^\s*(?:template\s+<\s*(?:class|typename)\s+(.+)\s*>\s+)?
(.*)\s+ (.*)\s+
([^\s\(]+)\s*\( ([^\s\(]+)\s*\(
(.*) (.*)
\)\s*{""", declaration, re.X) \)\s*{""", declaration, re.X)
if m: if m:
template_name, result, name, args = m.groups() template_name, result, name, args = m.groups()
if template_name: if template_name:
matcherTemplateArgs = re.findall(r'Matcher<\s*(%s)\s*>' % template_name, args) matcherTemplateArgs = re.findall(r'Matcher<\s*(%s)\s*>' % template_name, args)
templateArgs = re.findall(r'(?:^|[\s,<])(%s)(?:$|[\s,>])' % template_name, args) templateArgs = re.findall(r'(?:^|[\s,<])(%s)(?:$|[\s,>])' % template_name, args)
if len(matcherTemplateArgs) < len(templateArgs): if len(matcherTemplateArgs) < len(templateArgs):
# The template name is used naked, so don't replace with `*`` later on # The template name is used naked, so don't replace with `*`` later on
template_name = None template_name = None
else : else :
args = re.sub(r'(^|[\s,<])%s($|[\s,>])' % template_name, r'\1*\2', args) args = re.sub(r'(^|[\s,<])%s($|[\s,>])' % template_name, r'\1*\2', args)
args = ', '.join(p.strip() for p in args.split(',')) args = ', '.join(p.strip() for p in args.split(','))
m = re.match(r'(?:^|.*\s+)internal::(?:Bindable)?Matcher<([^>]+)>$', result) m = re.match(r'(?:^|.*\s+)internal::(?:Bindable)?Matcher<([^>]+)>$', result)
if m: if m:
result_types = [m.group(1)] result_types = [m.group(1)]
if template_name and len(result_types) is 1 and result_types[0] == template_name: if template_name and len(result_types) == 1 and result_types[0] == template_name:
result_types = ['*'] result_types = ['*']
else: else:
result_types = extract_result_types(comment) result_types = extract_result_types(comment)
if not result_types: if not result_types:
if not comment: if not comment:
# Only overloads don't have their own doxygen comments; ignore those. # Only overloads don't have their own doxygen comments; ignore those.
print('Ignoring "%s"' % name) print('Ignoring "%s"' % name)
else: else:
Show All 40 Lines else:
m = re.search(r'is_base_of<([^,]+), NodeType>', line) m = re.search(r'is_base_of<([^,]+), NodeType>', line)
if m and m.group(1): if m and m.group(1):
allowed_types += [m.group(1)] allowed_types += [m.group(1)]
continue continue
if line.strip() and line.lstrip()[0] == '/': if line.strip() and line.lstrip()[0] == '/':
comment += re.sub(r'^/+\s?', '', line) + '\n' comment += re.sub(r'^/+\s?', '', line) + '\n'
else: else:
declaration += ' ' + line declaration += ' ' + line
if ((not line.strip()) or if ((not line.strip()) or
line.rstrip()[-1] == ';' or line.rstrip()[-1] == ';' or
(line.rstrip()[-1] == '{' and line.rstrip()[-3:] != '= {')): (line.rstrip()[-1] == '{' and line.rstrip()[-3:] != '= {')):
if line.strip() and line.rstrip()[-1] == '{': if line.strip() and line.rstrip()[-1] == '{':
body = True body = True
else: else:
act_on_decl(declaration, comment, allowed_types) act_on_decl(declaration, comment, allowed_types)
comment = '' comment = ''
declaration = '' declaration = ''
allowed_types = [] allowed_types = []
node_matcher_table = sort_table('DECL', node_matchers) node_matcher_table = sort_table('DECL', node_matchers)
narrowing_matcher_table = sort_table('NARROWING', narrowing_matchers) narrowing_matcher_table = sort_table('NARROWING', narrowing_matchers)
traversal_matcher_table = sort_table('TRAVERSAL', traversal_matchers) traversal_matcher_table = sort_table('TRAVERSAL', traversal_matchers)
reference = open('../LibASTMatchersReference.html').read() reference = open('../LibASTMatchersReference.html').read()
reference = re.sub(r'<!-- START_DECL_MATCHERS.*END_DECL_MATCHERS -->', reference = re.sub(r'<!-- START_DECL_MATCHERS.*END_DECL_MATCHERS -->',
node_matcher_table, reference, flags=re.S) node_matcher_table, reference, flags=re.S)
reference = re.sub(r'<!-- START_NARROWING_MATCHERS.*END_NARROWING_MATCHERS -->', reference = re.sub(r'<!-- START_NARROWING_MATCHERS.*END_NARROWING_MATCHERS -->',
narrowing_matcher_table, reference, flags=re.S) narrowing_matcher_table, reference, flags=re.S)
reference = re.sub(r'<!-- START_TRAVERSAL_MATCHERS.*END_TRAVERSAL_MATCHERS -->', reference = re.sub(r'<!-- START_TRAVERSAL_MATCHERS.*END_TRAVERSAL_MATCHERS -->',
traversal_matcher_table, reference, flags=re.S) traversal_matcher_table, reference, flags=re.S)
with open('../LibASTMatchersReference.html', 'wb') as output: with open('../LibASTMatchersReference.html', 'w') as output:
output.write(reference) output.write(reference)