/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/AST/ASTNodeTraverser.h
Line | Count | Source (jump to first uncovered line) |
1 | | //===--- ASTNodeTraverser.h - Traversal of AST nodes ----------------------===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | // |
9 | | // This file implements the AST traversal facilities. Other users |
10 | | // of this class may make use of the same traversal logic by inheriting it, |
11 | | // similar to RecursiveASTVisitor. |
12 | | // |
13 | | //===----------------------------------------------------------------------===// |
14 | | |
15 | | #ifndef LLVM_CLANG_AST_ASTNODETRAVERSER_H |
16 | | #define LLVM_CLANG_AST_ASTNODETRAVERSER_H |
17 | | |
18 | | #include "clang/AST/AttrVisitor.h" |
19 | | #include "clang/AST/CommentVisitor.h" |
20 | | #include "clang/AST/DeclVisitor.h" |
21 | | #include "clang/AST/LocInfoType.h" |
22 | | #include "clang/AST/StmtVisitor.h" |
23 | | #include "clang/AST/TemplateArgumentVisitor.h" |
24 | | #include "clang/AST/TypeVisitor.h" |
25 | | |
26 | | namespace clang { |
27 | | |
28 | | /** |
29 | | |
30 | | ASTNodeTraverser traverses the Clang AST for dumping purposes. |
31 | | |
32 | | The `Derived::doGetNodeDelegate()` method is required to be an accessible member |
33 | | which returns a reference of type `NodeDelegateType &` which implements the |
34 | | following interface: |
35 | | |
36 | | struct { |
37 | | template <typename Fn> void AddChild(Fn DoAddChild); |
38 | | template <typename Fn> void AddChild(StringRef Label, Fn DoAddChild); |
39 | | |
40 | | void Visit(const comments::Comment *C, const comments::FullComment *FC); |
41 | | void Visit(const Attr *A); |
42 | | void Visit(const TemplateArgument &TA, SourceRange R = {}, |
43 | | const Decl *From = nullptr, StringRef Label = {}); |
44 | | void Visit(const Stmt *Node); |
45 | | void Visit(const Type *T); |
46 | | void Visit(QualType T); |
47 | | void Visit(const Decl *D); |
48 | | void Visit(const CXXCtorInitializer *Init); |
49 | | void Visit(const OMPClause *C); |
50 | | void Visit(const BlockDecl::Capture &C); |
51 | | void Visit(const GenericSelectionExpr::ConstAssociation &A); |
52 | | }; |
53 | | */ |
54 | | template <typename Derived, typename NodeDelegateType> |
55 | | class ASTNodeTraverser |
56 | | : public ConstDeclVisitor<Derived>, |
57 | | public ConstStmtVisitor<Derived>, |
58 | | public comments::ConstCommentVisitor<Derived, void, |
59 | | const comments::FullComment *>, |
60 | | public TypeVisitor<Derived>, |
61 | | public ConstAttrVisitor<Derived>, |
62 | | public ConstTemplateArgumentVisitor<Derived> { |
63 | | |
64 | | /// Indicates whether we should trigger deserialization of nodes that had |
65 | | /// not already been loaded. |
66 | | bool Deserialize = false; |
67 | | |
68 | 75.3k | NodeDelegateType &getNodeDelegate() { |
69 | 75.3k | return getDerived().doGetNodeDelegate(); |
70 | 75.3k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::getNodeDelegate() Line | Count | Source | 68 | 70.2k | NodeDelegateType &getNodeDelegate() { | 69 | 70.2k | return getDerived().doGetNodeDelegate(); | 70 | 70.2k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::getNodeDelegate() Line | Count | Source | 68 | 5.09k | NodeDelegateType &getNodeDelegate() { | 69 | 5.09k | return getDerived().doGetNodeDelegate(); | 70 | 5.09k | } |
|
71 | 75.3k | Derived &getDerived() { return *static_cast<Derived *>(this); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::getDerived() Line | Count | Source | 71 | 70.2k | Derived &getDerived() { return *static_cast<Derived *>(this); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::getDerived() Line | Count | Source | 71 | 5.09k | Derived &getDerived() { return *static_cast<Derived *>(this); } |
|
72 | | |
73 | | public: |
74 | 863 | void setDeserialize(bool D) { Deserialize = D; } |
75 | 7 | bool getDeserialize() const { return Deserialize; } |
76 | | |
77 | 14.2k | void Visit(const Decl *D) { |
78 | 14.2k | getNodeDelegate().AddChild([=] { |
79 | 14.2k | getNodeDelegate().Visit(D); |
80 | 14.2k | if (!D) |
81 | 3 | return; |
82 | 14.2k | |
83 | 14.2k | ConstDeclVisitor<Derived>::Visit(D); |
84 | 14.2k | |
85 | 14.2k | for (const auto &A : D->attrs()) |
86 | 1.05k | Visit(A); |
87 | 14.2k | |
88 | 14.2k | if (const comments::FullComment *Comment = |
89 | 37 | D->getASTContext().getLocalCommentForDeclUncached(D)) |
90 | 37 | Visit(Comment, Comment); |
91 | 14.2k | |
92 | 14.2k | // Decls within functions are visited by the body. |
93 | 14.2k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)12.0k ) { |
94 | 11.9k | if (const auto *DC = dyn_cast<DeclContext>(D)) |
95 | 2.83k | dumpDeclContext(DC); |
96 | 11.9k | } |
97 | 14.2k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Decl const*)::'lambda'()::operator()() const Line | Count | Source | 78 | 13.3k | getNodeDelegate().AddChild([=] { | 79 | 13.3k | getNodeDelegate().Visit(D); | 80 | 13.3k | if (!D) | 81 | 2 | return; | 82 | 13.3k | | 83 | 13.3k | ConstDeclVisitor<Derived>::Visit(D); | 84 | 13.3k | | 85 | 13.3k | for (const auto &A : D->attrs()) | 86 | 1.04k | Visit(A); | 87 | 13.3k | | 88 | 13.3k | if (const comments::FullComment *Comment = | 89 | 25 | D->getASTContext().getLocalCommentForDeclUncached(D)) | 90 | 25 | Visit(Comment, Comment); | 91 | 13.3k | | 92 | 13.3k | // Decls within functions are visited by the body. | 93 | 13.3k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)11.3k ) { | 94 | 11.2k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 95 | 2.63k | dumpDeclContext(DC); | 96 | 11.2k | } | 97 | 13.3k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Decl const*)::'lambda'()::operator()() const Line | Count | Source | 78 | 934 | getNodeDelegate().AddChild([=] { | 79 | 934 | getNodeDelegate().Visit(D); | 80 | 934 | if (!D) | 81 | 1 | return; | 82 | 933 | | 83 | 933 | ConstDeclVisitor<Derived>::Visit(D); | 84 | 933 | | 85 | 933 | for (const auto &A : D->attrs()) | 86 | 9 | Visit(A); | 87 | 933 | | 88 | 933 | if (const comments::FullComment *Comment = | 89 | 12 | D->getASTContext().getLocalCommentForDeclUncached(D)) | 90 | 12 | Visit(Comment, Comment); | 91 | 933 | | 92 | 933 | // Decls within functions are visited by the body. | 93 | 933 | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)699 ) { | 94 | 688 | if (const auto *DC = dyn_cast<DeclContext>(D)) | 95 | 204 | dumpDeclContext(DC); | 96 | 688 | } | 97 | 933 | }); |
|
98 | 14.2k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Decl const*) Line | Count | Source | 77 | 13.3k | void Visit(const Decl *D) { | 78 | 13.3k | getNodeDelegate().AddChild([=] { | 79 | 13.3k | getNodeDelegate().Visit(D); | 80 | 13.3k | if (!D) | 81 | 13.3k | return; | 82 | 13.3k | | 83 | 13.3k | ConstDeclVisitor<Derived>::Visit(D); | 84 | 13.3k | | 85 | 13.3k | for (const auto &A : D->attrs()) | 86 | 13.3k | Visit(A); | 87 | 13.3k | | 88 | 13.3k | if (const comments::FullComment *Comment = | 89 | 13.3k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 90 | 13.3k | Visit(Comment, Comment); | 91 | 13.3k | | 92 | 13.3k | // Decls within functions are visited by the body. | 93 | 13.3k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) { | 94 | 13.3k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 95 | 13.3k | dumpDeclContext(DC); | 96 | 13.3k | } | 97 | 13.3k | }); | 98 | 13.3k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Decl const*) Line | Count | Source | 77 | 934 | void Visit(const Decl *D) { | 78 | 934 | getNodeDelegate().AddChild([=] { | 79 | 934 | getNodeDelegate().Visit(D); | 80 | 934 | if (!D) | 81 | 934 | return; | 82 | 934 | | 83 | 934 | ConstDeclVisitor<Derived>::Visit(D); | 84 | 934 | | 85 | 934 | for (const auto &A : D->attrs()) | 86 | 934 | Visit(A); | 87 | 934 | | 88 | 934 | if (const comments::FullComment *Comment = | 89 | 934 | D->getASTContext().getLocalCommentForDeclUncached(D)) | 90 | 934 | Visit(Comment, Comment); | 91 | 934 | | 92 | 934 | // Decls within functions are visited by the body. | 93 | 934 | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) { | 94 | 934 | if (const auto *DC = dyn_cast<DeclContext>(D)) | 95 | 934 | dumpDeclContext(DC); | 96 | 934 | } | 97 | 934 | }); | 98 | 934 | } |
|
99 | | |
100 | 19.6k | void Visit(const Stmt *S, StringRef Label = {}) { |
101 | 19.6k | getNodeDelegate().AddChild(Label, [=] { |
102 | 19.6k | getNodeDelegate().Visit(S); |
103 | 19.6k | |
104 | 19.6k | if (!S) { |
105 | 772 | return; |
106 | 772 | } |
107 | 18.8k | |
108 | 18.8k | ConstStmtVisitor<Derived>::Visit(S); |
109 | 18.8k | |
110 | 18.8k | // Some statements have custom mechanisms for dumping their children. |
111 | 18.8k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)17.6k ) { |
112 | 1.22k | return; |
113 | 1.22k | } |
114 | 17.6k | |
115 | 17.6k | for (const Stmt *SubStmt : S->children()) |
116 | 15.1k | Visit(SubStmt); |
117 | 17.6k | }); clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef)::'lambda'()::operator()() const Line | Count | Source | 101 | 1.37k | getNodeDelegate().AddChild(Label, [=] { | 102 | 1.37k | getNodeDelegate().Visit(S); | 103 | 1.37k | | 104 | 1.37k | if (!S) { | 105 | 18 | return; | 106 | 18 | } | 107 | 1.35k | | 108 | 1.35k | ConstStmtVisitor<Derived>::Visit(S); | 109 | 1.35k | | 110 | 1.35k | // Some statements have custom mechanisms for dumping their children. | 111 | 1.35k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)1.30k ) { | 112 | 59 | return; | 113 | 59 | } | 114 | 1.29k | | 115 | 1.29k | for (const Stmt *SubStmt : S->children()) | 116 | 1.12k | Visit(SubStmt); | 117 | 1.29k | }); |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef)::'lambda'()::operator()() const Line | Count | Source | 101 | 18.2k | getNodeDelegate().AddChild(Label, [=] { | 102 | 18.2k | getNodeDelegate().Visit(S); | 103 | 18.2k | | 104 | 18.2k | if (!S) { | 105 | 754 | return; | 106 | 754 | } | 107 | 17.5k | | 108 | 17.5k | ConstStmtVisitor<Derived>::Visit(S); | 109 | 17.5k | | 110 | 17.5k | // Some statements have custom mechanisms for dumping their children. | 111 | 17.5k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)16.3k ) { | 112 | 1.16k | return; | 113 | 1.16k | } | 114 | 16.3k | | 115 | 16.3k | for (const Stmt *SubStmt : S->children()) | 116 | 14.0k | Visit(SubStmt); | 117 | 16.3k | }); |
|
118 | 19.6k | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef) Line | Count | Source | 100 | 1.37k | void Visit(const Stmt *S, StringRef Label = {}) { | 101 | 1.37k | getNodeDelegate().AddChild(Label, [=] { | 102 | 1.37k | getNodeDelegate().Visit(S); | 103 | 1.37k | | 104 | 1.37k | if (!S) { | 105 | 1.37k | return; | 106 | 1.37k | } | 107 | 1.37k | | 108 | 1.37k | ConstStmtVisitor<Derived>::Visit(S); | 109 | 1.37k | | 110 | 1.37k | // Some statements have custom mechanisms for dumping their children. | 111 | 1.37k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)) { | 112 | 1.37k | return; | 113 | 1.37k | } | 114 | 1.37k | | 115 | 1.37k | for (const Stmt *SubStmt : S->children()) | 116 | 1.37k | Visit(SubStmt); | 117 | 1.37k | }); | 118 | 1.37k | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef) Line | Count | Source | 100 | 18.2k | void Visit(const Stmt *S, StringRef Label = {}) { | 101 | 18.2k | getNodeDelegate().AddChild(Label, [=] { | 102 | 18.2k | getNodeDelegate().Visit(S); | 103 | 18.2k | | 104 | 18.2k | if (!S) { | 105 | 18.2k | return; | 106 | 18.2k | } | 107 | 18.2k | | 108 | 18.2k | ConstStmtVisitor<Derived>::Visit(S); | 109 | 18.2k | | 110 | 18.2k | // Some statements have custom mechanisms for dumping their children. | 111 | 18.2k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)) { | 112 | 18.2k | return; | 113 | 18.2k | } | 114 | 18.2k | | 115 | 18.2k | for (const Stmt *SubStmt : S->children()) | 116 | 18.2k | Visit(SubStmt); | 117 | 18.2k | }); | 118 | 18.2k | } |
|
119 | | |
120 | 1.61k | void Visit(QualType T) { |
121 | 1.61k | SplitQualType SQT = T.split(); |
122 | 1.61k | if (!SQT.Quals.hasQualifiers()) |
123 | 1.61k | return Visit(SQT.Ty); |
124 | 6 | |
125 | 6 | getNodeDelegate().AddChild([=] { |
126 | 6 | getNodeDelegate().Visit(T); |
127 | 6 | Visit(T.split().Ty); |
128 | 6 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::QualType)::'lambda'()::operator()() const Line | Count | Source | 125 | 5 | getNodeDelegate().AddChild([=] { | 126 | 5 | getNodeDelegate().Visit(T); | 127 | 5 | Visit(T.split().Ty); | 128 | 5 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::QualType)::'lambda'()::operator()() const Line | Count | Source | 125 | 1 | getNodeDelegate().AddChild([=] { | 126 | 1 | getNodeDelegate().Visit(T); | 127 | 1 | Visit(T.split().Ty); | 128 | 1 | }); |
|
129 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::QualType) Line | Count | Source | 120 | 1.47k | void Visit(QualType T) { | 121 | 1.47k | SplitQualType SQT = T.split(); | 122 | 1.47k | if (!SQT.Quals.hasQualifiers()) | 123 | 1.47k | return Visit(SQT.Ty); | 124 | 5 | | 125 | 5 | getNodeDelegate().AddChild([=] { | 126 | 5 | getNodeDelegate().Visit(T); | 127 | 5 | Visit(T.split().Ty); | 128 | 5 | }); | 129 | 5 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::QualType) Line | Count | Source | 120 | 140 | void Visit(QualType T) { | 121 | 140 | SplitQualType SQT = T.split(); | 122 | 140 | if (!SQT.Quals.hasQualifiers()) | 123 | 139 | return Visit(SQT.Ty); | 124 | 1 | | 125 | 1 | getNodeDelegate().AddChild([=] { | 126 | 1 | getNodeDelegate().Visit(T); | 127 | 1 | Visit(T.split().Ty); | 128 | 1 | }); | 129 | 1 | } |
|
130 | | |
131 | 1.62k | void Visit(const Type *T) { |
132 | 1.62k | getNodeDelegate().AddChild([=] { |
133 | 1.62k | getNodeDelegate().Visit(T); |
134 | 1.62k | if (!T) |
135 | 0 | return; |
136 | 1.62k | TypeVisitor<Derived>::Visit(T); |
137 | 1.62k | |
138 | 1.62k | QualType SingleStepDesugar = |
139 | 1.62k | T->getLocallyUnqualifiedSingleStepDesugaredType(); |
140 | 1.62k | if (SingleStepDesugar != QualType(T, 0)) |
141 | 56 | Visit(SingleStepDesugar); |
142 | 1.62k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Type const*)::'lambda'()::operator()() const Line | Count | Source | 132 | 1.48k | getNodeDelegate().AddChild([=] { | 133 | 1.48k | getNodeDelegate().Visit(T); | 134 | 1.48k | if (!T) | 135 | 0 | return; | 136 | 1.48k | TypeVisitor<Derived>::Visit(T); | 137 | 1.48k | | 138 | 1.48k | QualType SingleStepDesugar = | 139 | 1.48k | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 140 | 1.48k | if (SingleStepDesugar != QualType(T, 0)) | 141 | 49 | Visit(SingleStepDesugar); | 142 | 1.48k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Type const*)::'lambda'()::operator()() const Line | Count | Source | 132 | 142 | getNodeDelegate().AddChild([=] { | 133 | 142 | getNodeDelegate().Visit(T); | 134 | 142 | if (!T) | 135 | 0 | return; | 136 | 142 | TypeVisitor<Derived>::Visit(T); | 137 | 142 | | 138 | 142 | QualType SingleStepDesugar = | 139 | 142 | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 140 | 142 | if (SingleStepDesugar != QualType(T, 0)) | 141 | 7 | Visit(SingleStepDesugar); | 142 | 142 | }); |
|
143 | 1.62k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Type const*) Line | Count | Source | 131 | 1.48k | void Visit(const Type *T) { | 132 | 1.48k | getNodeDelegate().AddChild([=] { | 133 | 1.48k | getNodeDelegate().Visit(T); | 134 | 1.48k | if (!T) | 135 | 1.48k | return; | 136 | 1.48k | TypeVisitor<Derived>::Visit(T); | 137 | 1.48k | | 138 | 1.48k | QualType SingleStepDesugar = | 139 | 1.48k | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 140 | 1.48k | if (SingleStepDesugar != QualType(T, 0)) | 141 | 1.48k | Visit(SingleStepDesugar); | 142 | 1.48k | }); | 143 | 1.48k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Type const*) Line | Count | Source | 131 | 142 | void Visit(const Type *T) { | 132 | 142 | getNodeDelegate().AddChild([=] { | 133 | 142 | getNodeDelegate().Visit(T); | 134 | 142 | if (!T) | 135 | 142 | return; | 136 | 142 | TypeVisitor<Derived>::Visit(T); | 137 | 142 | | 138 | 142 | QualType SingleStepDesugar = | 139 | 142 | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 140 | 142 | if (SingleStepDesugar != QualType(T, 0)) | 141 | 142 | Visit(SingleStepDesugar); | 142 | 142 | }); | 143 | 142 | } |
|
144 | | |
145 | 1.05k | void Visit(const Attr *A) { |
146 | 1.05k | getNodeDelegate().AddChild([=] { |
147 | 1.05k | getNodeDelegate().Visit(A); |
148 | 1.05k | ConstAttrVisitor<Derived>::Visit(A); |
149 | 1.05k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Attr const*)::'lambda'()::operator()() const Line | Count | Source | 146 | 1.04k | getNodeDelegate().AddChild([=] { | 147 | 1.04k | getNodeDelegate().Visit(A); | 148 | 1.04k | ConstAttrVisitor<Derived>::Visit(A); | 149 | 1.04k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Attr const*)::'lambda'()::operator()() const Line | Count | Source | 146 | 9 | getNodeDelegate().AddChild([=] { | 147 | 9 | getNodeDelegate().Visit(A); | 148 | 9 | ConstAttrVisitor<Derived>::Visit(A); | 149 | 9 | }); |
|
150 | 1.05k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Attr const*) Line | Count | Source | 145 | 1.04k | void Visit(const Attr *A) { | 146 | 1.04k | getNodeDelegate().AddChild([=] { | 147 | 1.04k | getNodeDelegate().Visit(A); | 148 | 1.04k | ConstAttrVisitor<Derived>::Visit(A); | 149 | 1.04k | }); | 150 | 1.04k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Attr const*) Line | Count | Source | 145 | 9 | void Visit(const Attr *A) { | 146 | 9 | getNodeDelegate().AddChild([=] { | 147 | 9 | getNodeDelegate().Visit(A); | 148 | 9 | ConstAttrVisitor<Derived>::Visit(A); | 149 | 9 | }); | 150 | 9 | } |
|
151 | | |
152 | 86 | void Visit(const CXXCtorInitializer *Init) { |
153 | 86 | getNodeDelegate().AddChild([=] { |
154 | 86 | getNodeDelegate().Visit(Init); |
155 | 86 | Visit(Init->getInit()); |
156 | 86 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::CXXCtorInitializer const*)::'lambda'()::operator()() const Line | Count | Source | 153 | 86 | getNodeDelegate().AddChild([=] { | 154 | 86 | getNodeDelegate().Visit(Init); | 155 | 86 | Visit(Init->getInit()); | 156 | 86 | }); |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::CXXCtorInitializer const*)::'lambda'()::operator()() const |
157 | 86 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::CXXCtorInitializer const*) Line | Count | Source | 152 | 86 | void Visit(const CXXCtorInitializer *Init) { | 153 | 86 | getNodeDelegate().AddChild([=] { | 154 | 86 | getNodeDelegate().Visit(Init); | 155 | 86 | Visit(Init->getInit()); | 156 | 86 | }); | 157 | 86 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::CXXCtorInitializer const*) |
158 | | |
159 | | void Visit(const TemplateArgument &A, SourceRange R = {}, |
160 | 213 | const Decl *From = nullptr, const char *Label = nullptr) { |
161 | 213 | getNodeDelegate().AddChild([=] { |
162 | 213 | getNodeDelegate().Visit(A, R, From, Label); |
163 | 213 | ConstTemplateArgumentVisitor<Derived>::Visit(A); |
164 | 213 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*)::'lambda'()::operator()() const Line | Count | Source | 161 | 206 | getNodeDelegate().AddChild([=] { | 162 | 206 | getNodeDelegate().Visit(A, R, From, Label); | 163 | 206 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 164 | 206 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*)::'lambda'()::operator()() const Line | Count | Source | 161 | 7 | getNodeDelegate().AddChild([=] { | 162 | 7 | getNodeDelegate().Visit(A, R, From, Label); | 163 | 7 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 164 | 7 | }); |
|
165 | 213 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*) Line | Count | Source | 160 | 206 | const Decl *From = nullptr, const char *Label = nullptr) { | 161 | 206 | getNodeDelegate().AddChild([=] { | 162 | 206 | getNodeDelegate().Visit(A, R, From, Label); | 163 | 206 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 164 | 206 | }); | 165 | 206 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*) Line | Count | Source | 160 | 7 | const Decl *From = nullptr, const char *Label = nullptr) { | 161 | 7 | getNodeDelegate().AddChild([=] { | 162 | 7 | getNodeDelegate().Visit(A, R, From, Label); | 163 | 7 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 164 | 7 | }); | 165 | 7 | } |
|
166 | | |
167 | 8 | void Visit(const BlockDecl::Capture &C) { |
168 | 8 | getNodeDelegate().AddChild([=] { |
169 | 8 | getNodeDelegate().Visit(C); |
170 | 8 | if (C.hasCopyExpr()) |
171 | 2 | Visit(C.getCopyExpr()); |
172 | 8 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::BlockDecl::Capture const&)::'lambda'()::operator()() const Line | Count | Source | 168 | 5 | getNodeDelegate().AddChild([=] { | 169 | 5 | getNodeDelegate().Visit(C); | 170 | 5 | if (C.hasCopyExpr()) | 171 | 2 | Visit(C.getCopyExpr()); | 172 | 5 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::BlockDecl::Capture const&)::'lambda'()::operator()() const Line | Count | Source | 168 | 3 | getNodeDelegate().AddChild([=] { | 169 | 3 | getNodeDelegate().Visit(C); | 170 | 3 | if (C.hasCopyExpr()) | 171 | 0 | Visit(C.getCopyExpr()); | 172 | 3 | }); |
|
173 | 8 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::BlockDecl::Capture const&) Line | Count | Source | 167 | 5 | void Visit(const BlockDecl::Capture &C) { | 168 | 5 | getNodeDelegate().AddChild([=] { | 169 | 5 | getNodeDelegate().Visit(C); | 170 | 5 | if (C.hasCopyExpr()) | 171 | 5 | Visit(C.getCopyExpr()); | 172 | 5 | }); | 173 | 5 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::BlockDecl::Capture const&) Line | Count | Source | 167 | 3 | void Visit(const BlockDecl::Capture &C) { | 168 | 3 | getNodeDelegate().AddChild([=] { | 169 | 3 | getNodeDelegate().Visit(C); | 170 | 3 | if (C.hasCopyExpr()) | 171 | 3 | Visit(C.getCopyExpr()); | 172 | 3 | }); | 173 | 3 | } |
|
174 | | |
175 | 158 | void Visit(const OMPClause *C) { |
176 | 158 | getNodeDelegate().AddChild([=] { |
177 | 158 | getNodeDelegate().Visit(C); |
178 | 158 | for (const auto *S : C->children()) |
179 | 220 | Visit(S); |
180 | 158 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::OMPClause const*)::'lambda'()::operator()() const Line | Count | Source | 176 | 158 | getNodeDelegate().AddChild([=] { | 177 | 158 | getNodeDelegate().Visit(C); | 178 | 158 | for (const auto *S : C->children()) | 179 | 220 | Visit(S); | 180 | 158 | }); |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::OMPClause const*)::'lambda'()::operator()() const |
181 | 158 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::OMPClause const*) Line | Count | Source | 175 | 158 | void Visit(const OMPClause *C) { | 176 | 158 | getNodeDelegate().AddChild([=] { | 177 | 158 | getNodeDelegate().Visit(C); | 178 | 158 | for (const auto *S : C->children()) | 179 | 158 | Visit(S); | 180 | 158 | }); | 181 | 158 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::OMPClause const*) |
182 | | |
183 | 21 | void Visit(const GenericSelectionExpr::ConstAssociation &A) { |
184 | 21 | getNodeDelegate().AddChild([=] { |
185 | 21 | getNodeDelegate().Visit(A); |
186 | 21 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) |
187 | 13 | Visit(TSI->getType()); |
188 | 21 | Visit(A.getAssociationExpr()); |
189 | 21 | }); clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::GenericSelectionExpr::AssociationTy<true> const&)::'lambda'()::operator()() const Line | Count | Source | 184 | 12 | getNodeDelegate().AddChild([=] { | 185 | 12 | getNodeDelegate().Visit(A); | 186 | 12 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) | 187 | 7 | Visit(TSI->getType()); | 188 | 12 | Visit(A.getAssociationExpr()); | 189 | 12 | }); |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::GenericSelectionExpr::AssociationTy<true> const&)::'lambda'()::operator()() const Line | Count | Source | 184 | 9 | getNodeDelegate().AddChild([=] { | 185 | 9 | getNodeDelegate().Visit(A); | 186 | 9 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) | 187 | 6 | Visit(TSI->getType()); | 188 | 9 | Visit(A.getAssociationExpr()); | 189 | 9 | }); |
|
190 | 21 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::GenericSelectionExpr::AssociationTy<true> const&) Line | Count | Source | 183 | 12 | void Visit(const GenericSelectionExpr::ConstAssociation &A) { | 184 | 12 | getNodeDelegate().AddChild([=] { | 185 | 12 | getNodeDelegate().Visit(A); | 186 | 12 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) | 187 | 12 | Visit(TSI->getType()); | 188 | 12 | Visit(A.getAssociationExpr()); | 189 | 12 | }); | 190 | 12 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::GenericSelectionExpr::AssociationTy<true> const&) Line | Count | Source | 183 | 9 | void Visit(const GenericSelectionExpr::ConstAssociation &A) { | 184 | 9 | getNodeDelegate().AddChild([=] { | 185 | 9 | getNodeDelegate().Visit(A); | 186 | 9 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) | 187 | 9 | Visit(TSI->getType()); | 188 | 9 | Visit(A.getAssociationExpr()); | 189 | 9 | }); | 190 | 9 | } |
|
191 | | |
192 | 577 | void Visit(const comments::Comment *C, const comments::FullComment *FC) { |
193 | 577 | getNodeDelegate().AddChild([=] { |
194 | 577 | getNodeDelegate().Visit(C, FC); |
195 | 577 | if (!C) { |
196 | 0 | return; |
197 | 0 | } |
198 | 577 | comments::ConstCommentVisitor<Derived, void, |
199 | 577 | const comments::FullComment *>::visit(C, |
200 | 577 | FC); |
201 | 577 | for (comments::Comment::child_iterator I = C->child_begin(), |
202 | 577 | E = C->child_end(); |
203 | 1.03k | I != E; ++I461 ) |
204 | 461 | Visit(*I, FC); |
205 | 577 | }); clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::comments::Comment const*, clang::comments::FullComment const*)::'lambda'()::operator()() const Line | Count | Source | 193 | 64 | getNodeDelegate().AddChild([=] { | 194 | 64 | getNodeDelegate().Visit(C, FC); | 195 | 64 | if (!C) { | 196 | 0 | return; | 197 | 0 | } | 198 | 64 | comments::ConstCommentVisitor<Derived, void, | 199 | 64 | const comments::FullComment *>::visit(C, | 200 | 64 | FC); | 201 | 64 | for (comments::Comment::child_iterator I = C->child_begin(), | 202 | 64 | E = C->child_end(); | 203 | 116 | I != E; ++I52 ) | 204 | 52 | Visit(*I, FC); | 205 | 64 | }); |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::comments::Comment const*, clang::comments::FullComment const*)::'lambda'()::operator()() const Line | Count | Source | 193 | 513 | getNodeDelegate().AddChild([=] { | 194 | 513 | getNodeDelegate().Visit(C, FC); | 195 | 513 | if (!C) { | 196 | 0 | return; | 197 | 0 | } | 198 | 513 | comments::ConstCommentVisitor<Derived, void, | 199 | 513 | const comments::FullComment *>::visit(C, | 200 | 513 | FC); | 201 | 513 | for (comments::Comment::child_iterator I = C->child_begin(), | 202 | 513 | E = C->child_end(); | 203 | 922 | I != E; ++I409 ) | 204 | 409 | Visit(*I, FC); | 205 | 513 | }); |
|
206 | 577 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::comments::Comment const*, clang::comments::FullComment const*) Line | Count | Source | 192 | 64 | void Visit(const comments::Comment *C, const comments::FullComment *FC) { | 193 | 64 | getNodeDelegate().AddChild([=] { | 194 | 64 | getNodeDelegate().Visit(C, FC); | 195 | 64 | if (!C) { | 196 | 64 | return; | 197 | 64 | } | 198 | 64 | comments::ConstCommentVisitor<Derived, void, | 199 | 64 | const comments::FullComment *>::visit(C, | 200 | 64 | FC); | 201 | 64 | for (comments::Comment::child_iterator I = C->child_begin(), | 202 | 64 | E = C->child_end(); | 203 | 64 | I != E; ++I) | 204 | 64 | Visit(*I, FC); | 205 | 64 | }); | 206 | 64 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::comments::Comment const*, clang::comments::FullComment const*) Line | Count | Source | 192 | 513 | void Visit(const comments::Comment *C, const comments::FullComment *FC) { | 193 | 513 | getNodeDelegate().AddChild([=] { | 194 | 513 | getNodeDelegate().Visit(C, FC); | 195 | 513 | if (!C) { | 196 | 513 | return; | 197 | 513 | } | 198 | 513 | comments::ConstCommentVisitor<Derived, void, | 199 | 513 | const comments::FullComment *>::visit(C, | 200 | 513 | FC); | 201 | 513 | for (comments::Comment::child_iterator I = C->child_begin(), | 202 | 513 | E = C->child_end(); | 203 | 513 | I != E; ++I) | 204 | 513 | Visit(*I, FC); | 205 | 513 | }); | 206 | 513 | } |
|
207 | | |
208 | | void Visit(const ast_type_traits::DynTypedNode &N) { |
209 | | // FIXME: Improve this with a switch or a visitor pattern. |
210 | | if (const auto *D = N.get<Decl>()) |
211 | | Visit(D); |
212 | | else if (const auto *S = N.get<Stmt>()) |
213 | | Visit(S); |
214 | | else if (const auto *QT = N.get<QualType>()) |
215 | | Visit(*QT); |
216 | | else if (const auto *T = N.get<Type>()) |
217 | | Visit(T); |
218 | | else if (const auto *C = N.get<CXXCtorInitializer>()) |
219 | | Visit(C); |
220 | | else if (const auto *C = N.get<OMPClause>()) |
221 | | Visit(C); |
222 | | else if (const auto *T = N.get<TemplateArgument>()) |
223 | | Visit(*T); |
224 | | } |
225 | | |
226 | 2.86k | void dumpDeclContext(const DeclContext *DC) { |
227 | 2.86k | if (!DC) |
228 | 0 | return; |
229 | 2.86k | |
230 | 2.86k | for (const auto *D : (Deserialize ? DC->decls()55 : DC->noload_decls()2.81k )) |
231 | 9.53k | Visit(D); |
232 | 2.86k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpDeclContext(clang::DeclContext const*) Line | Count | Source | 226 | 2.66k | void dumpDeclContext(const DeclContext *DC) { | 227 | 2.66k | if (!DC) | 228 | 0 | return; | 229 | 2.66k | | 230 | 2.66k | for (const auto *D : (Deserialize ? DC->decls()55 : DC->noload_decls()2.60k )) | 231 | 8.99k | Visit(D); | 232 | 2.66k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpDeclContext(clang::DeclContext const*) Line | Count | Source | 226 | 207 | void dumpDeclContext(const DeclContext *DC) { | 227 | 207 | if (!DC) | 228 | 0 | return; | 229 | 207 | | 230 | 207 | for (const auto *D : (Deserialize ? DC->decls()0 : DC->noload_decls())) | 231 | 539 | Visit(D); | 232 | 207 | } |
|
233 | | |
234 | 283 | void dumpTemplateParameters(const TemplateParameterList *TPL) { |
235 | 283 | if (!TPL) |
236 | 0 | return; |
237 | 283 | |
238 | 283 | for (const auto &TP : *TPL) |
239 | 321 | Visit(TP); |
240 | 283 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpTemplateParameters(clang::TemplateParameterList const*) Line | Count | Source | 234 | 250 | void dumpTemplateParameters(const TemplateParameterList *TPL) { | 235 | 250 | if (!TPL) | 236 | 0 | return; | 237 | 250 | | 238 | 250 | for (const auto &TP : *TPL) | 239 | 285 | Visit(TP); | 240 | 250 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpTemplateParameters(clang::TemplateParameterList const*) Line | Count | Source | 234 | 33 | void dumpTemplateParameters(const TemplateParameterList *TPL) { | 235 | 33 | if (!TPL) | 236 | 0 | return; | 237 | 33 | | 238 | 33 | for (const auto &TP : *TPL) | 239 | 36 | Visit(TP); | 240 | 33 | } |
|
241 | | |
242 | | void |
243 | 1 | dumpASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *TALI) { |
244 | 1 | if (!TALI) |
245 | 0 | return; |
246 | 1 | |
247 | 1 | for (const auto &TA : TALI->arguments()) |
248 | 1 | dumpTemplateArgumentLoc(TA); |
249 | 1 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpASTTemplateArgumentListInfo(clang::ASTTemplateArgumentListInfo const*) Line | Count | Source | 243 | 1 | dumpASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *TALI) { | 244 | 1 | if (!TALI) | 245 | 0 | return; | 246 | 1 | | 247 | 1 | for (const auto &TA : TALI->arguments()) | 248 | 1 | dumpTemplateArgumentLoc(TA); | 249 | 1 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpASTTemplateArgumentListInfo(clang::ASTTemplateArgumentListInfo const*) |
250 | | |
251 | | void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A, |
252 | | const Decl *From = nullptr, |
253 | 4 | const char *Label = nullptr) { |
254 | 4 | Visit(A.getArgument(), A.getSourceRange(), From, Label); |
255 | 4 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpTemplateArgumentLoc(clang::TemplateArgumentLoc const&, clang::Decl const*, char const*) Line | Count | Source | 253 | 4 | const char *Label = nullptr) { | 254 | 4 | Visit(A.getArgument(), A.getSourceRange(), From, Label); | 255 | 4 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpTemplateArgumentLoc(clang::TemplateArgumentLoc const&, clang::Decl const*, char const*) |
256 | | |
257 | 134 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { |
258 | 294 | for (unsigned i = 0, e = TAL.size(); i < e; ++i160 ) |
259 | 160 | Visit(TAL[i]); |
260 | 134 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpTemplateArgumentList(clang::TemplateArgumentList const&) Line | Count | Source | 257 | 131 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { | 258 | 286 | for (unsigned i = 0, e = TAL.size(); i < e; ++i155 ) | 259 | 155 | Visit(TAL[i]); | 260 | 131 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpTemplateArgumentList(clang::TemplateArgumentList const&) Line | Count | Source | 257 | 3 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { | 258 | 8 | for (unsigned i = 0, e = TAL.size(); i < e; ++i5 ) | 259 | 5 | Visit(TAL[i]); | 260 | 3 | } |
|
261 | | |
262 | 83 | void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) { |
263 | 83 | if (!typeParams) |
264 | 80 | return; |
265 | 3 | |
266 | 4 | for (const auto &typeParam : *typeParams)3 { |
267 | 4 | Visit(typeParam); |
268 | 4 | } |
269 | 3 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpObjCTypeParamList(clang::ObjCTypeParamList const*) Line | Count | Source | 262 | 78 | void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) { | 263 | 78 | if (!typeParams) | 264 | 76 | return; | 265 | 2 | | 266 | 3 | for (const auto &typeParam : *typeParams)2 { | 267 | 3 | Visit(typeParam); | 268 | 3 | } | 269 | 2 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpObjCTypeParamList(clang::ObjCTypeParamList const*) Line | Count | Source | 262 | 5 | void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) { | 263 | 5 | if (!typeParams) | 264 | 4 | return; | 265 | 1 | | 266 | 1 | for (const auto &typeParam : *typeParams) { | 267 | 1 | Visit(typeParam); | 268 | 1 | } | 269 | 1 | } |
|
270 | | |
271 | 0 | void VisitComplexType(const ComplexType *T) { Visit(T->getElementType()); } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitComplexType(clang::ComplexType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitComplexType(clang::ComplexType const*) |
272 | | void VisitLocInfoType(const LocInfoType *T) { |
273 | | Visit(T->getTypeSourceInfo()->getType()); |
274 | | } |
275 | 207 | void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPointerType(clang::PointerType const*) Line | Count | Source | 275 | 191 | void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPointerType(clang::PointerType const*) Line | Count | Source | 275 | 16 | void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); } |
|
276 | 0 | void VisitBlockPointerType(const BlockPointerType *T) { |
277 | 0 | Visit(T->getPointeeType()); |
278 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBlockPointerType(clang::BlockPointerType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBlockPointerType(clang::BlockPointerType const*) |
279 | 0 | void VisitReferenceType(const ReferenceType *T) { |
280 | 0 | Visit(T->getPointeeType()); |
281 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitReferenceType(clang::ReferenceType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitReferenceType(clang::ReferenceType const*) |
282 | 2 | void VisitMemberPointerType(const MemberPointerType *T) { |
283 | 2 | Visit(T->getClass()); |
284 | 2 | Visit(T->getPointeeType()); |
285 | 2 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitMemberPointerType(clang::MemberPointerType const*) clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitMemberPointerType(clang::MemberPointerType const*) Line | Count | Source | 282 | 2 | void VisitMemberPointerType(const MemberPointerType *T) { | 283 | 2 | Visit(T->getClass()); | 284 | 2 | Visit(T->getPointeeType()); | 285 | 2 | } |
|
286 | 160 | void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitArrayType(clang::ArrayType const*) Line | Count | Source | 286 | 146 | void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitArrayType(clang::ArrayType const*) Line | Count | Source | 286 | 14 | void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); } |
|
287 | 0 | void VisitVariableArrayType(const VariableArrayType *T) { |
288 | 0 | VisitArrayType(T); |
289 | 0 | Visit(T->getSizeExpr()); |
290 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVariableArrayType(clang::VariableArrayType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVariableArrayType(clang::VariableArrayType const*) |
291 | 1 | void VisitDependentSizedArrayType(const DependentSizedArrayType *T) { |
292 | 1 | Visit(T->getElementType()); |
293 | 1 | Visit(T->getSizeExpr()); |
294 | 1 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDependentSizedArrayType(clang::DependentSizedArrayType const*) Line | Count | Source | 291 | 1 | void VisitDependentSizedArrayType(const DependentSizedArrayType *T) { | 292 | 1 | Visit(T->getElementType()); | 293 | 1 | Visit(T->getSizeExpr()); | 294 | 1 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDependentSizedArrayType(clang::DependentSizedArrayType const*) |
295 | 0 | void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) { |
296 | 0 | Visit(T->getElementType()); |
297 | 0 | Visit(T->getSizeExpr()); |
298 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDependentSizedExtVectorType(clang::DependentSizedExtVectorType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDependentSizedExtVectorType(clang::DependentSizedExtVectorType const*) |
299 | 5 | void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVectorType(clang::VectorType const*) Line | Count | Source | 299 | 5 | void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVectorType(clang::VectorType const*) |
300 | 4 | void VisitFunctionType(const FunctionType *T) { Visit(T->getReturnType()); } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionType(clang::FunctionType const*) clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFunctionType(clang::FunctionType const*) Line | Count | Source | 300 | 4 | void VisitFunctionType(const FunctionType *T) { Visit(T->getReturnType()); } |
|
301 | 4 | void VisitFunctionProtoType(const FunctionProtoType *T) { |
302 | 4 | VisitFunctionType(T); |
303 | 4 | for (const QualType &PT : T->getParamTypes()) |
304 | 1 | Visit(PT); |
305 | 4 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionProtoType(clang::FunctionProtoType const*) clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFunctionProtoType(clang::FunctionProtoType const*) Line | Count | Source | 301 | 4 | void VisitFunctionProtoType(const FunctionProtoType *T) { | 302 | 4 | VisitFunctionType(T); | 303 | 4 | for (const QualType &PT : T->getParamTypes()) | 304 | 1 | Visit(PT); | 305 | 4 | } |
|
306 | 18 | void VisitTypeOfExprType(const TypeOfExprType *T) { |
307 | 18 | Visit(T->getUnderlyingExpr()); |
308 | 18 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeOfExprType(clang::TypeOfExprType const*) Line | Count | Source | 306 | 18 | void VisitTypeOfExprType(const TypeOfExprType *T) { | 307 | 18 | Visit(T->getUnderlyingExpr()); | 308 | 18 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeOfExprType(clang::TypeOfExprType const*) |
309 | 3 | void VisitDecltypeType(const DecltypeType *T) { |
310 | 3 | Visit(T->getUnderlyingExpr()); |
311 | 3 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDecltypeType(clang::DecltypeType const*) Line | Count | Source | 309 | 3 | void VisitDecltypeType(const DecltypeType *T) { | 310 | 3 | Visit(T->getUnderlyingExpr()); | 311 | 3 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDecltypeType(clang::DecltypeType const*) |
312 | 0 | void VisitUnaryTransformType(const UnaryTransformType *T) { |
313 | 0 | Visit(T->getBaseType()); |
314 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitUnaryTransformType(clang::UnaryTransformType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitUnaryTransformType(clang::UnaryTransformType const*) |
315 | 1 | void VisitAttributedType(const AttributedType *T) { |
316 | 1 | // FIXME: AttrKind |
317 | 1 | Visit(T->getModifiedType()); |
318 | 1 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitAttributedType(clang::AttributedType const*) clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitAttributedType(clang::AttributedType const*) Line | Count | Source | 315 | 1 | void VisitAttributedType(const AttributedType *T) { | 316 | 1 | // FIXME: AttrKind | 317 | 1 | Visit(T->getModifiedType()); | 318 | 1 | } |
|
319 | 4 | void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { |
320 | 4 | Visit(T->getReplacedParameter()); |
321 | 4 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstTemplateTypeParmType(clang::SubstTemplateTypeParmType const*) Line | Count | Source | 319 | 4 | void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { | 320 | 4 | Visit(T->getReplacedParameter()); | 321 | 4 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstTemplateTypeParmType(clang::SubstTemplateTypeParmType const*) |
322 | | void |
323 | 0 | VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) { |
324 | 0 | Visit(T->getReplacedParameter()); |
325 | 0 | Visit(T->getArgumentPack()); |
326 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstTemplateTypeParmPackType(clang::SubstTemplateTypeParmPackType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstTemplateTypeParmPackType(clang::SubstTemplateTypeParmPackType const*) |
327 | 17 | void VisitTemplateSpecializationType(const TemplateSpecializationType *T) { |
328 | 17 | for (const auto &Arg : *T) |
329 | 20 | Visit(Arg); |
330 | 17 | if (T->isTypeAlias()) |
331 | 0 | Visit(T->getAliasedType()); |
332 | 17 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateSpecializationType(clang::TemplateSpecializationType const*) Line | Count | Source | 327 | 17 | void VisitTemplateSpecializationType(const TemplateSpecializationType *T) { | 328 | 17 | for (const auto &Arg : *T) | 329 | 20 | Visit(Arg); | 330 | 17 | if (T->isTypeAlias()) | 331 | 0 | Visit(T->getAliasedType()); | 332 | 17 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTemplateSpecializationType(clang::TemplateSpecializationType const*) |
333 | 40 | void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { |
334 | 40 | Visit(T->getPointeeType()); |
335 | 40 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCObjectPointerType(clang::ObjCObjectPointerType const*) Line | Count | Source | 333 | 40 | void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { | 334 | 40 | Visit(T->getPointeeType()); | 335 | 40 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCObjectPointerType(clang::ObjCObjectPointerType const*) |
336 | 16 | void VisitAtomicType(const AtomicType *T) { Visit(T->getValueType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitAtomicType(clang::AtomicType const*) Line | Count | Source | 336 | 16 | void VisitAtomicType(const AtomicType *T) { Visit(T->getValueType()); } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitAtomicType(clang::AtomicType const*) |
337 | 3 | void VisitPipeType(const PipeType *T) { Visit(T->getElementType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPipeType(clang::PipeType const*) Line | Count | Source | 337 | 3 | void VisitPipeType(const PipeType *T) { Visit(T->getElementType()); } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPipeType(clang::PipeType const*) |
338 | 0 | void VisitAdjustedType(const AdjustedType *T) { Visit(T->getOriginalType()); } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitAdjustedType(clang::AdjustedType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitAdjustedType(clang::AdjustedType const*) |
339 | 0 | void VisitPackExpansionType(const PackExpansionType *T) { |
340 | 0 | if (!T->isSugared()) |
341 | 0 | Visit(T->getPattern()); |
342 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPackExpansionType(clang::PackExpansionType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPackExpansionType(clang::PackExpansionType const*) |
343 | | // FIXME: ElaboratedType, DependentNameType, |
344 | | // DependentTemplateSpecializationType, ObjCObjectType |
345 | | |
346 | 1.06k | void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypedefDecl(clang::TypedefDecl const*) Line | Count | Source | 346 | 984 | void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypedefDecl(clang::TypedefDecl const*) Line | Count | Source | 346 | 77 | void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); } |
|
347 | | |
348 | 80 | void VisitEnumConstantDecl(const EnumConstantDecl *D) { |
349 | 80 | if (const Expr *Init = D->getInitExpr()) |
350 | 8 | Visit(Init); |
351 | 80 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitEnumConstantDecl(clang::EnumConstantDecl const*) Line | Count | Source | 348 | 63 | void VisitEnumConstantDecl(const EnumConstantDecl *D) { | 349 | 63 | if (const Expr *Init = D->getInitExpr()) | 350 | 7 | Visit(Init); | 351 | 63 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitEnumConstantDecl(clang::EnumConstantDecl const*) Line | Count | Source | 348 | 17 | void VisitEnumConstantDecl(const EnumConstantDecl *D) { | 349 | 17 | if (const Expr *Init = D->getInitExpr()) | 350 | 1 | Visit(Init); | 351 | 17 | } |
|
352 | | |
353 | 2.20k | void VisitFunctionDecl(const FunctionDecl *D) { |
354 | 2.20k | if (const auto *FTSI = D->getTemplateSpecializationInfo()) |
355 | 37 | dumpTemplateArgumentList(*FTSI->TemplateArguments); |
356 | 2.20k | |
357 | 2.20k | if (D->param_begin()) |
358 | 1.08k | for (const auto *Parameter : D->parameters()) |
359 | 1.35k | Visit(Parameter); |
360 | 2.20k | |
361 | 2.20k | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) |
362 | 504 | for (const auto *I : C->inits()) |
363 | 85 | Visit(I); |
364 | 2.20k | |
365 | 2.20k | if (D->doesThisDeclarationHaveABody()) |
366 | 1.09k | Visit(D->getBody()); |
367 | 2.20k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionDecl(clang::FunctionDecl const*) Line | Count | Source | 353 | 1.97k | void VisitFunctionDecl(const FunctionDecl *D) { | 354 | 1.97k | if (const auto *FTSI = D->getTemplateSpecializationInfo()) | 355 | 36 | dumpTemplateArgumentList(*FTSI->TemplateArguments); | 356 | 1.97k | | 357 | 1.97k | if (D->param_begin()) | 358 | 967 | for (const auto *Parameter : D->parameters()) | 359 | 1.21k | Visit(Parameter); | 360 | 1.97k | | 361 | 1.97k | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) | 362 | 487 | for (const auto *I : C->inits()) | 363 | 85 | Visit(I); | 364 | 1.97k | | 365 | 1.97k | if (D->doesThisDeclarationHaveABody()) | 366 | 982 | Visit(D->getBody()); | 367 | 1.97k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFunctionDecl(clang::FunctionDecl const*) Line | Count | Source | 353 | 234 | void VisitFunctionDecl(const FunctionDecl *D) { | 354 | 234 | if (const auto *FTSI = D->getTemplateSpecializationInfo()) | 355 | 1 | dumpTemplateArgumentList(*FTSI->TemplateArguments); | 356 | 234 | | 357 | 234 | if (D->param_begin()) | 358 | 114 | for (const auto *Parameter : D->parameters()) | 359 | 135 | Visit(Parameter); | 360 | 234 | | 361 | 234 | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) | 362 | 17 | for (const auto *I : C->inits()) | 363 | 0 | Visit(I); | 364 | 234 | | 365 | 234 | if (D->doesThisDeclarationHaveABody()) | 366 | 114 | Visit(D->getBody()); | 367 | 234 | } |
|
368 | | |
369 | 1.02k | void VisitFieldDecl(const FieldDecl *D) { |
370 | 1.02k | if (D->isBitField()) |
371 | 58 | Visit(D->getBitWidth()); |
372 | 1.02k | if (Expr *Init = D->getInClassInitializer()) |
373 | 24 | Visit(Init); |
374 | 1.02k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFieldDecl(clang::FieldDecl const*) Line | Count | Source | 369 | 955 | void VisitFieldDecl(const FieldDecl *D) { | 370 | 955 | if (D->isBitField()) | 371 | 51 | Visit(D->getBitWidth()); | 372 | 955 | if (Expr *Init = D->getInClassInitializer()) | 373 | 23 | Visit(Init); | 374 | 955 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFieldDecl(clang::FieldDecl const*) Line | Count | Source | 369 | 74 | void VisitFieldDecl(const FieldDecl *D) { | 370 | 74 | if (D->isBitField()) | 371 | 7 | Visit(D->getBitWidth()); | 372 | 74 | if (Expr *Init = D->getInClassInitializer()) | 373 | 1 | Visit(Init); | 374 | 74 | } |
|
375 | | |
376 | 5.97k | void VisitVarDecl(const VarDecl *D) { |
377 | 5.97k | if (D->hasInit()) |
378 | 1.92k | Visit(D->getInit()); |
379 | 5.97k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVarDecl(clang::VarDecl const*) Line | Count | Source | 376 | 5.75k | void VisitVarDecl(const VarDecl *D) { | 377 | 5.75k | if (D->hasInit()) | 378 | 1.87k | Visit(D->getInit()); | 379 | 5.75k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVarDecl(clang::VarDecl const*) Line | Count | Source | 376 | 221 | void VisitVarDecl(const VarDecl *D) { | 377 | 221 | if (D->hasInit()) | 378 | 48 | Visit(D->getInit()); | 379 | 221 | } |
|
380 | | |
381 | 0 | void VisitDecompositionDecl(const DecompositionDecl *D) { |
382 | 0 | VisitVarDecl(D); |
383 | 0 | for (const auto *B : D->bindings()) |
384 | 0 | Visit(B); |
385 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDecompositionDecl(clang::DecompositionDecl const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDecompositionDecl(clang::DecompositionDecl const*) |
386 | | |
387 | 0 | void VisitBindingDecl(const BindingDecl *D) { |
388 | 0 | if (const auto *E = D->getBinding()) |
389 | 0 | Visit(E); |
390 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBindingDecl(clang::BindingDecl const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBindingDecl(clang::BindingDecl const*) |
391 | | |
392 | 3 | void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) { |
393 | 3 | Visit(D->getAsmString()); |
394 | 3 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFileScopeAsmDecl(clang::FileScopeAsmDecl const*) Line | Count | Source | 392 | 3 | void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) { | 393 | 3 | Visit(D->getAsmString()); | 394 | 3 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFileScopeAsmDecl(clang::FileScopeAsmDecl const*) |
395 | | |
396 | 632 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCapturedDecl(clang::CapturedDecl const*) Line | Count | Source | 396 | 631 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCapturedDecl(clang::CapturedDecl const*) Line | Count | Source | 396 | 1 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } |
|
397 | | |
398 | 2 | void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { |
399 | 2 | for (const auto *E : D->varlists()) |
400 | 4 | Visit(E); |
401 | 2 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPThreadPrivateDecl(clang::OMPThreadPrivateDecl const*) Line | Count | Source | 398 | 2 | void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { | 399 | 2 | for (const auto *E : D->varlists()) | 400 | 4 | Visit(E); | 401 | 2 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPThreadPrivateDecl(clang::OMPThreadPrivateDecl const*) |
402 | | |
403 | 6 | void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) { |
404 | 6 | Visit(D->getCombiner()); |
405 | 6 | if (const auto *Initializer = D->getInitializer()) |
406 | 2 | Visit(Initializer); |
407 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPDeclareReductionDecl(clang::OMPDeclareReductionDecl const*) Line | Count | Source | 403 | 6 | void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) { | 404 | 6 | Visit(D->getCombiner()); | 405 | 6 | if (const auto *Initializer = D->getInitializer()) | 406 | 2 | Visit(Initializer); | 407 | 6 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPDeclareReductionDecl(clang::OMPDeclareReductionDecl const*) |
408 | | |
409 | 0 | void VisitOMPDeclareMapperDecl(const OMPDeclareMapperDecl *D) { |
410 | 0 | for (const auto *C : D->clauselists()) |
411 | 0 | Visit(C); |
412 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPDeclareMapperDecl(clang::OMPDeclareMapperDecl const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPDeclareMapperDecl(clang::OMPDeclareMapperDecl const*) |
413 | | |
414 | 96 | void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) { |
415 | 96 | Visit(D->getInit()); |
416 | 96 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPCapturedExprDecl(clang::OMPCapturedExprDecl const*) Line | Count | Source | 414 | 96 | void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) { | 415 | 96 | Visit(D->getInit()); | 416 | 96 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPCapturedExprDecl(clang::OMPCapturedExprDecl const*) |
417 | | |
418 | 0 | void VisitOMPAllocateDecl(const OMPAllocateDecl *D) { |
419 | 0 | for (const auto *E : D->varlists()) |
420 | 0 | Visit(E); |
421 | 0 | for (const auto *C : D->clauselists()) |
422 | 0 | Visit(C); |
423 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPAllocateDecl(clang::OMPAllocateDecl const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPAllocateDecl(clang::OMPAllocateDecl const*) |
424 | | |
425 | | template <typename SpecializationDecl> |
426 | | void dumpTemplateDeclSpecialization(const SpecializationDecl *D) { |
427 | | for (const auto *RedeclWithBadType : D->redecls()) { |
428 | | // FIXME: The redecls() range sometimes has elements of a less-specific |
429 | | // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives |
430 | | // us TagDecls, and should give CXXRecordDecls). |
431 | | auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType); |
432 | | if (!Redecl) { |
433 | | // Found the injected-class-name for a class template. This will be |
434 | | // dumped as part of its surrounding class so we don't need to dump it |
435 | | // here. |
436 | | assert(isa<CXXRecordDecl>(RedeclWithBadType) && |
437 | | "expected an injected-class-name"); |
438 | | continue; |
439 | | } |
440 | | Visit(Redecl); |
441 | | } |
442 | | } |
443 | | |
444 | | template <typename TemplateDecl> |
445 | | void dumpTemplateDecl(const TemplateDecl *D) { |
446 | | dumpTemplateParameters(D->getTemplateParameters()); |
447 | | |
448 | | Visit(D->getTemplatedDecl()); |
449 | | |
450 | | for (const auto *Child : D->specializations()) |
451 | | dumpTemplateDeclSpecialization(Child); |
452 | | } |
453 | | |
454 | 34 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { |
455 | 34 | Visit(D->getUnderlyingType()); |
456 | 34 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeAliasDecl(clang::TypeAliasDecl const*) Line | Count | Source | 454 | 30 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { | 455 | 30 | Visit(D->getUnderlyingType()); | 456 | 30 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeAliasDecl(clang::TypeAliasDecl const*) Line | Count | Source | 454 | 4 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { | 455 | 4 | Visit(D->getUnderlyingType()); | 456 | 4 | } |
|
457 | | |
458 | 1 | void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) { |
459 | 1 | dumpTemplateParameters(D->getTemplateParameters()); |
460 | 1 | Visit(D->getTemplatedDecl()); |
461 | 1 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl const*) Line | Count | Source | 458 | 1 | void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) { | 459 | 1 | dumpTemplateParameters(D->getTemplateParameters()); | 460 | 1 | Visit(D->getTemplatedDecl()); | 461 | 1 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl const*) |
462 | | |
463 | 21 | void VisitStaticAssertDecl(const StaticAssertDecl *D) { |
464 | 21 | Visit(D->getAssertExpr()); |
465 | 21 | Visit(D->getMessage()); |
466 | 21 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitStaticAssertDecl(clang::StaticAssertDecl const*) Line | Count | Source | 463 | 21 | void VisitStaticAssertDecl(const StaticAssertDecl *D) { | 464 | 21 | Visit(D->getAssertExpr()); | 465 | 21 | Visit(D->getMessage()); | 466 | 21 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitStaticAssertDecl(clang::StaticAssertDecl const*) |
467 | | |
468 | | void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) { |
469 | | dumpTemplateDecl(D); |
470 | | } |
471 | | |
472 | | void VisitClassTemplateDecl(const ClassTemplateDecl *D) { |
473 | | dumpTemplateDecl(D); |
474 | | } |
475 | | |
476 | | void VisitClassTemplateSpecializationDecl( |
477 | 93 | const ClassTemplateSpecializationDecl *D) { |
478 | 93 | dumpTemplateArgumentList(D->getTemplateArgs()); |
479 | 93 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassTemplateSpecializationDecl(clang::ClassTemplateSpecializationDecl const*) Line | Count | Source | 477 | 91 | const ClassTemplateSpecializationDecl *D) { | 478 | 91 | dumpTemplateArgumentList(D->getTemplateArgs()); | 479 | 91 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassTemplateSpecializationDecl(clang::ClassTemplateSpecializationDecl const*) Line | Count | Source | 477 | 2 | const ClassTemplateSpecializationDecl *D) { | 478 | 2 | dumpTemplateArgumentList(D->getTemplateArgs()); | 479 | 2 | } |
|
480 | | |
481 | | void VisitClassTemplatePartialSpecializationDecl( |
482 | 16 | const ClassTemplatePartialSpecializationDecl *D) { |
483 | 16 | VisitClassTemplateSpecializationDecl(D); |
484 | 16 | dumpTemplateParameters(D->getTemplateParameters()); |
485 | 16 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplatePartialSpecializationDecl const*) Line | Count | Source | 482 | 15 | const ClassTemplatePartialSpecializationDecl *D) { | 483 | 15 | VisitClassTemplateSpecializationDecl(D); | 484 | 15 | dumpTemplateParameters(D->getTemplateParameters()); | 485 | 15 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplatePartialSpecializationDecl const*) Line | Count | Source | 482 | 1 | const ClassTemplatePartialSpecializationDecl *D) { | 483 | 1 | VisitClassTemplateSpecializationDecl(D); | 484 | 1 | dumpTemplateParameters(D->getTemplateParameters()); | 485 | 1 | } |
|
486 | | |
487 | | void VisitClassScopeFunctionSpecializationDecl( |
488 | 1 | const ClassScopeFunctionSpecializationDecl *D) { |
489 | 1 | Visit(D->getSpecialization()); |
490 | 1 | dumpASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten()); |
491 | 1 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassScopeFunctionSpecializationDecl(clang::ClassScopeFunctionSpecializationDecl const*) Line | Count | Source | 488 | 1 | const ClassScopeFunctionSpecializationDecl *D) { | 489 | 1 | Visit(D->getSpecialization()); | 490 | 1 | dumpASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten()); | 491 | 1 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassScopeFunctionSpecializationDecl(clang::ClassScopeFunctionSpecializationDecl const*) |
492 | | void VisitVarTemplateDecl(const VarTemplateDecl *D) { dumpTemplateDecl(D); } |
493 | | |
494 | 0 | void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) { |
495 | 0 | dumpTemplateParameters(D->getTemplateParameters()); |
496 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBuiltinTemplateDecl(clang::BuiltinTemplateDecl const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBuiltinTemplateDecl(clang::BuiltinTemplateDecl const*) |
497 | | |
498 | | void |
499 | 4 | VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) { |
500 | 4 | dumpTemplateArgumentList(D->getTemplateArgs()); |
501 | 4 | VisitVarDecl(D); |
502 | 4 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVarTemplateSpecializationDecl(clang::VarTemplateSpecializationDecl const*) Line | Count | Source | 499 | 4 | VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) { | 500 | 4 | dumpTemplateArgumentList(D->getTemplateArgs()); | 501 | 4 | VisitVarDecl(D); | 502 | 4 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVarTemplateSpecializationDecl(clang::VarTemplateSpecializationDecl const*) |
503 | | |
504 | | void VisitVarTemplatePartialSpecializationDecl( |
505 | 0 | const VarTemplatePartialSpecializationDecl *D) { |
506 | 0 | dumpTemplateParameters(D->getTemplateParameters()); |
507 | 0 | VisitVarTemplateSpecializationDecl(D); |
508 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVarTemplatePartialSpecializationDecl(clang::VarTemplatePartialSpecializationDecl const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVarTemplatePartialSpecializationDecl(clang::VarTemplatePartialSpecializationDecl const*) |
509 | | |
510 | 257 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { |
511 | 257 | if (D->hasDefaultArgument()) |
512 | 8 | Visit(D->getDefaultArgument(), SourceRange(), |
513 | 8 | D->getDefaultArgStorage().getInheritedFrom(), |
514 | 8 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"7 ); |
515 | 257 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateTypeParmDecl(clang::TemplateTypeParmDecl const*) Line | Count | Source | 510 | 225 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { | 511 | 225 | if (D->hasDefaultArgument()) | 512 | 6 | Visit(D->getDefaultArgument(), SourceRange(), | 513 | 6 | D->getDefaultArgStorage().getInheritedFrom(), | 514 | 6 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"5 ); | 515 | 225 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTemplateTypeParmDecl(clang::TemplateTypeParmDecl const*) Line | Count | Source | 510 | 32 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { | 511 | 32 | if (D->hasDefaultArgument()) | 512 | 2 | Visit(D->getDefaultArgument(), SourceRange(), | 513 | 2 | D->getDefaultArgStorage().getInheritedFrom(), | 514 | 2 | D->defaultArgumentWasInherited() ? "inherited from"0 : "previous"); | 515 | 32 | } |
|
516 | | |
517 | 52 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { |
518 | 52 | if (D->hasDefaultArgument()) |
519 | 5 | Visit(D->getDefaultArgument(), SourceRange(), |
520 | 5 | D->getDefaultArgStorage().getInheritedFrom(), |
521 | 5 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"4 ); |
522 | 52 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitNonTypeTemplateParmDecl(clang::NonTypeTemplateParmDecl const*) Line | Count | Source | 517 | 49 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { | 518 | 49 | if (D->hasDefaultArgument()) | 519 | 5 | Visit(D->getDefaultArgument(), SourceRange(), | 520 | 5 | D->getDefaultArgStorage().getInheritedFrom(), | 521 | 5 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"4 ); | 522 | 49 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitNonTypeTemplateParmDecl(clang::NonTypeTemplateParmDecl const*) Line | Count | Source | 517 | 3 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { | 518 | 3 | if (D->hasDefaultArgument()) | 519 | 0 | Visit(D->getDefaultArgument(), SourceRange(), | 520 | 0 | D->getDefaultArgStorage().getInheritedFrom(), | 521 | 0 | D->defaultArgumentWasInherited() ? "inherited from" : "previous"); | 522 | 3 | } |
|
523 | | |
524 | 12 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { |
525 | 12 | dumpTemplateParameters(D->getTemplateParameters()); |
526 | 12 | if (D->hasDefaultArgument()) |
527 | 3 | dumpTemplateArgumentLoc( |
528 | 3 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), |
529 | 3 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"2 ); |
530 | 12 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl const*) Line | Count | Source | 524 | 11 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { | 525 | 11 | dumpTemplateParameters(D->getTemplateParameters()); | 526 | 11 | if (D->hasDefaultArgument()) | 527 | 3 | dumpTemplateArgumentLoc( | 528 | 3 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), | 529 | 3 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"2 ); | 530 | 11 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl const*) Line | Count | Source | 524 | 1 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { | 525 | 1 | dumpTemplateParameters(D->getTemplateParameters()); | 526 | 1 | if (D->hasDefaultArgument()) | 527 | 0 | dumpTemplateArgumentLoc( | 528 | 0 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), | 529 | 0 | D->defaultArgumentWasInherited() ? "inherited from" : "previous"); | 530 | 1 | } |
|
531 | | |
532 | 0 | void VisitConceptDecl(const ConceptDecl *D) { |
533 | 0 | dumpTemplateParameters(D->getTemplateParameters()); |
534 | 0 | Visit(D->getConstraintExpr()); |
535 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitConceptDecl(clang::ConceptDecl const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitConceptDecl(clang::ConceptDecl const*) |
536 | | |
537 | 26 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { |
538 | 26 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) |
539 | 0 | Visit(TD->getTypeForDecl()); |
540 | 26 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitUsingShadowDecl(clang::UsingShadowDecl const*) Line | Count | Source | 537 | 24 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { | 538 | 24 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) | 539 | 0 | Visit(TD->getTypeForDecl()); | 540 | 24 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitUsingShadowDecl(clang::UsingShadowDecl const*) Line | Count | Source | 537 | 2 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { | 538 | 2 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) | 539 | 0 | Visit(TD->getTypeForDecl()); | 540 | 2 | } |
|
541 | | |
542 | 10 | void VisitFriendDecl(const FriendDecl *D) { |
543 | 10 | if (!D->getFriendType()) |
544 | 6 | Visit(D->getFriendDecl()); |
545 | 10 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFriendDecl(clang::FriendDecl const*) Line | Count | Source | 542 | 10 | void VisitFriendDecl(const FriendDecl *D) { | 543 | 10 | if (!D->getFriendType()) | 544 | 6 | Visit(D->getFriendDecl()); | 545 | 10 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFriendDecl(clang::FriendDecl const*) |
546 | | |
547 | 108 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { |
548 | 108 | if (D->isThisDeclarationADefinition()) |
549 | 30 | dumpDeclContext(D); |
550 | 78 | else |
551 | 78 | for (const ParmVarDecl *Parameter : D->parameters()) |
552 | 25 | Visit(Parameter); |
553 | 108 | |
554 | 108 | if (D->hasBody()) |
555 | 30 | Visit(D->getBody()); |
556 | 108 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCMethodDecl(clang::ObjCMethodDecl const*) Line | Count | Source | 547 | 97 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { | 548 | 97 | if (D->isThisDeclarationADefinition()) | 549 | 27 | dumpDeclContext(D); | 550 | 70 | else | 551 | 70 | for (const ParmVarDecl *Parameter : D->parameters()) | 552 | 22 | Visit(Parameter); | 553 | 97 | | 554 | 97 | if (D->hasBody()) | 555 | 27 | Visit(D->getBody()); | 556 | 97 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCMethodDecl(clang::ObjCMethodDecl const*) Line | Count | Source | 547 | 11 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { | 548 | 11 | if (D->isThisDeclarationADefinition()) | 549 | 3 | dumpDeclContext(D); | 550 | 8 | else | 551 | 8 | for (const ParmVarDecl *Parameter : D->parameters()) | 552 | 3 | Visit(Parameter); | 553 | 11 | | 554 | 11 | if (D->hasBody()) | 555 | 3 | Visit(D->getBody()); | 556 | 11 | } |
|
557 | | |
558 | 17 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { |
559 | 17 | dumpObjCTypeParamList(D->getTypeParamList()); |
560 | 17 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCCategoryDecl(clang::ObjCCategoryDecl const*) Line | Count | Source | 558 | 16 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { | 559 | 16 | dumpObjCTypeParamList(D->getTypeParamList()); | 560 | 16 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCCategoryDecl(clang::ObjCCategoryDecl const*) Line | Count | Source | 558 | 1 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { | 559 | 1 | dumpObjCTypeParamList(D->getTypeParamList()); | 560 | 1 | } |
|
561 | | |
562 | 66 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { |
563 | 66 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); |
564 | 66 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCInterfaceDecl(clang::ObjCInterfaceDecl const*) Line | Count | Source | 562 | 62 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { | 563 | 62 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); | 564 | 62 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCInterfaceDecl(clang::ObjCInterfaceDecl const*) Line | Count | Source | 562 | 4 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { | 563 | 4 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); | 564 | 4 | } |
|
565 | | |
566 | 18 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { |
567 | 18 | for (const auto &I : D->inits()) |
568 | 1 | Visit(I); |
569 | 18 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCImplementationDecl(clang::ObjCImplementationDecl const*) Line | Count | Source | 566 | 15 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { | 567 | 15 | for (const auto &I : D->inits()) | 568 | 1 | Visit(I); | 569 | 15 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCImplementationDecl(clang::ObjCImplementationDecl const*) Line | Count | Source | 566 | 3 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { | 567 | 3 | for (const auto &I : D->inits()) | 568 | 0 | Visit(I); | 569 | 3 | } |
|
570 | | |
571 | 18 | void VisitBlockDecl(const BlockDecl *D) { |
572 | 18 | for (const auto &I : D->parameters()) |
573 | 2 | Visit(I); |
574 | 18 | |
575 | 18 | for (const auto &I : D->captures()) |
576 | 8 | Visit(I); |
577 | 18 | Visit(D->getBody()); |
578 | 18 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBlockDecl(clang::BlockDecl const*) Line | Count | Source | 571 | 15 | void VisitBlockDecl(const BlockDecl *D) { | 572 | 15 | for (const auto &I : D->parameters()) | 573 | 1 | Visit(I); | 574 | 15 | | 575 | 15 | for (const auto &I : D->captures()) | 576 | 5 | Visit(I); | 577 | 15 | Visit(D->getBody()); | 578 | 15 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBlockDecl(clang::BlockDecl const*) Line | Count | Source | 571 | 3 | void VisitBlockDecl(const BlockDecl *D) { | 572 | 3 | for (const auto &I : D->parameters()) | 573 | 1 | Visit(I); | 574 | 3 | | 575 | 3 | for (const auto &I : D->captures()) | 576 | 3 | Visit(I); | 577 | 3 | Visit(D->getBody()); | 578 | 3 | } |
|
579 | | |
580 | 1.21k | void VisitDeclStmt(const DeclStmt *Node) { |
581 | 1.21k | for (const auto &D : Node->decls()) |
582 | 1.24k | Visit(D); |
583 | 1.21k | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDeclStmt(clang::DeclStmt const*) Line | Count | Source | 580 | 52 | void VisitDeclStmt(const DeclStmt *Node) { | 581 | 52 | for (const auto &D : Node->decls()) | 582 | 54 | Visit(D); | 583 | 52 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDeclStmt(clang::DeclStmt const*) Line | Count | Source | 580 | 1.15k | void VisitDeclStmt(const DeclStmt *Node) { | 581 | 1.15k | for (const auto &D : Node->decls()) | 582 | 1.19k | Visit(D); | 583 | 1.15k | } |
|
584 | | |
585 | 4 | void VisitAttributedStmt(const AttributedStmt *Node) { |
586 | 4 | for (const auto *A : Node->getAttrs()) |
587 | 4 | Visit(A); |
588 | 4 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitAttributedStmt(clang::AttributedStmt const*) clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitAttributedStmt(clang::AttributedStmt const*) Line | Count | Source | 585 | 4 | void VisitAttributedStmt(const AttributedStmt *Node) { | 586 | 4 | for (const auto *A : Node->getAttrs()) | 587 | 4 | Visit(A); | 588 | 4 | } |
|
589 | | |
590 | 10 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { |
591 | 10 | Visit(Node->getExceptionDecl()); |
592 | 10 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCXXCatchStmt(clang::CXXCatchStmt const*) Line | Count | Source | 590 | 2 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { | 591 | 2 | Visit(Node->getExceptionDecl()); | 592 | 2 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCXXCatchStmt(clang::CXXCatchStmt const*) Line | Count | Source | 590 | 8 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { | 591 | 8 | Visit(Node->getExceptionDecl()); | 592 | 8 | } |
|
593 | | |
594 | 386 | void VisitCapturedStmt(const CapturedStmt *Node) { |
595 | 386 | Visit(Node->getCapturedDecl()); |
596 | 386 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCapturedStmt(clang::CapturedStmt const*) Line | Count | Source | 594 | 1 | void VisitCapturedStmt(const CapturedStmt *Node) { | 595 | 1 | Visit(Node->getCapturedDecl()); | 596 | 1 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCapturedStmt(clang::CapturedStmt const*) Line | Count | Source | 594 | 385 | void VisitCapturedStmt(const CapturedStmt *Node) { | 595 | 385 | Visit(Node->getCapturedDecl()); | 596 | 385 | } |
|
597 | | |
598 | 187 | void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) { |
599 | 187 | for (const auto *C : Node->clauses()) |
600 | 158 | Visit(C); |
601 | 187 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPExecutableDirective(clang::OMPExecutableDirective const*) clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPExecutableDirective(clang::OMPExecutableDirective const*) Line | Count | Source | 598 | 187 | void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) { | 599 | 187 | for (const auto *C : Node->clauses()) | 600 | 158 | Visit(C); | 601 | 187 | } |
|
602 | | |
603 | 105 | void VisitInitListExpr(const InitListExpr *ILE) { |
604 | 105 | if (auto *Filler = ILE->getArrayFiller()) { |
605 | 10 | Visit(Filler, "array_filler"); |
606 | 10 | } |
607 | 105 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitInitListExpr(clang::InitListExpr const*) Line | Count | Source | 603 | 9 | void VisitInitListExpr(const InitListExpr *ILE) { | 604 | 9 | if (auto *Filler = ILE->getArrayFiller()) { | 605 | 1 | Visit(Filler, "array_filler"); | 606 | 1 | } | 607 | 9 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitInitListExpr(clang::InitListExpr const*) Line | Count | Source | 603 | 96 | void VisitInitListExpr(const InitListExpr *ILE) { | 604 | 96 | if (auto *Filler = ILE->getArrayFiller()) { | 605 | 9 | Visit(Filler, "array_filler"); | 606 | 9 | } | 607 | 96 | } |
|
608 | | |
609 | 18 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBlockExpr(clang::BlockExpr const*) Line | Count | Source | 609 | 3 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBlockExpr(clang::BlockExpr const*) Line | Count | Source | 609 | 15 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } |
|
610 | | |
611 | 88 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { |
612 | 88 | if (Expr *Source = Node->getSourceExpr()) |
613 | 87 | Visit(Source); |
614 | 88 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOpaqueValueExpr(clang::OpaqueValueExpr const*) Line | Count | Source | 611 | 52 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { | 612 | 52 | if (Expr *Source = Node->getSourceExpr()) | 613 | 52 | Visit(Source); | 614 | 52 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOpaqueValueExpr(clang::OpaqueValueExpr const*) Line | Count | Source | 611 | 36 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { | 612 | 36 | if (Expr *Source = Node->getSourceExpr()) | 613 | 35 | Visit(Source); | 614 | 36 | } |
|
615 | | |
616 | 12 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { |
617 | 12 | Visit(E->getControllingExpr()); |
618 | 12 | Visit(E->getControllingExpr()->getType()); // FIXME: remove |
619 | 12 | |
620 | 21 | for (const auto &Assoc : E->associations()) { |
621 | 21 | Visit(Assoc); |
622 | 21 | } |
623 | 12 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitGenericSelectionExpr(clang::GenericSelectionExpr const*) Line | Count | Source | 616 | 7 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { | 617 | 7 | Visit(E->getControllingExpr()); | 618 | 7 | Visit(E->getControllingExpr()->getType()); // FIXME: remove | 619 | 7 | | 620 | 12 | for (const auto &Assoc : E->associations()) { | 621 | 12 | Visit(Assoc); | 622 | 12 | } | 623 | 7 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitGenericSelectionExpr(clang::GenericSelectionExpr const*) Line | Count | Source | 616 | 5 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { | 617 | 5 | Visit(E->getControllingExpr()); | 618 | 5 | Visit(E->getControllingExpr()->getType()); // FIXME: remove | 619 | 5 | | 620 | 9 | for (const auto &Assoc : E->associations()) { | 621 | 9 | Visit(Assoc); | 622 | 9 | } | 623 | 5 | } |
|
624 | | |
625 | 45 | void VisitLambdaExpr(const LambdaExpr *Node) { |
626 | 45 | Visit(Node->getLambdaClass()); |
627 | 45 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitLambdaExpr(clang::LambdaExpr const*) Line | Count | Source | 625 | 17 | void VisitLambdaExpr(const LambdaExpr *Node) { | 626 | 17 | Visit(Node->getLambdaClass()); | 627 | 17 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitLambdaExpr(clang::LambdaExpr const*) Line | Count | Source | 625 | 28 | void VisitLambdaExpr(const LambdaExpr *Node) { | 626 | 28 | Visit(Node->getLambdaClass()); | 627 | 28 | } |
|
628 | | |
629 | 6 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { |
630 | 6 | if (Node->isPartiallySubstituted()) |
631 | 0 | for (const auto &A : Node->getPartialArguments()) |
632 | 0 | Visit(A); |
633 | 6 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSizeOfPackExpr(clang::SizeOfPackExpr const*) Line | Count | Source | 629 | 1 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { | 630 | 1 | if (Node->isPartiallySubstituted()) | 631 | 0 | for (const auto &A : Node->getPartialArguments()) | 632 | 0 | Visit(A); | 633 | 1 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSizeOfPackExpr(clang::SizeOfPackExpr const*) Line | Count | Source | 629 | 5 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { | 630 | 5 | if (Node->isPartiallySubstituted()) | 631 | 0 | for (const auto &A : Node->getPartialArguments()) | 632 | 0 | Visit(A); | 633 | 5 | } |
|
634 | | |
635 | 9 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { |
636 | 9 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) |
637 | 7 | Visit(CatchParam); |
638 | 9 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCAtCatchStmt(clang::ObjCAtCatchStmt const*) Line | Count | Source | 635 | 2 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { | 636 | 2 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) | 637 | 1 | Visit(CatchParam); | 638 | 2 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCAtCatchStmt(clang::ObjCAtCatchStmt const*) Line | Count | Source | 635 | 7 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { | 636 | 7 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) | 637 | 6 | Visit(CatchParam); | 638 | 7 | } |
|
639 | | |
640 | 11 | void VisitExpressionTemplateArgument(const TemplateArgument &TA) { |
641 | 11 | Visit(TA.getAsExpr()); |
642 | 11 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitExpressionTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 640 | 11 | void VisitExpressionTemplateArgument(const TemplateArgument &TA) { | 641 | 11 | Visit(TA.getAsExpr()); | 642 | 11 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitExpressionTemplateArgument(clang::TemplateArgument const&) |
643 | 8 | void VisitPackTemplateArgument(const TemplateArgument &TA) { |
644 | 8 | for (const auto &TArg : TA.pack_elements()) |
645 | 16 | Visit(TArg); |
646 | 8 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPackTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 643 | 8 | void VisitPackTemplateArgument(const TemplateArgument &TA) { | 644 | 8 | for (const auto &TArg : TA.pack_elements()) | 645 | 16 | Visit(TArg); | 646 | 8 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPackTemplateArgument(clang::TemplateArgument const&) |
647 | | |
648 | | // Implements Visit methods for Attrs. |
649 | | #include "clang/AST/AttrNodeTraverse.inc" |
650 | | }; |
651 | | |
652 | | } // namespace clang |
653 | | |
654 | | #endif // LLVM_CLANG_AST_ASTNODETRAVERSER_H |