/Users/buildslave/jenkins/workspace/coverage/llvm-project/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/ASTTypeTraits.h" |
19 | | #include "clang/AST/AttrVisitor.h" |
20 | | #include "clang/AST/CommentVisitor.h" |
21 | | #include "clang/AST/DeclVisitor.h" |
22 | | #include "clang/AST/LocInfoType.h" |
23 | | #include "clang/AST/StmtVisitor.h" |
24 | | #include "clang/AST/TemplateArgumentVisitor.h" |
25 | | #include "clang/AST/Type.h" |
26 | | #include "clang/AST/TypeVisitor.h" |
27 | | |
28 | | namespace clang { |
29 | | |
30 | | class APValue; |
31 | | |
32 | | /** |
33 | | |
34 | | ASTNodeTraverser traverses the Clang AST for dumping purposes. |
35 | | |
36 | | The `Derived::doGetNodeDelegate()` method is required to be an accessible member |
37 | | which returns a reference of type `NodeDelegateType &` which implements the |
38 | | following interface: |
39 | | |
40 | | struct { |
41 | | template <typename Fn> void AddChild(Fn DoAddChild); |
42 | | template <typename Fn> void AddChild(StringRef Label, Fn DoAddChild); |
43 | | |
44 | | void Visit(const comments::Comment *C, const comments::FullComment *FC); |
45 | | void Visit(const Attr *A); |
46 | | void Visit(const TemplateArgument &TA, SourceRange R = {}, |
47 | | const Decl *From = nullptr, StringRef Label = {}); |
48 | | void Visit(const Stmt *Node); |
49 | | void Visit(const Type *T); |
50 | | void Visit(QualType T); |
51 | | void Visit(const Decl *D); |
52 | | void Visit(const CXXCtorInitializer *Init); |
53 | | void Visit(const OMPClause *C); |
54 | | void Visit(const BlockDecl::Capture &C); |
55 | | void Visit(const GenericSelectionExpr::ConstAssociation &A); |
56 | | void Visit(const concepts::Requirement *R); |
57 | | void Visit(const APValue &Value, QualType Ty); |
58 | | }; |
59 | | */ |
60 | | template <typename Derived, typename NodeDelegateType> |
61 | | class ASTNodeTraverser |
62 | | : public ConstDeclVisitor<Derived>, |
63 | | public ConstStmtVisitor<Derived>, |
64 | | public comments::ConstCommentVisitor<Derived, void, |
65 | | const comments::FullComment *>, |
66 | | public TypeVisitor<Derived>, |
67 | | public ConstAttrVisitor<Derived>, |
68 | | public ConstTemplateArgumentVisitor<Derived> { |
69 | | |
70 | | /// Indicates whether we should trigger deserialization of nodes that had |
71 | | /// not already been loaded. |
72 | | bool Deserialize = false; |
73 | | |
74 | | TraversalKind Traversal = TraversalKind::TK_AsIs; |
75 | | |
76 | 156k | NodeDelegateType &getNodeDelegate() { |
77 | 156k | return getDerived().doGetNodeDelegate(); |
78 | 156k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::getNodeDelegate() Line | Count | Source | 76 | 145k | NodeDelegateType &getNodeDelegate() { | 77 | 145k | return getDerived().doGetNodeDelegate(); | 78 | 145k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::getNodeDelegate() Line | Count | Source | 76 | 11.1k | NodeDelegateType &getNodeDelegate() { | 77 | 11.1k | return getDerived().doGetNodeDelegate(); | 78 | 11.1k | } |
|
79 | 156k | Derived &getDerived() { return *static_cast<Derived *>(this); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::getDerived() Line | Count | Source | 79 | 145k | Derived &getDerived() { return *static_cast<Derived *>(this); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::getDerived() Line | Count | Source | 79 | 11.1k | Derived &getDerived() { return *static_cast<Derived *>(this); } |
|
80 | | |
81 | | public: |
82 | 1.68k | void setDeserialize(bool D) { Deserialize = D; } |
83 | 7 | bool getDeserialize() const { return Deserialize; } |
84 | | |
85 | | void SetTraversalKind(TraversalKind TK) { Traversal = TK; } |
86 | 577 | TraversalKind GetTraversalKind() const { return Traversal; } |
87 | | |
88 | 28.9k | void Visit(const Decl *D) { |
89 | 28.9k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isImplicit()0 ) |
90 | 0 | return; |
91 | | |
92 | 28.9k | getNodeDelegate().AddChild([=] { |
93 | 28.9k | getNodeDelegate().Visit(D); |
94 | 28.9k | if (!D) |
95 | 4 | return; |
96 | | |
97 | 28.9k | ConstDeclVisitor<Derived>::Visit(D); |
98 | | |
99 | 28.9k | for (const auto &A : D->attrs()) |
100 | 2.45k | Visit(A); |
101 | | |
102 | 28.9k | if (const comments::FullComment *Comment = |
103 | 28.9k | D->getASTContext().getLocalCommentForDeclUncached(D)) |
104 | 57 | Visit(Comment, Comment); |
105 | | |
106 | | // Decls within functions are visited by the body. |
107 | 28.9k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)23.5k ) { |
108 | 23.3k | if (Traversal != TK_AsIs) { |
109 | 0 | if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) { |
110 | 0 | auto SK = CTSD->getSpecializationKind(); |
111 | 0 | if (SK == TSK_ExplicitInstantiationDeclaration || |
112 | 0 | SK == TSK_ExplicitInstantiationDefinition) |
113 | 0 | return; |
114 | 0 | } |
115 | 0 | } |
116 | 23.3k | if (const auto *DC = dyn_cast<DeclContext>(D)) |
117 | 5.44k | dumpDeclContext(DC); |
118 | 23.3k | } |
119 | 28.9k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Decl const*)::'lambda'()::operator()() const Line | Count | Source | 92 | 26.9k | getNodeDelegate().AddChild([=] { | 93 | 26.9k | getNodeDelegate().Visit(D); | 94 | 26.9k | if (!D) | 95 | 3 | return; | 96 | | | 97 | 26.9k | ConstDeclVisitor<Derived>::Visit(D); | 98 | | | 99 | 26.9k | for (const auto &A : D->attrs()) | 100 | 2.42k | Visit(A); | 101 | | | 102 | 26.9k | if (const comments::FullComment *Comment = | 103 | 26.9k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 104 | 45 | Visit(Comment, Comment); | 105 | | | 106 | | // Decls within functions are visited by the body. | 107 | 26.9k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)21.9k ) { | 108 | 21.7k | if (Traversal != TK_AsIs) { | 109 | 0 | if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) { | 110 | 0 | auto SK = CTSD->getSpecializationKind(); | 111 | 0 | if (SK == TSK_ExplicitInstantiationDeclaration || | 112 | 0 | SK == TSK_ExplicitInstantiationDefinition) | 113 | 0 | return; | 114 | 0 | } | 115 | 0 | } | 116 | 21.7k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 117 | 5.05k | dumpDeclContext(DC); | 118 | 21.7k | } | 119 | 26.9k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Decl const*)::'lambda'()::operator()() const Line | Count | Source | 92 | 2.05k | getNodeDelegate().AddChild([=] { | 93 | 2.05k | getNodeDelegate().Visit(D); | 94 | 2.05k | if (!D) | 95 | 1 | return; | 96 | | | 97 | 2.05k | ConstDeclVisitor<Derived>::Visit(D); | 98 | | | 99 | 2.05k | for (const auto &A : D->attrs()) | 100 | 35 | Visit(A); | 101 | | | 102 | 2.05k | if (const comments::FullComment *Comment = | 103 | 2.05k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 104 | 12 | Visit(Comment, Comment); | 105 | | | 106 | | // Decls within functions are visited by the body. | 107 | 2.05k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)1.55k ) { | 108 | 1.54k | if (Traversal != TK_AsIs) { | 109 | 0 | if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) { | 110 | 0 | auto SK = CTSD->getSpecializationKind(); | 111 | 0 | if (SK == TSK_ExplicitInstantiationDeclaration || | 112 | 0 | SK == TSK_ExplicitInstantiationDefinition) | 113 | 0 | return; | 114 | 0 | } | 115 | 0 | } | 116 | 1.54k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 117 | 388 | dumpDeclContext(DC); | 118 | 1.54k | } | 119 | 2.05k | }); |
|
120 | 28.9k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Decl const*) Line | Count | Source | 88 | 26.9k | void Visit(const Decl *D) { | 89 | 26.9k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isImplicit()0 ) | 90 | 0 | return; | 91 | | | 92 | 26.9k | getNodeDelegate().AddChild([=] { | 93 | 26.9k | getNodeDelegate().Visit(D); | 94 | 26.9k | if (!D) | 95 | 26.9k | return; | 96 | | | 97 | 26.9k | ConstDeclVisitor<Derived>::Visit(D); | 98 | | | 99 | 26.9k | for (const auto &A : D->attrs()) | 100 | 26.9k | Visit(A); | 101 | | | 102 | 26.9k | if (const comments::FullComment *Comment = | 103 | 26.9k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 104 | 26.9k | Visit(Comment, Comment); | 105 | | | 106 | | // Decls within functions are visited by the body. | 107 | 26.9k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) { | 108 | 26.9k | if (Traversal != TK_AsIs) { | 109 | 26.9k | if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) { | 110 | 26.9k | auto SK = CTSD->getSpecializationKind(); | 111 | 26.9k | if (SK == TSK_ExplicitInstantiationDeclaration || | 112 | 26.9k | SK == TSK_ExplicitInstantiationDefinition) | 113 | 26.9k | return; | 114 | 26.9k | } | 115 | 26.9k | } | 116 | 26.9k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 117 | 26.9k | dumpDeclContext(DC); | 118 | 26.9k | } | 119 | 26.9k | }); | 120 | 26.9k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Decl const*) Line | Count | Source | 88 | 2.05k | void Visit(const Decl *D) { | 89 | 2.05k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isImplicit()0 ) | 90 | 0 | return; | 91 | | | 92 | 2.05k | getNodeDelegate().AddChild([=] { | 93 | 2.05k | getNodeDelegate().Visit(D); | 94 | 2.05k | if (!D) | 95 | 2.05k | return; | 96 | | | 97 | 2.05k | ConstDeclVisitor<Derived>::Visit(D); | 98 | | | 99 | 2.05k | for (const auto &A : D->attrs()) | 100 | 2.05k | Visit(A); | 101 | | | 102 | 2.05k | if (const comments::FullComment *Comment = | 103 | 2.05k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 104 | 2.05k | Visit(Comment, Comment); | 105 | | | 106 | | // Decls within functions are visited by the body. | 107 | 2.05k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) { | 108 | 2.05k | if (Traversal != TK_AsIs) { | 109 | 2.05k | if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) { | 110 | 2.05k | auto SK = CTSD->getSpecializationKind(); | 111 | 2.05k | if (SK == TSK_ExplicitInstantiationDeclaration || | 112 | 2.05k | SK == TSK_ExplicitInstantiationDefinition) | 113 | 2.05k | return; | 114 | 2.05k | } | 115 | 2.05k | } | 116 | 2.05k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 117 | 2.05k | dumpDeclContext(DC); | 118 | 2.05k | } | 119 | 2.05k | }); | 120 | 2.05k | } |
|
121 | | |
122 | 38.6k | void Visit(const Stmt *Node, StringRef Label = {}) { |
123 | 38.6k | getNodeDelegate().AddChild(Label, [=] { |
124 | 38.6k | const Stmt *S = Node; |
125 | | |
126 | 38.6k | if (auto *E = dyn_cast_or_null<Expr>(S)) { |
127 | 28.3k | switch (Traversal) { |
128 | 28.3k | case TK_AsIs: |
129 | 28.3k | break; |
130 | 0 | case TK_IgnoreUnlessSpelledInSource: |
131 | 0 | S = E->IgnoreUnlessSpelledInSource(); |
132 | 0 | break; |
133 | 28.3k | } |
134 | 28.3k | } |
135 | | |
136 | 38.6k | getNodeDelegate().Visit(S); |
137 | | |
138 | 38.6k | if (!S) { |
139 | 1.07k | return; |
140 | 1.07k | } |
141 | | |
142 | 37.6k | ConstStmtVisitor<Derived>::Visit(S); |
143 | | |
144 | | // Some statements have custom mechanisms for dumping their children. |
145 | 37.6k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)35.4k || |
146 | 37.6k | isa<RequiresExpr>(S)35.4k ) |
147 | 2.13k | return; |
148 | | |
149 | 35.4k | if (Traversal == TK_IgnoreUnlessSpelledInSource && |
150 | 35.4k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, |
151 | 0 | CXXRewrittenBinaryOperator>(S)) |
152 | 0 | return; |
153 | | |
154 | 35.4k | for (const Stmt *SubStmt : S->children()) |
155 | 29.9k | Visit(SubStmt); |
156 | 35.4k | }); clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef)::'lambda'()::operator()() const Line | Count | Source | 123 | 2.83k | getNodeDelegate().AddChild(Label, [=] { | 124 | 2.83k | const Stmt *S = Node; | 125 | | | 126 | 2.83k | if (auto *E = dyn_cast_or_null<Expr>(S)) { | 127 | 2.14k | switch (Traversal) { | 128 | 2.14k | case TK_AsIs: | 129 | 2.14k | break; | 130 | 0 | case TK_IgnoreUnlessSpelledInSource: | 131 | 0 | S = E->IgnoreUnlessSpelledInSource(); | 132 | 0 | break; | 133 | 2.14k | } | 134 | 2.14k | } | 135 | | | 136 | 2.83k | getNodeDelegate().Visit(S); | 137 | | | 138 | 2.83k | if (!S) { | 139 | 37 | return; | 140 | 37 | } | 141 | | | 142 | 2.79k | ConstStmtVisitor<Derived>::Visit(S); | 143 | | | 144 | | // Some statements have custom mechanisms for dumping their children. | 145 | 2.79k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)2.70k || | 146 | 2.79k | isa<RequiresExpr>(S)2.69k ) | 147 | 100 | return; | 148 | | | 149 | 2.69k | if (Traversal == TK_IgnoreUnlessSpelledInSource && | 150 | 2.69k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, | 151 | 0 | CXXRewrittenBinaryOperator>(S)) | 152 | 0 | return; | 153 | | | 154 | 2.69k | for (const Stmt *SubStmt : S->children()) | 155 | 2.28k | Visit(SubStmt); | 156 | 2.69k | }); |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef)::'lambda'()::operator()() const Line | Count | Source | 123 | 35.8k | getNodeDelegate().AddChild(Label, [=] { | 124 | 35.8k | const Stmt *S = Node; | 125 | | | 126 | 35.8k | if (auto *E = dyn_cast_or_null<Expr>(S)) { | 127 | 26.2k | switch (Traversal) { | 128 | 26.2k | case TK_AsIs: | 129 | 26.2k | break; | 130 | 0 | case TK_IgnoreUnlessSpelledInSource: | 131 | 0 | S = E->IgnoreUnlessSpelledInSource(); | 132 | 0 | break; | 133 | 26.2k | } | 134 | 26.2k | } | 135 | | | 136 | 35.8k | getNodeDelegate().Visit(S); | 137 | | | 138 | 35.8k | if (!S) { | 139 | 1.03k | return; | 140 | 1.03k | } | 141 | | | 142 | 34.8k | ConstStmtVisitor<Derived>::Visit(S); | 143 | | | 144 | | // Some statements have custom mechanisms for dumping their children. | 145 | 34.8k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)32.7k || | 146 | 34.8k | isa<RequiresExpr>(S)32.7k ) | 147 | 2.03k | return; | 148 | | | 149 | 32.7k | if (Traversal == TK_IgnoreUnlessSpelledInSource && | 150 | 32.7k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, | 151 | 0 | CXXRewrittenBinaryOperator>(S)) | 152 | 0 | return; | 153 | | | 154 | 32.7k | for (const Stmt *SubStmt : S->children()) | 155 | 27.7k | Visit(SubStmt); | 156 | 32.7k | }); |
|
157 | 38.6k | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef) Line | Count | Source | 122 | 2.83k | void Visit(const Stmt *Node, StringRef Label = {}) { | 123 | 2.83k | getNodeDelegate().AddChild(Label, [=] { | 124 | 2.83k | const Stmt *S = Node; | 125 | | | 126 | 2.83k | if (auto *E = dyn_cast_or_null<Expr>(S)) { | 127 | 2.83k | switch (Traversal) { | 128 | 2.83k | case TK_AsIs: | 129 | 2.83k | break; | 130 | 2.83k | case TK_IgnoreUnlessSpelledInSource: | 131 | 2.83k | S = E->IgnoreUnlessSpelledInSource(); | 132 | 2.83k | break; | 133 | 2.83k | } | 134 | 2.83k | } | 135 | | | 136 | 2.83k | getNodeDelegate().Visit(S); | 137 | | | 138 | 2.83k | if (!S) { | 139 | 2.83k | return; | 140 | 2.83k | } | 141 | | | 142 | 2.83k | ConstStmtVisitor<Derived>::Visit(S); | 143 | | | 144 | | // Some statements have custom mechanisms for dumping their children. | 145 | 2.83k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S) || | 146 | 2.83k | isa<RequiresExpr>(S)) | 147 | 2.83k | return; | 148 | | | 149 | 2.83k | if (Traversal == TK_IgnoreUnlessSpelledInSource && | 150 | 2.83k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, | 151 | 2.83k | CXXRewrittenBinaryOperator>(S)) | 152 | 2.83k | return; | 153 | | | 154 | 2.83k | for (const Stmt *SubStmt : S->children()) | 155 | 2.83k | Visit(SubStmt); | 156 | 2.83k | }); | 157 | 2.83k | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef) Line | Count | Source | 122 | 35.8k | void Visit(const Stmt *Node, StringRef Label = {}) { | 123 | 35.8k | getNodeDelegate().AddChild(Label, [=] { | 124 | 35.8k | const Stmt *S = Node; | 125 | | | 126 | 35.8k | if (auto *E = dyn_cast_or_null<Expr>(S)) { | 127 | 35.8k | switch (Traversal) { | 128 | 35.8k | case TK_AsIs: | 129 | 35.8k | break; | 130 | 35.8k | case TK_IgnoreUnlessSpelledInSource: | 131 | 35.8k | S = E->IgnoreUnlessSpelledInSource(); | 132 | 35.8k | break; | 133 | 35.8k | } | 134 | 35.8k | } | 135 | | | 136 | 35.8k | getNodeDelegate().Visit(S); | 137 | | | 138 | 35.8k | if (!S) { | 139 | 35.8k | return; | 140 | 35.8k | } | 141 | | | 142 | 35.8k | ConstStmtVisitor<Derived>::Visit(S); | 143 | | | 144 | | // Some statements have custom mechanisms for dumping their children. | 145 | 35.8k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S) || | 146 | 35.8k | isa<RequiresExpr>(S)) | 147 | 35.8k | return; | 148 | | | 149 | 35.8k | if (Traversal == TK_IgnoreUnlessSpelledInSource && | 150 | 35.8k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, | 151 | 35.8k | CXXRewrittenBinaryOperator>(S)) | 152 | 35.8k | return; | 153 | | | 154 | 35.8k | for (const Stmt *SubStmt : S->children()) | 155 | 35.8k | Visit(SubStmt); | 156 | 35.8k | }); | 157 | 35.8k | } |
|
158 | | |
159 | 5.86k | void Visit(QualType T) { |
160 | 5.86k | SplitQualType SQT = T.split(); |
161 | 5.86k | if (!SQT.Quals.hasQualifiers()) |
162 | 5.83k | return Visit(SQT.Ty); |
163 | | |
164 | 27 | getNodeDelegate().AddChild([=] { |
165 | 27 | getNodeDelegate().Visit(T); |
166 | 27 | Visit(T.split().Ty); |
167 | 27 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::QualType)::'lambda'()::operator()() const Line | Count | Source | 164 | 26 | getNodeDelegate().AddChild([=] { | 165 | 26 | getNodeDelegate().Visit(T); | 166 | 26 | Visit(T.split().Ty); | 167 | 26 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::QualType)::'lambda'()::operator()() const Line | Count | Source | 164 | 1 | getNodeDelegate().AddChild([=] { | 165 | 1 | getNodeDelegate().Visit(T); | 166 | 1 | Visit(T.split().Ty); | 167 | 1 | }); |
|
168 | 27 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::QualType) Line | Count | Source | 159 | 5.37k | void Visit(QualType T) { | 160 | 5.37k | SplitQualType SQT = T.split(); | 161 | 5.37k | if (!SQT.Quals.hasQualifiers()) | 162 | 5.34k | return Visit(SQT.Ty); | 163 | | | 164 | 26 | getNodeDelegate().AddChild([=] { | 165 | 26 | getNodeDelegate().Visit(T); | 166 | 26 | Visit(T.split().Ty); | 167 | 26 | }); | 168 | 26 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::QualType) Line | Count | Source | 159 | 491 | void Visit(QualType T) { | 160 | 491 | SplitQualType SQT = T.split(); | 161 | 491 | if (!SQT.Quals.hasQualifiers()) | 162 | 490 | return Visit(SQT.Ty); | 163 | | | 164 | 1 | getNodeDelegate().AddChild([=] { | 165 | 1 | getNodeDelegate().Visit(T); | 166 | 1 | Visit(T.split().Ty); | 167 | 1 | }); | 168 | 1 | } |
|
169 | | |
170 | 5.95k | void Visit(const Type *T) { |
171 | 5.95k | getNodeDelegate().AddChild([=] { |
172 | 5.95k | getNodeDelegate().Visit(T); |
173 | 5.95k | if (!T) |
174 | 1 | return; |
175 | 5.95k | TypeVisitor<Derived>::Visit(T); |
176 | | |
177 | 5.95k | QualType SingleStepDesugar = |
178 | 5.95k | T->getLocallyUnqualifiedSingleStepDesugaredType(); |
179 | 5.95k | if (SingleStepDesugar != QualType(T, 0)) |
180 | 284 | Visit(SingleStepDesugar); |
181 | 5.95k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Type const*)::'lambda'()::operator()() const Line | Count | Source | 171 | 5.45k | getNodeDelegate().AddChild([=] { | 172 | 5.45k | getNodeDelegate().Visit(T); | 173 | 5.45k | if (!T) | 174 | 0 | return; | 175 | 5.45k | TypeVisitor<Derived>::Visit(T); | 176 | | | 177 | 5.45k | QualType SingleStepDesugar = | 178 | 5.45k | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 179 | 5.45k | if (SingleStepDesugar != QualType(T, 0)) | 180 | 277 | Visit(SingleStepDesugar); | 181 | 5.45k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Type const*)::'lambda'()::operator()() const Line | Count | Source | 171 | 495 | getNodeDelegate().AddChild([=] { | 172 | 495 | getNodeDelegate().Visit(T); | 173 | 495 | if (!T) | 174 | 1 | return; | 175 | 494 | TypeVisitor<Derived>::Visit(T); | 176 | | | 177 | 494 | QualType SingleStepDesugar = | 178 | 494 | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 179 | 494 | if (SingleStepDesugar != QualType(T, 0)) | 180 | 7 | Visit(SingleStepDesugar); | 181 | 494 | }); |
|
182 | 5.95k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Type const*) Line | Count | Source | 170 | 5.45k | void Visit(const Type *T) { | 171 | 5.45k | getNodeDelegate().AddChild([=] { | 172 | 5.45k | getNodeDelegate().Visit(T); | 173 | 5.45k | if (!T) | 174 | 5.45k | return; | 175 | 5.45k | TypeVisitor<Derived>::Visit(T); | 176 | | | 177 | 5.45k | QualType SingleStepDesugar = | 178 | 5.45k | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 179 | 5.45k | if (SingleStepDesugar != QualType(T, 0)) | 180 | 5.45k | Visit(SingleStepDesugar); | 181 | 5.45k | }); | 182 | 5.45k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Type const*) Line | Count | Source | 170 | 495 | void Visit(const Type *T) { | 171 | 495 | getNodeDelegate().AddChild([=] { | 172 | 495 | getNodeDelegate().Visit(T); | 173 | 495 | if (!T) | 174 | 495 | return; | 175 | 495 | TypeVisitor<Derived>::Visit(T); | 176 | | | 177 | 495 | QualType SingleStepDesugar = | 178 | 495 | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 179 | 495 | if (SingleStepDesugar != QualType(T, 0)) | 180 | 495 | Visit(SingleStepDesugar); | 181 | 495 | }); | 182 | 495 | } |
|
183 | | |
184 | 2.47k | void Visit(const Attr *A) { |
185 | 2.47k | getNodeDelegate().AddChild([=] { |
186 | 2.47k | getNodeDelegate().Visit(A); |
187 | 2.47k | ConstAttrVisitor<Derived>::Visit(A); |
188 | 2.47k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Attr const*)::'lambda'()::operator()() const Line | Count | Source | 185 | 2.44k | getNodeDelegate().AddChild([=] { | 186 | 2.44k | getNodeDelegate().Visit(A); | 187 | 2.44k | ConstAttrVisitor<Derived>::Visit(A); | 188 | 2.44k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Attr const*)::'lambda'()::operator()() const Line | Count | Source | 185 | 35 | getNodeDelegate().AddChild([=] { | 186 | 35 | getNodeDelegate().Visit(A); | 187 | 35 | ConstAttrVisitor<Derived>::Visit(A); | 188 | 35 | }); |
|
189 | 2.47k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Attr const*) Line | Count | Source | 184 | 2.44k | void Visit(const Attr *A) { | 185 | 2.44k | getNodeDelegate().AddChild([=] { | 186 | 2.44k | getNodeDelegate().Visit(A); | 187 | 2.44k | ConstAttrVisitor<Derived>::Visit(A); | 188 | 2.44k | }); | 189 | 2.44k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Attr const*) Line | Count | Source | 184 | 35 | void Visit(const Attr *A) { | 185 | 35 | getNodeDelegate().AddChild([=] { | 186 | 35 | getNodeDelegate().Visit(A); | 187 | 35 | ConstAttrVisitor<Derived>::Visit(A); | 188 | 35 | }); | 189 | 35 | } |
|
190 | | |
191 | 212 | void Visit(const CXXCtorInitializer *Init) { |
192 | 212 | if (Traversal == TK_IgnoreUnlessSpelledInSource && !Init->isWritten()0 ) |
193 | 0 | return; |
194 | 212 | getNodeDelegate().AddChild([=] { |
195 | 212 | getNodeDelegate().Visit(Init); |
196 | 212 | Visit(Init->getInit()); |
197 | 212 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::CXXCtorInitializer const*)::'lambda'()::operator()() const Line | Count | Source | 194 | 191 | getNodeDelegate().AddChild([=] { | 195 | 191 | getNodeDelegate().Visit(Init); | 196 | 191 | Visit(Init->getInit()); | 197 | 191 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::CXXCtorInitializer const*)::'lambda'()::operator()() const Line | Count | Source | 194 | 21 | getNodeDelegate().AddChild([=] { | 195 | 21 | getNodeDelegate().Visit(Init); | 196 | 21 | Visit(Init->getInit()); | 197 | 21 | }); |
|
198 | 212 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::CXXCtorInitializer const*) Line | Count | Source | 191 | 191 | void Visit(const CXXCtorInitializer *Init) { | 192 | 191 | if (Traversal == TK_IgnoreUnlessSpelledInSource && !Init->isWritten()0 ) | 193 | 0 | return; | 194 | 191 | getNodeDelegate().AddChild([=] { | 195 | 191 | getNodeDelegate().Visit(Init); | 196 | 191 | Visit(Init->getInit()); | 197 | 191 | }); | 198 | 191 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::CXXCtorInitializer const*) Line | Count | Source | 191 | 21 | void Visit(const CXXCtorInitializer *Init) { | 192 | 21 | if (Traversal == TK_IgnoreUnlessSpelledInSource && !Init->isWritten()0 ) | 193 | 0 | return; | 194 | 21 | getNodeDelegate().AddChild([=] { | 195 | 21 | getNodeDelegate().Visit(Init); | 196 | 21 | Visit(Init->getInit()); | 197 | 21 | }); | 198 | 21 | } |
|
199 | | |
200 | | void Visit(const TemplateArgument &A, SourceRange R = {}, |
201 | 894 | const Decl *From = nullptr, const char *Label = nullptr) { |
202 | 894 | getNodeDelegate().AddChild([=] { |
203 | 894 | getNodeDelegate().Visit(A, R, From, Label); |
204 | 894 | ConstTemplateArgumentVisitor<Derived>::Visit(A); |
205 | 894 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*)::'lambda'()::operator()() const Line | Count | Source | 202 | 855 | getNodeDelegate().AddChild([=] { | 203 | 855 | getNodeDelegate().Visit(A, R, From, Label); | 204 | 855 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 205 | 855 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*)::'lambda'()::operator()() const Line | Count | Source | 202 | 39 | getNodeDelegate().AddChild([=] { | 203 | 39 | getNodeDelegate().Visit(A, R, From, Label); | 204 | 39 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 205 | 39 | }); |
|
206 | 894 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*) Line | Count | Source | 201 | 855 | const Decl *From = nullptr, const char *Label = nullptr) { | 202 | 855 | getNodeDelegate().AddChild([=] { | 203 | 855 | getNodeDelegate().Visit(A, R, From, Label); | 204 | 855 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 205 | 855 | }); | 206 | 855 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*) Line | Count | Source | 201 | 39 | const Decl *From = nullptr, const char *Label = nullptr) { | 202 | 39 | getNodeDelegate().AddChild([=] { | 203 | 39 | getNodeDelegate().Visit(A, R, From, Label); | 204 | 39 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 205 | 39 | }); | 206 | 39 | } |
|
207 | | |
208 | 11 | void Visit(const BlockDecl::Capture &C) { |
209 | 11 | getNodeDelegate().AddChild([=] { |
210 | 11 | getNodeDelegate().Visit(C); |
211 | 11 | if (C.hasCopyExpr()) |
212 | 2 | Visit(C.getCopyExpr()); |
213 | 11 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::BlockDecl::Capture const&)::'lambda'()::operator()() const Line | Count | Source | 209 | 8 | getNodeDelegate().AddChild([=] { | 210 | 8 | getNodeDelegate().Visit(C); | 211 | 8 | if (C.hasCopyExpr()) | 212 | 2 | Visit(C.getCopyExpr()); | 213 | 8 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::BlockDecl::Capture const&)::'lambda'()::operator()() const Line | Count | Source | 209 | 3 | getNodeDelegate().AddChild([=] { | 210 | 3 | getNodeDelegate().Visit(C); | 211 | 3 | if (C.hasCopyExpr()) | 212 | 0 | Visit(C.getCopyExpr()); | 213 | 3 | }); |
|
214 | 11 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::BlockDecl::Capture const&) Line | Count | Source | 208 | 8 | void Visit(const BlockDecl::Capture &C) { | 209 | 8 | getNodeDelegate().AddChild([=] { | 210 | 8 | getNodeDelegate().Visit(C); | 211 | 8 | if (C.hasCopyExpr()) | 212 | 8 | Visit(C.getCopyExpr()); | 213 | 8 | }); | 214 | 8 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::BlockDecl::Capture const&) Line | Count | Source | 208 | 3 | void Visit(const BlockDecl::Capture &C) { | 209 | 3 | getNodeDelegate().AddChild([=] { | 210 | 3 | getNodeDelegate().Visit(C); | 211 | 3 | if (C.hasCopyExpr()) | 212 | 3 | Visit(C.getCopyExpr()); | 213 | 3 | }); | 214 | 3 | } |
|
215 | | |
216 | 422 | void Visit(const OMPClause *C) { |
217 | 422 | getNodeDelegate().AddChild([=] { |
218 | 422 | getNodeDelegate().Visit(C); |
219 | 422 | for (const auto *S : C->children()) |
220 | 494 | Visit(S); |
221 | 422 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::OMPClause const*)::'lambda'()::operator()() const Line | Count | Source | 217 | 420 | getNodeDelegate().AddChild([=] { | 218 | 420 | getNodeDelegate().Visit(C); | 219 | 420 | for (const auto *S : C->children()) | 220 | 492 | Visit(S); | 221 | 420 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::OMPClause const*)::'lambda'()::operator()() const Line | Count | Source | 217 | 2 | getNodeDelegate().AddChild([=] { | 218 | 2 | getNodeDelegate().Visit(C); | 219 | 2 | for (const auto *S : C->children()) | 220 | 2 | Visit(S); | 221 | 2 | }); |
|
222 | 422 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::OMPClause const*) Line | Count | Source | 216 | 420 | void Visit(const OMPClause *C) { | 217 | 420 | getNodeDelegate().AddChild([=] { | 218 | 420 | getNodeDelegate().Visit(C); | 219 | 420 | for (const auto *S : C->children()) | 220 | 420 | Visit(S); | 221 | 420 | }); | 222 | 420 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::OMPClause const*) Line | Count | Source | 216 | 2 | void Visit(const OMPClause *C) { | 217 | 2 | getNodeDelegate().AddChild([=] { | 218 | 2 | getNodeDelegate().Visit(C); | 219 | 2 | for (const auto *S : C->children()) | 220 | 2 | Visit(S); | 221 | 2 | }); | 222 | 2 | } |
|
223 | | |
224 | 38 | void Visit(const GenericSelectionExpr::ConstAssociation &A) { |
225 | 38 | getNodeDelegate().AddChild([=] { |
226 | 38 | getNodeDelegate().Visit(A); |
227 | 38 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) |
228 | 27 | Visit(TSI->getType()); |
229 | 38 | Visit(A.getAssociationExpr()); |
230 | 38 | }); clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::GenericSelectionExpr::AssociationTy<true> const&)::'lambda'()::operator()() const Line | Count | Source | 225 | 12 | getNodeDelegate().AddChild([=] { | 226 | 12 | getNodeDelegate().Visit(A); | 227 | 12 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) | 228 | 7 | Visit(TSI->getType()); | 229 | 12 | Visit(A.getAssociationExpr()); | 230 | 12 | }); |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::GenericSelectionExpr::AssociationTy<true> const&)::'lambda'()::operator()() const Line | Count | Source | 225 | 26 | getNodeDelegate().AddChild([=] { | 226 | 26 | getNodeDelegate().Visit(A); | 227 | 26 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) | 228 | 20 | Visit(TSI->getType()); | 229 | 26 | Visit(A.getAssociationExpr()); | 230 | 26 | }); |
|
231 | 38 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::GenericSelectionExpr::AssociationTy<true> const&) Line | Count | Source | 224 | 12 | void Visit(const GenericSelectionExpr::ConstAssociation &A) { | 225 | 12 | getNodeDelegate().AddChild([=] { | 226 | 12 | getNodeDelegate().Visit(A); | 227 | 12 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) | 228 | 12 | Visit(TSI->getType()); | 229 | 12 | Visit(A.getAssociationExpr()); | 230 | 12 | }); | 231 | 12 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::GenericSelectionExpr::AssociationTy<true> const&) Line | Count | Source | 224 | 26 | void Visit(const GenericSelectionExpr::ConstAssociation &A) { | 225 | 26 | getNodeDelegate().AddChild([=] { | 226 | 26 | getNodeDelegate().Visit(A); | 227 | 26 | if (const TypeSourceInfo *TSI = A.getTypeSourceInfo()) | 228 | 26 | Visit(TSI->getType()); | 229 | 26 | Visit(A.getAssociationExpr()); | 230 | 26 | }); | 231 | 26 | } |
|
232 | | |
233 | 12 | void Visit(const concepts::Requirement *R) { |
234 | 12 | getNodeDelegate().AddChild([=] { |
235 | 12 | getNodeDelegate().Visit(R); |
236 | 12 | if (!R) |
237 | 0 | return; |
238 | 12 | if (auto *TR = dyn_cast<concepts::TypeRequirement>(R)) { |
239 | 3 | if (!TR->isSubstitutionFailure()) |
240 | 3 | Visit(TR->getType()->getType().getTypePtr()); |
241 | 9 | } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(R)) { |
242 | 6 | if (!ER->isExprSubstitutionFailure()) |
243 | 6 | Visit(ER->getExpr()); |
244 | 6 | if (!ER->getReturnTypeRequirement().isEmpty()) |
245 | 3 | Visit(ER->getReturnTypeRequirement() |
246 | 3 | .getTypeConstraint() |
247 | 3 | ->getImmediatelyDeclaredConstraint()); |
248 | 6 | } else if (auto *3 NR3 = dyn_cast<concepts::NestedRequirement>(R)) { |
249 | 3 | if (!NR->isSubstitutionFailure()) |
250 | 3 | Visit(NR->getConstraintExpr()); |
251 | 3 | } |
252 | 12 | }); clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::concepts::Requirement const*)::'lambda'()::operator()() const Line | Count | Source | 234 | 4 | getNodeDelegate().AddChild([=] { | 235 | 4 | getNodeDelegate().Visit(R); | 236 | 4 | if (!R) | 237 | 0 | return; | 238 | 4 | if (auto *TR = dyn_cast<concepts::TypeRequirement>(R)) { | 239 | 1 | if (!TR->isSubstitutionFailure()) | 240 | 1 | Visit(TR->getType()->getType().getTypePtr()); | 241 | 3 | } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(R)) { | 242 | 2 | if (!ER->isExprSubstitutionFailure()) | 243 | 2 | Visit(ER->getExpr()); | 244 | 2 | if (!ER->getReturnTypeRequirement().isEmpty()) | 245 | 1 | Visit(ER->getReturnTypeRequirement() | 246 | 1 | .getTypeConstraint() | 247 | 1 | ->getImmediatelyDeclaredConstraint()); | 248 | 2 | } else if (auto *1 NR1 = dyn_cast<concepts::NestedRequirement>(R)) { | 249 | 1 | if (!NR->isSubstitutionFailure()) | 250 | 1 | Visit(NR->getConstraintExpr()); | 251 | 1 | } | 252 | 4 | }); |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::concepts::Requirement const*)::'lambda'()::operator()() const Line | Count | Source | 234 | 8 | getNodeDelegate().AddChild([=] { | 235 | 8 | getNodeDelegate().Visit(R); | 236 | 8 | if (!R) | 237 | 0 | return; | 238 | 8 | if (auto *TR = dyn_cast<concepts::TypeRequirement>(R)) { | 239 | 2 | if (!TR->isSubstitutionFailure()) | 240 | 2 | Visit(TR->getType()->getType().getTypePtr()); | 241 | 6 | } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(R)) { | 242 | 4 | if (!ER->isExprSubstitutionFailure()) | 243 | 4 | Visit(ER->getExpr()); | 244 | 4 | if (!ER->getReturnTypeRequirement().isEmpty()) | 245 | 2 | Visit(ER->getReturnTypeRequirement() | 246 | 2 | .getTypeConstraint() | 247 | 2 | ->getImmediatelyDeclaredConstraint()); | 248 | 4 | } else if (auto *2 NR2 = dyn_cast<concepts::NestedRequirement>(R)) { | 249 | 2 | if (!NR->isSubstitutionFailure()) | 250 | 2 | Visit(NR->getConstraintExpr()); | 251 | 2 | } | 252 | 8 | }); |
|
253 | 12 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::concepts::Requirement const*) Line | Count | Source | 233 | 4 | void Visit(const concepts::Requirement *R) { | 234 | 4 | getNodeDelegate().AddChild([=] { | 235 | 4 | getNodeDelegate().Visit(R); | 236 | 4 | if (!R) | 237 | 4 | return; | 238 | 4 | if (auto *TR = dyn_cast<concepts::TypeRequirement>(R)) { | 239 | 4 | if (!TR->isSubstitutionFailure()) | 240 | 4 | Visit(TR->getType()->getType().getTypePtr()); | 241 | 4 | } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(R)) { | 242 | 4 | if (!ER->isExprSubstitutionFailure()) | 243 | 4 | Visit(ER->getExpr()); | 244 | 4 | if (!ER->getReturnTypeRequirement().isEmpty()) | 245 | 4 | Visit(ER->getReturnTypeRequirement() | 246 | 4 | .getTypeConstraint() | 247 | 4 | ->getImmediatelyDeclaredConstraint()); | 248 | 4 | } else if (auto *NR = dyn_cast<concepts::NestedRequirement>(R)) { | 249 | 4 | if (!NR->isSubstitutionFailure()) | 250 | 4 | Visit(NR->getConstraintExpr()); | 251 | 4 | } | 252 | 4 | }); | 253 | 4 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::concepts::Requirement const*) Line | Count | Source | 233 | 8 | void Visit(const concepts::Requirement *R) { | 234 | 8 | getNodeDelegate().AddChild([=] { | 235 | 8 | getNodeDelegate().Visit(R); | 236 | 8 | if (!R) | 237 | 8 | return; | 238 | 8 | if (auto *TR = dyn_cast<concepts::TypeRequirement>(R)) { | 239 | 8 | if (!TR->isSubstitutionFailure()) | 240 | 8 | Visit(TR->getType()->getType().getTypePtr()); | 241 | 8 | } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(R)) { | 242 | 8 | if (!ER->isExprSubstitutionFailure()) | 243 | 8 | Visit(ER->getExpr()); | 244 | 8 | if (!ER->getReturnTypeRequirement().isEmpty()) | 245 | 8 | Visit(ER->getReturnTypeRequirement() | 246 | 8 | .getTypeConstraint() | 247 | 8 | ->getImmediatelyDeclaredConstraint()); | 248 | 8 | } else if (auto *NR = dyn_cast<concepts::NestedRequirement>(R)) { | 249 | 8 | if (!NR->isSubstitutionFailure()) | 250 | 8 | Visit(NR->getConstraintExpr()); | 251 | 8 | } | 252 | 8 | }); | 253 | 8 | } |
|
254 | | |
255 | 0 | void Visit(const APValue &Value, QualType Ty) { |
256 | 0 | getNodeDelegate().AddChild([=] { getNodeDelegate().Visit(Value, Ty); }); |
257 | 0 | } |
258 | | |
259 | 711 | void Visit(const comments::Comment *C, const comments::FullComment *FC) { |
260 | 711 | getNodeDelegate().AddChild([=] { |
261 | 711 | getNodeDelegate().Visit(C, FC); |
262 | 711 | if (!C) { |
263 | 0 | return; |
264 | 0 | } |
265 | 711 | comments::ConstCommentVisitor<Derived, void, |
266 | 711 | const comments::FullComment *>::visit(C, |
267 | 711 | FC); |
268 | 711 | for (comments::Comment::child_iterator I = C->child_begin(), |
269 | 711 | E = C->child_end(); |
270 | 1.28k | I != E; ++I575 ) |
271 | 575 | Visit(*I, FC); |
272 | 711 | }); clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::comments::Comment const*, clang::comments::FullComment const*)::'lambda'()::operator()() const Line | Count | Source | 260 | 64 | getNodeDelegate().AddChild([=] { | 261 | 64 | getNodeDelegate().Visit(C, FC); | 262 | 64 | if (!C) { | 263 | 0 | return; | 264 | 0 | } | 265 | 64 | comments::ConstCommentVisitor<Derived, void, | 266 | 64 | const comments::FullComment *>::visit(C, | 267 | 64 | FC); | 268 | 64 | for (comments::Comment::child_iterator I = C->child_begin(), | 269 | 64 | E = C->child_end(); | 270 | 116 | I != E; ++I52 ) | 271 | 52 | Visit(*I, FC); | 272 | 64 | }); |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::comments::Comment const*, clang::comments::FullComment const*)::'lambda'()::operator()() const Line | Count | Source | 260 | 647 | getNodeDelegate().AddChild([=] { | 261 | 647 | getNodeDelegate().Visit(C, FC); | 262 | 647 | if (!C) { | 263 | 0 | return; | 264 | 0 | } | 265 | 647 | comments::ConstCommentVisitor<Derived, void, | 266 | 647 | const comments::FullComment *>::visit(C, | 267 | 647 | FC); | 268 | 647 | for (comments::Comment::child_iterator I = C->child_begin(), | 269 | 647 | E = C->child_end(); | 270 | 1.17k | I != E; ++I523 ) | 271 | 523 | Visit(*I, FC); | 272 | 647 | }); |
|
273 | 711 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::comments::Comment const*, clang::comments::FullComment const*) Line | Count | Source | 259 | 64 | void Visit(const comments::Comment *C, const comments::FullComment *FC) { | 260 | 64 | getNodeDelegate().AddChild([=] { | 261 | 64 | getNodeDelegate().Visit(C, FC); | 262 | 64 | if (!C) { | 263 | 64 | return; | 264 | 64 | } | 265 | 64 | comments::ConstCommentVisitor<Derived, void, | 266 | 64 | const comments::FullComment *>::visit(C, | 267 | 64 | FC); | 268 | 64 | for (comments::Comment::child_iterator I = C->child_begin(), | 269 | 64 | E = C->child_end(); | 270 | 64 | I != E; ++I) | 271 | 64 | Visit(*I, FC); | 272 | 64 | }); | 273 | 64 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::comments::Comment const*, clang::comments::FullComment const*) Line | Count | Source | 259 | 647 | void Visit(const comments::Comment *C, const comments::FullComment *FC) { | 260 | 647 | getNodeDelegate().AddChild([=] { | 261 | 647 | getNodeDelegate().Visit(C, FC); | 262 | 647 | if (!C) { | 263 | 647 | return; | 264 | 647 | } | 265 | 647 | comments::ConstCommentVisitor<Derived, void, | 266 | 647 | const comments::FullComment *>::visit(C, | 267 | 647 | FC); | 268 | 647 | for (comments::Comment::child_iterator I = C->child_begin(), | 269 | 647 | E = C->child_end(); | 270 | 647 | I != E; ++I) | 271 | 647 | Visit(*I, FC); | 272 | 647 | }); | 273 | 647 | } |
|
274 | | |
275 | | void Visit(const DynTypedNode &N) { |
276 | | // FIXME: Improve this with a switch or a visitor pattern. |
277 | | if (const auto *D = N.get<Decl>()) |
278 | | Visit(D); |
279 | | else if (const auto *S = N.get<Stmt>()) |
280 | | Visit(S); |
281 | | else if (const auto *QT = N.get<QualType>()) |
282 | | Visit(*QT); |
283 | | else if (const auto *T = N.get<Type>()) |
284 | | Visit(T); |
285 | | else if (const auto *C = N.get<CXXCtorInitializer>()) |
286 | | Visit(C); |
287 | | else if (const auto *C = N.get<OMPClause>()) |
288 | | Visit(C); |
289 | | else if (const auto *T = N.get<TemplateArgument>()) |
290 | | Visit(*T); |
291 | | } |
292 | | |
293 | 5.47k | void dumpDeclContext(const DeclContext *DC) { |
294 | 5.47k | if (!DC) |
295 | 0 | return; |
296 | | |
297 | 5.47k | for (const auto *D : (Deserialize ? DC->decls()862 : DC->noload_decls()4.61k )) |
298 | 18.9k | Visit(D); |
299 | 5.47k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpDeclContext(clang::DeclContext const*) Line | Count | Source | 293 | 5.08k | void dumpDeclContext(const DeclContext *DC) { | 294 | 5.08k | if (!DC) | 295 | 0 | return; | 296 | | | 297 | 5.08k | for (const auto *D : (Deserialize ? DC->decls()862 : DC->noload_decls()4.22k )) | 298 | 17.6k | Visit(D); | 299 | 5.08k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpDeclContext(clang::DeclContext const*) Line | Count | Source | 293 | 391 | void dumpDeclContext(const DeclContext *DC) { | 294 | 391 | if (!DC) | 295 | 0 | return; | 296 | | | 297 | 391 | for (const auto *D : (Deserialize ? DC->decls()0 : DC->noload_decls())) | 298 | 1.32k | Visit(D); | 299 | 391 | } |
|
300 | | |
301 | 722 | void dumpTemplateParameters(const TemplateParameterList *TPL) { |
302 | 722 | if (!TPL) |
303 | 0 | return; |
304 | | |
305 | 722 | for (const auto &TP : *TPL) |
306 | 877 | Visit(TP); |
307 | | |
308 | 722 | if (const Expr *RC = TPL->getRequiresClause()) |
309 | 2 | Visit(RC); |
310 | 722 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpTemplateParameters(clang::TemplateParameterList const*) Line | Count | Source | 301 | 668 | void dumpTemplateParameters(const TemplateParameterList *TPL) { | 302 | 668 | if (!TPL) | 303 | 0 | return; | 304 | | | 305 | 668 | for (const auto &TP : *TPL) | 306 | 819 | Visit(TP); | 307 | | | 308 | 668 | if (const Expr *RC = TPL->getRequiresClause()) | 309 | 2 | Visit(RC); | 310 | 668 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpTemplateParameters(clang::TemplateParameterList const*) Line | Count | Source | 301 | 54 | void dumpTemplateParameters(const TemplateParameterList *TPL) { | 302 | 54 | if (!TPL) | 303 | 0 | return; | 304 | | | 305 | 54 | for (const auto &TP : *TPL) | 306 | 58 | Visit(TP); | 307 | | | 308 | 54 | if (const Expr *RC = TPL->getRequiresClause()) | 309 | 0 | Visit(RC); | 310 | 54 | } |
|
311 | | |
312 | | void |
313 | 1 | dumpASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *TALI) { |
314 | 1 | if (!TALI) |
315 | 0 | return; |
316 | | |
317 | 1 | for (const auto &TA : TALI->arguments()) |
318 | 1 | dumpTemplateArgumentLoc(TA); |
319 | 1 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpASTTemplateArgumentListInfo(clang::ASTTemplateArgumentListInfo const*) Line | Count | Source | 313 | 1 | dumpASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *TALI) { | 314 | 1 | if (!TALI) | 315 | 0 | return; | 316 | | | 317 | 1 | for (const auto &TA : TALI->arguments()) | 318 | 1 | dumpTemplateArgumentLoc(TA); | 319 | 1 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpASTTemplateArgumentListInfo(clang::ASTTemplateArgumentListInfo const*) |
320 | | |
321 | | void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A, |
322 | | const Decl *From = nullptr, |
323 | 33 | const char *Label = nullptr) { |
324 | 33 | Visit(A.getArgument(), A.getSourceRange(), From, Label); |
325 | 33 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpTemplateArgumentLoc(clang::TemplateArgumentLoc const&, clang::Decl const*, char const*) Line | Count | Source | 323 | 28 | const char *Label = nullptr) { | 324 | 28 | Visit(A.getArgument(), A.getSourceRange(), From, Label); | 325 | 28 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpTemplateArgumentLoc(clang::TemplateArgumentLoc const&, clang::Decl const*, char const*) Line | Count | Source | 323 | 5 | const char *Label = nullptr) { | 324 | 5 | Visit(A.getArgument(), A.getSourceRange(), From, Label); | 325 | 5 | } |
|
326 | | |
327 | 429 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { |
328 | 952 | for (unsigned i = 0, e = TAL.size(); i < e; ++i523 ) |
329 | 523 | Visit(TAL[i]); |
330 | 429 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpTemplateArgumentList(clang::TemplateArgumentList const&) Line | Count | Source | 327 | 400 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { | 328 | 891 | for (unsigned i = 0, e = TAL.size(); i < e; ++i491 ) | 329 | 491 | Visit(TAL[i]); | 330 | 400 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpTemplateArgumentList(clang::TemplateArgumentList const&) Line | Count | Source | 327 | 29 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { | 328 | 61 | for (unsigned i = 0, e = TAL.size(); i < e; ++i32 ) | 329 | 32 | Visit(TAL[i]); | 330 | 29 | } |
|
331 | | |
332 | 129 | void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) { |
333 | 129 | if (!typeParams) |
334 | 125 | return; |
335 | | |
336 | 5 | for (const auto &typeParam : *typeParams)4 { |
337 | 5 | Visit(typeParam); |
338 | 5 | } |
339 | 4 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpObjCTypeParamList(clang::ObjCTypeParamList const*) Line | Count | Source | 332 | 124 | void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) { | 333 | 124 | if (!typeParams) | 334 | 121 | return; | 335 | | | 336 | 4 | for (const auto &typeParam : *typeParams)3 { | 337 | 4 | Visit(typeParam); | 338 | 4 | } | 339 | 3 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpObjCTypeParamList(clang::ObjCTypeParamList const*) Line | Count | Source | 332 | 5 | void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) { | 333 | 5 | if (!typeParams) | 334 | 4 | return; | 335 | | | 336 | 1 | for (const auto &typeParam : *typeParams) { | 337 | 1 | Visit(typeParam); | 338 | 1 | } | 339 | 1 | } |
|
340 | | |
341 | 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*) |
342 | | void VisitLocInfoType(const LocInfoType *T) { |
343 | | Visit(T->getTypeSourceInfo()->getType()); |
344 | | } |
345 | 596 | void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPointerType(clang::PointerType const*) Line | Count | Source | 345 | 533 | void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPointerType(clang::PointerType const*) Line | Count | Source | 345 | 63 | void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); } |
|
346 | 0 | void VisitBlockPointerType(const BlockPointerType *T) { |
347 | 0 | Visit(T->getPointeeType()); |
348 | 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*) |
349 | 28 | void VisitReferenceType(const ReferenceType *T) { |
350 | 28 | Visit(T->getPointeeType()); |
351 | 28 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitReferenceType(clang::ReferenceType const*) Line | Count | Source | 349 | 28 | void VisitReferenceType(const ReferenceType *T) { | 350 | 28 | Visit(T->getPointeeType()); | 351 | 28 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitReferenceType(clang::ReferenceType const*) |
352 | 2 | void VisitMemberPointerType(const MemberPointerType *T) { |
353 | 2 | Visit(T->getClass()); |
354 | 2 | Visit(T->getPointeeType()); |
355 | 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 | 352 | 2 | void VisitMemberPointerType(const MemberPointerType *T) { | 353 | 2 | Visit(T->getClass()); | 354 | 2 | Visit(T->getPointeeType()); | 355 | 2 | } |
|
356 | 433 | void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitArrayType(clang::ArrayType const*) Line | Count | Source | 356 | 374 | void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitArrayType(clang::ArrayType const*) Line | Count | Source | 356 | 59 | void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); } |
|
357 | 0 | void VisitVariableArrayType(const VariableArrayType *T) { |
358 | 0 | VisitArrayType(T); |
359 | 0 | Visit(T->getSizeExpr()); |
360 | 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*) |
361 | 7 | void VisitDependentSizedArrayType(const DependentSizedArrayType *T) { |
362 | 7 | Visit(T->getElementType()); |
363 | 7 | Visit(T->getSizeExpr()); |
364 | 7 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDependentSizedArrayType(clang::DependentSizedArrayType const*) Line | Count | Source | 361 | 6 | void VisitDependentSizedArrayType(const DependentSizedArrayType *T) { | 362 | 6 | Visit(T->getElementType()); | 363 | 6 | Visit(T->getSizeExpr()); | 364 | 6 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDependentSizedArrayType(clang::DependentSizedArrayType const*) Line | Count | Source | 361 | 1 | void VisitDependentSizedArrayType(const DependentSizedArrayType *T) { | 362 | 1 | Visit(T->getElementType()); | 363 | 1 | Visit(T->getSizeExpr()); | 364 | 1 | } |
|
365 | 21 | void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) { |
366 | 21 | Visit(T->getElementType()); |
367 | 21 | Visit(T->getSizeExpr()); |
368 | 21 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDependentSizedExtVectorType(clang::DependentSizedExtVectorType const*) Line | Count | Source | 365 | 21 | void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) { | 366 | 21 | Visit(T->getElementType()); | 367 | 21 | Visit(T->getSizeExpr()); | 368 | 21 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDependentSizedExtVectorType(clang::DependentSizedExtVectorType const*) |
369 | 9 | void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVectorType(clang::VectorType const*) Line | Count | Source | 369 | 9 | void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVectorType(clang::VectorType const*) |
370 | 52 | void VisitFunctionType(const FunctionType *T) { Visit(T->getReturnType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionType(clang::FunctionType const*) Line | Count | Source | 370 | 48 | void VisitFunctionType(const FunctionType *T) { Visit(T->getReturnType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFunctionType(clang::FunctionType const*) Line | Count | Source | 370 | 4 | void VisitFunctionType(const FunctionType *T) { Visit(T->getReturnType()); } |
|
371 | 52 | void VisitFunctionProtoType(const FunctionProtoType *T) { |
372 | 52 | VisitFunctionType(T); |
373 | 52 | for (const QualType &PT : T->getParamTypes()) |
374 | 55 | Visit(PT); |
375 | 52 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionProtoType(clang::FunctionProtoType const*) Line | Count | Source | 371 | 48 | void VisitFunctionProtoType(const FunctionProtoType *T) { | 372 | 48 | VisitFunctionType(T); | 373 | 48 | for (const QualType &PT : T->getParamTypes()) | 374 | 54 | Visit(PT); | 375 | 48 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFunctionProtoType(clang::FunctionProtoType const*) Line | Count | Source | 371 | 4 | void VisitFunctionProtoType(const FunctionProtoType *T) { | 372 | 4 | VisitFunctionType(T); | 373 | 4 | for (const QualType &PT : T->getParamTypes()) | 374 | 1 | Visit(PT); | 375 | 4 | } |
|
376 | 32 | void VisitTypeOfExprType(const TypeOfExprType *T) { |
377 | 32 | Visit(T->getUnderlyingExpr()); |
378 | 32 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeOfExprType(clang::TypeOfExprType const*) Line | Count | Source | 376 | 32 | void VisitTypeOfExprType(const TypeOfExprType *T) { | 377 | 32 | Visit(T->getUnderlyingExpr()); | 378 | 32 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeOfExprType(clang::TypeOfExprType const*) |
379 | 8 | void VisitDecltypeType(const DecltypeType *T) { |
380 | 8 | Visit(T->getUnderlyingExpr()); |
381 | 8 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDecltypeType(clang::DecltypeType const*) Line | Count | Source | 379 | 8 | void VisitDecltypeType(const DecltypeType *T) { | 380 | 8 | Visit(T->getUnderlyingExpr()); | 381 | 8 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDecltypeType(clang::DecltypeType const*) |
382 | 0 | void VisitUnaryTransformType(const UnaryTransformType *T) { |
383 | 0 | Visit(T->getBaseType()); |
384 | 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*) |
385 | 1 | void VisitAttributedType(const AttributedType *T) { |
386 | | // FIXME: AttrKind |
387 | 1 | Visit(T->getModifiedType()); |
388 | 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 | 385 | 1 | void VisitAttributedType(const AttributedType *T) { | 386 | | // FIXME: AttrKind | 387 | 1 | Visit(T->getModifiedType()); | 388 | 1 | } |
|
389 | 0 | void VisitBTFTagAttributedType(const BTFTagAttributedType *T) { |
390 | 0 | Visit(T->getWrappedType()); |
391 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBTFTagAttributedType(clang::BTFTagAttributedType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBTFTagAttributedType(clang::BTFTagAttributedType const*) |
392 | 77 | void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { |
393 | 77 | Visit(T->getReplacedParameter()); |
394 | 77 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstTemplateTypeParmType(clang::SubstTemplateTypeParmType const*) Line | Count | Source | 392 | 77 | void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { | 393 | 77 | Visit(T->getReplacedParameter()); | 394 | 77 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstTemplateTypeParmType(clang::SubstTemplateTypeParmType const*) |
395 | | void |
396 | 3 | VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) { |
397 | 3 | Visit(T->getReplacedParameter()); |
398 | 3 | Visit(T->getArgumentPack()); |
399 | 3 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstTemplateTypeParmPackType(clang::SubstTemplateTypeParmPackType const*) Line | Count | Source | 396 | 3 | VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) { | 397 | 3 | Visit(T->getReplacedParameter()); | 398 | 3 | Visit(T->getArgumentPack()); | 399 | 3 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstTemplateTypeParmPackType(clang::SubstTemplateTypeParmPackType const*) |
400 | 86 | void VisitTemplateSpecializationType(const TemplateSpecializationType *T) { |
401 | 86 | for (const auto &Arg : *T) |
402 | 141 | Visit(Arg); |
403 | 86 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateSpecializationType(clang::TemplateSpecializationType const*) Line | Count | Source | 400 | 86 | void VisitTemplateSpecializationType(const TemplateSpecializationType *T) { | 401 | 86 | for (const auto &Arg : *T) | 402 | 141 | Visit(Arg); | 403 | 86 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTemplateSpecializationType(clang::TemplateSpecializationType const*) |
404 | 81 | void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { |
405 | 81 | Visit(T->getPointeeType()); |
406 | 81 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCObjectPointerType(clang::ObjCObjectPointerType const*) Line | Count | Source | 404 | 81 | void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { | 405 | 81 | Visit(T->getPointeeType()); | 406 | 81 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCObjectPointerType(clang::ObjCObjectPointerType const*) |
407 | 114 | void VisitAtomicType(const AtomicType *T) { Visit(T->getValueType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitAtomicType(clang::AtomicType const*) Line | Count | Source | 407 | 114 | void VisitAtomicType(const AtomicType *T) { Visit(T->getValueType()); } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitAtomicType(clang::AtomicType const*) |
408 | 6 | void VisitPipeType(const PipeType *T) { Visit(T->getElementType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPipeType(clang::PipeType const*) Line | Count | Source | 408 | 6 | void VisitPipeType(const PipeType *T) { Visit(T->getElementType()); } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPipeType(clang::PipeType const*) |
409 | 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*) |
410 | 24 | void VisitPackExpansionType(const PackExpansionType *T) { |
411 | 24 | if (!T->isSugared()) |
412 | 24 | Visit(T->getPattern()); |
413 | 24 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPackExpansionType(clang::PackExpansionType const*) Line | Count | Source | 410 | 24 | void VisitPackExpansionType(const PackExpansionType *T) { | 411 | 24 | if (!T->isSugared()) | 412 | 24 | Visit(T->getPattern()); | 413 | 24 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPackExpansionType(clang::PackExpansionType const*) |
414 | | // FIXME: ElaboratedType, DependentNameType, |
415 | | // DependentTemplateSpecializationType, ObjCObjectType |
416 | | |
417 | 3.34k | void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypedefDecl(clang::TypedefDecl const*) Line | Count | Source | 417 | 3.03k | void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypedefDecl(clang::TypedefDecl const*) Line | Count | Source | 417 | 309 | void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); } |
|
418 | | |
419 | 113 | void VisitEnumConstantDecl(const EnumConstantDecl *D) { |
420 | 113 | if (const Expr *Init = D->getInitExpr()) |
421 | 31 | Visit(Init); |
422 | 113 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitEnumConstantDecl(clang::EnumConstantDecl const*) Line | Count | Source | 419 | 95 | void VisitEnumConstantDecl(const EnumConstantDecl *D) { | 420 | 95 | if (const Expr *Init = D->getInitExpr()) | 421 | 30 | Visit(Init); | 422 | 95 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitEnumConstantDecl(clang::EnumConstantDecl const*) Line | Count | Source | 419 | 18 | void VisitEnumConstantDecl(const EnumConstantDecl *D) { | 420 | 18 | if (const Expr *Init = D->getInitExpr()) | 421 | 1 | Visit(Init); | 422 | 18 | } |
|
423 | | |
424 | 5.46k | void VisitFunctionDecl(const FunctionDecl *D) { |
425 | 5.46k | if (const auto *FTSI = D->getTemplateSpecializationInfo()) |
426 | 189 | dumpTemplateArgumentList(*FTSI->TemplateArguments); |
427 | | |
428 | 5.46k | if (D->param_begin()) |
429 | 2.46k | for (const auto *Parameter : D->parameters()) |
430 | 3.17k | Visit(Parameter); |
431 | | |
432 | 5.46k | if (const Expr *TRC = D->getTrailingRequiresClause()) |
433 | 75 | Visit(TRC); |
434 | | |
435 | 5.46k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isDefaulted()0 ) |
436 | 0 | return; |
437 | | |
438 | 5.46k | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) |
439 | 993 | for (const auto *I : C->inits()) |
440 | 209 | Visit(I); |
441 | | |
442 | 5.46k | if (D->doesThisDeclarationHaveABody()) |
443 | 2.77k | Visit(D->getBody()); |
444 | 5.46k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionDecl(clang::FunctionDecl const*) Line | Count | Source | 424 | 4.96k | void VisitFunctionDecl(const FunctionDecl *D) { | 425 | 4.96k | if (const auto *FTSI = D->getTemplateSpecializationInfo()) | 426 | 187 | dumpTemplateArgumentList(*FTSI->TemplateArguments); | 427 | | | 428 | 4.96k | if (D->param_begin()) | 429 | 2.25k | for (const auto *Parameter : D->parameters()) | 430 | 2.92k | Visit(Parameter); | 431 | | | 432 | 4.96k | if (const Expr *TRC = D->getTrailingRequiresClause()) | 433 | 14 | Visit(TRC); | 434 | | | 435 | 4.96k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isDefaulted()0 ) | 436 | 0 | return; | 437 | | | 438 | 4.96k | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) | 439 | 939 | for (const auto *I : C->inits()) | 440 | 188 | Visit(I); | 441 | | | 442 | 4.96k | if (D->doesThisDeclarationHaveABody()) | 443 | 2.51k | Visit(D->getBody()); | 444 | 4.96k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFunctionDecl(clang::FunctionDecl const*) Line | Count | Source | 424 | 501 | void VisitFunctionDecl(const FunctionDecl *D) { | 425 | 501 | if (const auto *FTSI = D->getTemplateSpecializationInfo()) | 426 | 2 | dumpTemplateArgumentList(*FTSI->TemplateArguments); | 427 | | | 428 | 501 | if (D->param_begin()) | 429 | 212 | for (const auto *Parameter : D->parameters()) | 430 | 250 | Visit(Parameter); | 431 | | | 432 | 501 | if (const Expr *TRC = D->getTrailingRequiresClause()) | 433 | 61 | Visit(TRC); | 434 | | | 435 | 501 | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isDefaulted()0 ) | 436 | 0 | return; | 437 | | | 438 | 501 | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) | 439 | 54 | for (const auto *I : C->inits()) | 440 | 21 | Visit(I); | 441 | | | 442 | 501 | if (D->doesThisDeclarationHaveABody()) | 443 | 261 | Visit(D->getBody()); | 444 | 501 | } |
|
445 | | |
446 | 2.12k | void VisitFieldDecl(const FieldDecl *D) { |
447 | 2.12k | if (D->isBitField()) |
448 | 103 | Visit(D->getBitWidth()); |
449 | 2.12k | if (Expr *Init = D->getInClassInitializer()) |
450 | 46 | Visit(Init); |
451 | 2.12k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFieldDecl(clang::FieldDecl const*) Line | Count | Source | 446 | 2.01k | void VisitFieldDecl(const FieldDecl *D) { | 447 | 2.01k | if (D->isBitField()) | 448 | 96 | Visit(D->getBitWidth()); | 449 | 2.01k | if (Expr *Init = D->getInClassInitializer()) | 450 | 45 | Visit(Init); | 451 | 2.01k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFieldDecl(clang::FieldDecl const*) Line | Count | Source | 446 | 111 | void VisitFieldDecl(const FieldDecl *D) { | 447 | 111 | if (D->isBitField()) | 448 | 7 | Visit(D->getBitWidth()); | 449 | 111 | if (Expr *Init = D->getInClassInitializer()) | 450 | 1 | Visit(Init); | 451 | 111 | } |
|
452 | | |
453 | 9.80k | void VisitVarDecl(const VarDecl *D) { |
454 | 9.80k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isCXXForRangeDecl()0 ) |
455 | 0 | return; |
456 | | |
457 | 9.80k | if (D->hasInit()) |
458 | 2.84k | Visit(D->getInit()); |
459 | 9.80k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVarDecl(clang::VarDecl const*) Line | Count | Source | 453 | 9.33k | void VisitVarDecl(const VarDecl *D) { | 454 | 9.33k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isCXXForRangeDecl()0 ) | 455 | 0 | return; | 456 | | | 457 | 9.33k | if (D->hasInit()) | 458 | 2.76k | Visit(D->getInit()); | 459 | 9.33k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVarDecl(clang::VarDecl const*) Line | Count | Source | 453 | 468 | void VisitVarDecl(const VarDecl *D) { | 454 | 468 | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isCXXForRangeDecl()0 ) | 455 | 0 | return; | 456 | | | 457 | 468 | if (D->hasInit()) | 458 | 84 | Visit(D->getInit()); | 459 | 468 | } |
|
460 | | |
461 | 0 | void VisitDecompositionDecl(const DecompositionDecl *D) { |
462 | 0 | VisitVarDecl(D); |
463 | 0 | for (const auto *B : D->bindings()) |
464 | 0 | Visit(B); |
465 | 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*) |
466 | | |
467 | 0 | void VisitBindingDecl(const BindingDecl *D) { |
468 | 0 | if (Traversal == TK_IgnoreUnlessSpelledInSource) |
469 | 0 | return; |
470 | | |
471 | 0 | if (const auto *V = D->getHoldingVar()) |
472 | 0 | Visit(V); |
473 | |
|
474 | 0 | if (const auto *E = D->getBinding()) |
475 | 0 | Visit(E); |
476 | 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*) |
477 | | |
478 | 3 | void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) { |
479 | 3 | Visit(D->getAsmString()); |
480 | 3 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFileScopeAsmDecl(clang::FileScopeAsmDecl const*) Line | Count | Source | 478 | 3 | void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) { | 479 | 3 | Visit(D->getAsmString()); | 480 | 3 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFileScopeAsmDecl(clang::FileScopeAsmDecl const*) |
481 | | |
482 | 889 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCapturedDecl(clang::CapturedDecl const*) Line | Count | Source | 482 | 868 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCapturedDecl(clang::CapturedDecl const*) Line | Count | Source | 482 | 21 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } |
|
483 | | |
484 | 2 | void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { |
485 | 2 | for (const auto *E : D->varlists()) |
486 | 4 | Visit(E); |
487 | 2 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPThreadPrivateDecl(clang::OMPThreadPrivateDecl const*) Line | Count | Source | 484 | 2 | void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { | 485 | 2 | for (const auto *E : D->varlists()) | 486 | 4 | Visit(E); | 487 | 2 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPThreadPrivateDecl(clang::OMPThreadPrivateDecl const*) |
488 | | |
489 | 6 | void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) { |
490 | 6 | Visit(D->getCombiner()); |
491 | 6 | if (const auto *Initializer = D->getInitializer()) |
492 | 2 | Visit(Initializer); |
493 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPDeclareReductionDecl(clang::OMPDeclareReductionDecl const*) Line | Count | Source | 489 | 6 | void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) { | 490 | 6 | Visit(D->getCombiner()); | 491 | 6 | if (const auto *Initializer = D->getInitializer()) | 492 | 2 | Visit(Initializer); | 493 | 6 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPDeclareReductionDecl(clang::OMPDeclareReductionDecl const*) |
494 | | |
495 | 0 | void VisitOMPDeclareMapperDecl(const OMPDeclareMapperDecl *D) { |
496 | 0 | for (const auto *C : D->clauselists()) |
497 | 0 | Visit(C); |
498 | 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*) |
499 | | |
500 | 104 | void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) { |
501 | 104 | Visit(D->getInit()); |
502 | 104 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPCapturedExprDecl(clang::OMPCapturedExprDecl const*) Line | Count | Source | 500 | 104 | void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) { | 501 | 104 | Visit(D->getInit()); | 502 | 104 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPCapturedExprDecl(clang::OMPCapturedExprDecl const*) |
503 | | |
504 | 8 | void VisitOMPAllocateDecl(const OMPAllocateDecl *D) { |
505 | 8 | for (const auto *E : D->varlists()) |
506 | 8 | Visit(E); |
507 | 8 | for (const auto *C : D->clauselists()) |
508 | 12 | Visit(C); |
509 | 8 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPAllocateDecl(clang::OMPAllocateDecl const*) Line | Count | Source | 504 | 8 | void VisitOMPAllocateDecl(const OMPAllocateDecl *D) { | 505 | 8 | for (const auto *E : D->varlists()) | 506 | 8 | Visit(E); | 507 | 8 | for (const auto *C : D->clauselists()) | 508 | 12 | Visit(C); | 509 | 8 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPAllocateDecl(clang::OMPAllocateDecl const*) |
510 | | |
511 | | template <typename SpecializationDecl> |
512 | | void dumpTemplateDeclSpecialization(const SpecializationDecl *D) { |
513 | | for (const auto *RedeclWithBadType : D->redecls()) { |
514 | | // FIXME: The redecls() range sometimes has elements of a less-specific |
515 | | // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives |
516 | | // us TagDecls, and should give CXXRecordDecls). |
517 | | auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType); |
518 | | if (!Redecl) { |
519 | | // Found the injected-class-name for a class template. This will be |
520 | | // dumped as part of its surrounding class so we don't need to dump it |
521 | | // here. |
522 | | assert(isa<CXXRecordDecl>(RedeclWithBadType) && |
523 | | "expected an injected-class-name"); |
524 | | continue; |
525 | | } |
526 | | Visit(Redecl); |
527 | | } |
528 | | } |
529 | | |
530 | | template <typename TemplateDecl> |
531 | | void dumpTemplateDecl(const TemplateDecl *D) { |
532 | | dumpTemplateParameters(D->getTemplateParameters()); |
533 | | |
534 | | Visit(D->getTemplatedDecl()); |
535 | | |
536 | | if (Traversal == TK_AsIs) { |
537 | | for (const auto *Child : D->specializations()) |
538 | | dumpTemplateDeclSpecialization(Child); |
539 | | } |
540 | | } |
541 | | |
542 | 143 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { |
543 | 143 | Visit(D->getUnderlyingType()); |
544 | 143 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeAliasDecl(clang::TypeAliasDecl const*) Line | Count | Source | 542 | 138 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { | 543 | 138 | Visit(D->getUnderlyingType()); | 544 | 138 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeAliasDecl(clang::TypeAliasDecl const*) Line | Count | Source | 542 | 5 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { | 543 | 5 | Visit(D->getUnderlyingType()); | 544 | 5 | } |
|
545 | | |
546 | 43 | void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) { |
547 | 43 | dumpTemplateParameters(D->getTemplateParameters()); |
548 | 43 | Visit(D->getTemplatedDecl()); |
549 | 43 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl const*) Line | Count | Source | 546 | 43 | void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) { | 547 | 43 | dumpTemplateParameters(D->getTemplateParameters()); | 548 | 43 | Visit(D->getTemplatedDecl()); | 549 | 43 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl const*) |
550 | | |
551 | 48 | void VisitStaticAssertDecl(const StaticAssertDecl *D) { |
552 | 48 | Visit(D->getAssertExpr()); |
553 | 48 | Visit(D->getMessage()); |
554 | 48 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitStaticAssertDecl(clang::StaticAssertDecl const*) Line | Count | Source | 551 | 47 | void VisitStaticAssertDecl(const StaticAssertDecl *D) { | 552 | 47 | Visit(D->getAssertExpr()); | 553 | 47 | Visit(D->getMessage()); | 554 | 47 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitStaticAssertDecl(clang::StaticAssertDecl const*) Line | Count | Source | 551 | 1 | void VisitStaticAssertDecl(const StaticAssertDecl *D) { | 552 | 1 | Visit(D->getAssertExpr()); | 553 | 1 | Visit(D->getMessage()); | 554 | 1 | } |
|
555 | | |
556 | | void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) { |
557 | | dumpTemplateDecl(D); |
558 | | } |
559 | | |
560 | | void VisitClassTemplateDecl(const ClassTemplateDecl *D) { |
561 | | dumpTemplateDecl(D); |
562 | | } |
563 | | |
564 | | void VisitClassTemplateSpecializationDecl( |
565 | 234 | const ClassTemplateSpecializationDecl *D) { |
566 | 234 | dumpTemplateArgumentList(D->getTemplateArgs()); |
567 | 234 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassTemplateSpecializationDecl(clang::ClassTemplateSpecializationDecl const*) Line | Count | Source | 565 | 207 | const ClassTemplateSpecializationDecl *D) { | 566 | 207 | dumpTemplateArgumentList(D->getTemplateArgs()); | 567 | 207 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassTemplateSpecializationDecl(clang::ClassTemplateSpecializationDecl const*) Line | Count | Source | 565 | 27 | const ClassTemplateSpecializationDecl *D) { | 566 | 27 | dumpTemplateArgumentList(D->getTemplateArgs()); | 567 | 27 | } |
|
568 | | |
569 | | void VisitClassTemplatePartialSpecializationDecl( |
570 | 26 | const ClassTemplatePartialSpecializationDecl *D) { |
571 | 26 | VisitClassTemplateSpecializationDecl(D); |
572 | 26 | dumpTemplateParameters(D->getTemplateParameters()); |
573 | 26 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplatePartialSpecializationDecl const*) Line | Count | Source | 570 | 24 | const ClassTemplatePartialSpecializationDecl *D) { | 571 | 24 | VisitClassTemplateSpecializationDecl(D); | 572 | 24 | dumpTemplateParameters(D->getTemplateParameters()); | 573 | 24 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplatePartialSpecializationDecl const*) Line | Count | Source | 570 | 2 | const ClassTemplatePartialSpecializationDecl *D) { | 571 | 2 | VisitClassTemplateSpecializationDecl(D); | 572 | 2 | dumpTemplateParameters(D->getTemplateParameters()); | 573 | 2 | } |
|
574 | | |
575 | | void VisitClassScopeFunctionSpecializationDecl( |
576 | 1 | const ClassScopeFunctionSpecializationDecl *D) { |
577 | 1 | Visit(D->getSpecialization()); |
578 | 1 | dumpASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten()); |
579 | 1 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassScopeFunctionSpecializationDecl(clang::ClassScopeFunctionSpecializationDecl const*) Line | Count | Source | 576 | 1 | const ClassScopeFunctionSpecializationDecl *D) { | 577 | 1 | Visit(D->getSpecialization()); | 578 | 1 | dumpASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten()); | 579 | 1 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassScopeFunctionSpecializationDecl(clang::ClassScopeFunctionSpecializationDecl const*) |
580 | | void VisitVarTemplateDecl(const VarTemplateDecl *D) { dumpTemplateDecl(D); } |
581 | | |
582 | 4 | void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) { |
583 | 4 | dumpTemplateParameters(D->getTemplateParameters()); |
584 | 4 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBuiltinTemplateDecl(clang::BuiltinTemplateDecl const*) Line | Count | Source | 582 | 4 | void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) { | 583 | 4 | dumpTemplateParameters(D->getTemplateParameters()); | 584 | 4 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBuiltinTemplateDecl(clang::BuiltinTemplateDecl const*) |
585 | | |
586 | | void |
587 | 6 | VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) { |
588 | 6 | dumpTemplateArgumentList(D->getTemplateArgs()); |
589 | 6 | VisitVarDecl(D); |
590 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVarTemplateSpecializationDecl(clang::VarTemplateSpecializationDecl const*) Line | Count | Source | 587 | 6 | VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) { | 588 | 6 | dumpTemplateArgumentList(D->getTemplateArgs()); | 589 | 6 | VisitVarDecl(D); | 590 | 6 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVarTemplateSpecializationDecl(clang::VarTemplateSpecializationDecl const*) |
591 | | |
592 | | void VisitVarTemplatePartialSpecializationDecl( |
593 | 0 | const VarTemplatePartialSpecializationDecl *D) { |
594 | 0 | dumpTemplateParameters(D->getTemplateParameters()); |
595 | 0 | VisitVarTemplateSpecializationDecl(D); |
596 | 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*) |
597 | | |
598 | 681 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { |
599 | 681 | if (const auto *TC = D->getTypeConstraint()) |
600 | 14 | Visit(TC->getImmediatelyDeclaredConstraint()); |
601 | 681 | if (D->hasDefaultArgument()) |
602 | 43 | Visit(D->getDefaultArgument(), SourceRange(), |
603 | 43 | D->getDefaultArgStorage().getInheritedFrom(), |
604 | 43 | D->defaultArgumentWasInherited() ? "inherited from"7 : "previous"36 ); |
605 | 681 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateTypeParmDecl(clang::TemplateTypeParmDecl const*) Line | Count | Source | 598 | 633 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { | 599 | 633 | if (const auto *TC = D->getTypeConstraint()) | 600 | 12 | Visit(TC->getImmediatelyDeclaredConstraint()); | 601 | 633 | if (D->hasDefaultArgument()) | 602 | 41 | Visit(D->getDefaultArgument(), SourceRange(), | 603 | 41 | D->getDefaultArgStorage().getInheritedFrom(), | 604 | 41 | D->defaultArgumentWasInherited() ? "inherited from"7 : "previous"34 ); | 605 | 633 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTemplateTypeParmDecl(clang::TemplateTypeParmDecl const*) Line | Count | Source | 598 | 48 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { | 599 | 48 | if (const auto *TC = D->getTypeConstraint()) | 600 | 2 | Visit(TC->getImmediatelyDeclaredConstraint()); | 601 | 48 | if (D->hasDefaultArgument()) | 602 | 2 | Visit(D->getDefaultArgument(), SourceRange(), | 603 | 2 | D->getDefaultArgStorage().getInheritedFrom(), | 604 | 2 | D->defaultArgumentWasInherited() ? "inherited from"0 : "previous"); | 605 | 48 | } |
|
606 | | |
607 | 297 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { |
608 | 297 | if (const auto *E = D->getPlaceholderTypeConstraint()) |
609 | 0 | Visit(E); |
610 | 297 | if (D->hasDefaultArgument()) |
611 | 37 | Visit(D->getDefaultArgument(), SourceRange(), |
612 | 37 | D->getDefaultArgStorage().getInheritedFrom(), |
613 | 37 | D->defaultArgumentWasInherited() ? "inherited from"4 : "previous"33 ); |
614 | 297 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitNonTypeTemplateParmDecl(clang::NonTypeTemplateParmDecl const*) Line | Count | Source | 607 | 239 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { | 608 | 239 | if (const auto *E = D->getPlaceholderTypeConstraint()) | 609 | 0 | Visit(E); | 610 | 239 | if (D->hasDefaultArgument()) | 611 | 37 | Visit(D->getDefaultArgument(), SourceRange(), | 612 | 37 | D->getDefaultArgStorage().getInheritedFrom(), | 613 | 37 | D->defaultArgumentWasInherited() ? "inherited from"4 : "previous"33 ); | 614 | 239 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitNonTypeTemplateParmDecl(clang::NonTypeTemplateParmDecl const*) Line | Count | Source | 607 | 58 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { | 608 | 58 | if (const auto *E = D->getPlaceholderTypeConstraint()) | 609 | 0 | Visit(E); | 610 | 58 | if (D->hasDefaultArgument()) | 611 | 0 | Visit(D->getDefaultArgument(), SourceRange(), | 612 | 0 | D->getDefaultArgStorage().getInheritedFrom(), | 613 | 0 | D->defaultArgumentWasInherited() ? "inherited from" : "previous"); | 614 | 58 | } |
|
615 | | |
616 | 18 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { |
617 | 18 | dumpTemplateParameters(D->getTemplateParameters()); |
618 | 18 | if (D->hasDefaultArgument()) |
619 | 4 | dumpTemplateArgumentLoc( |
620 | 4 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), |
621 | 4 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"3 ); |
622 | 18 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl const*) Line | Count | Source | 616 | 16 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { | 617 | 16 | dumpTemplateParameters(D->getTemplateParameters()); | 618 | 16 | if (D->hasDefaultArgument()) | 619 | 3 | dumpTemplateArgumentLoc( | 620 | 3 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), | 621 | 3 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"2 ); | 622 | 16 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl const*) Line | Count | Source | 616 | 2 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { | 617 | 2 | dumpTemplateParameters(D->getTemplateParameters()); | 618 | 2 | if (D->hasDefaultArgument()) | 619 | 1 | dumpTemplateArgumentLoc( | 620 | 1 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), | 621 | 1 | D->defaultArgumentWasInherited() ? "inherited from"0 : "previous"); | 622 | 2 | } |
|
623 | | |
624 | 6 | void VisitConceptDecl(const ConceptDecl *D) { |
625 | 6 | dumpTemplateParameters(D->getTemplateParameters()); |
626 | 6 | Visit(D->getConstraintExpr()); |
627 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitConceptDecl(clang::ConceptDecl const*) Line | Count | Source | 624 | 4 | void VisitConceptDecl(const ConceptDecl *D) { | 625 | 4 | dumpTemplateParameters(D->getTemplateParameters()); | 626 | 4 | Visit(D->getConstraintExpr()); | 627 | 4 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitConceptDecl(clang::ConceptDecl const*) Line | Count | Source | 624 | 2 | void VisitConceptDecl(const ConceptDecl *D) { | 625 | 2 | dumpTemplateParameters(D->getTemplateParameters()); | 626 | 2 | Visit(D->getConstraintExpr()); | 627 | 2 | } |
|
628 | | |
629 | 24 | void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *CSE) { |
630 | 24 | if (CSE->hasExplicitTemplateArgs()) |
631 | 24 | for (const auto &ArgLoc : CSE->getTemplateArgsAsWritten()->arguments()) |
632 | 28 | dumpTemplateArgumentLoc(ArgLoc); |
633 | 24 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitConceptSpecializationExpr(clang::ConceptSpecializationExpr const*) Line | Count | Source | 629 | 4 | void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *CSE) { | 630 | 4 | if (CSE->hasExplicitTemplateArgs()) | 631 | 4 | for (const auto &ArgLoc : CSE->getTemplateArgsAsWritten()->arguments()) | 632 | 4 | dumpTemplateArgumentLoc(ArgLoc); | 633 | 4 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitConceptSpecializationExpr(clang::ConceptSpecializationExpr const*) Line | Count | Source | 629 | 20 | void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *CSE) { | 630 | 20 | if (CSE->hasExplicitTemplateArgs()) | 631 | 20 | for (const auto &ArgLoc : CSE->getTemplateArgsAsWritten()->arguments()) | 632 | 24 | dumpTemplateArgumentLoc(ArgLoc); | 633 | 20 | } |
|
634 | | |
635 | 84 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { |
636 | 84 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) |
637 | 2 | Visit(TD->getTypeForDecl()); |
638 | 84 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitUsingShadowDecl(clang::UsingShadowDecl const*) Line | Count | Source | 635 | 80 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { | 636 | 80 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) | 637 | 1 | Visit(TD->getTypeForDecl()); | 638 | 80 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitUsingShadowDecl(clang::UsingShadowDecl const*) Line | Count | Source | 635 | 4 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { | 636 | 4 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) | 637 | 1 | Visit(TD->getTypeForDecl()); | 638 | 4 | } |
|
639 | | |
640 | 12 | void VisitFriendDecl(const FriendDecl *D) { |
641 | 12 | if (!D->getFriendType()) |
642 | 7 | Visit(D->getFriendDecl()); |
643 | 12 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFriendDecl(clang::FriendDecl const*) Line | Count | Source | 640 | 10 | void VisitFriendDecl(const FriendDecl *D) { | 641 | 10 | if (!D->getFriendType()) | 642 | 6 | Visit(D->getFriendDecl()); | 643 | 10 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFriendDecl(clang::FriendDecl const*) Line | Count | Source | 640 | 2 | void VisitFriendDecl(const FriendDecl *D) { | 641 | 2 | if (!D->getFriendType()) | 642 | 1 | Visit(D->getFriendDecl()); | 643 | 2 | } |
|
644 | | |
645 | 193 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { |
646 | 193 | if (D->isThisDeclarationADefinition()) |
647 | 35 | dumpDeclContext(D); |
648 | 158 | else |
649 | 158 | for (const ParmVarDecl *Parameter : D->parameters()) |
650 | 59 | Visit(Parameter); |
651 | | |
652 | 193 | if (D->hasBody()) |
653 | 35 | Visit(D->getBody()); |
654 | 193 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCMethodDecl(clang::ObjCMethodDecl const*) Line | Count | Source | 645 | 178 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { | 646 | 178 | if (D->isThisDeclarationADefinition()) | 647 | 32 | dumpDeclContext(D); | 648 | 146 | else | 649 | 146 | for (const ParmVarDecl *Parameter : D->parameters()) | 650 | 54 | Visit(Parameter); | 651 | | | 652 | 178 | if (D->hasBody()) | 653 | 32 | Visit(D->getBody()); | 654 | 178 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCMethodDecl(clang::ObjCMethodDecl const*) Line | Count | Source | 645 | 15 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { | 646 | 15 | if (D->isThisDeclarationADefinition()) | 647 | 3 | dumpDeclContext(D); | 648 | 12 | else | 649 | 12 | for (const ParmVarDecl *Parameter : D->parameters()) | 650 | 5 | Visit(Parameter); | 651 | | | 652 | 15 | if (D->hasBody()) | 653 | 3 | Visit(D->getBody()); | 654 | 15 | } |
|
655 | | |
656 | 20 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { |
657 | 20 | dumpObjCTypeParamList(D->getTypeParamList()); |
658 | 20 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCCategoryDecl(clang::ObjCCategoryDecl const*) Line | Count | Source | 656 | 19 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { | 657 | 19 | dumpObjCTypeParamList(D->getTypeParamList()); | 658 | 19 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCCategoryDecl(clang::ObjCCategoryDecl const*) Line | Count | Source | 656 | 1 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { | 657 | 1 | dumpObjCTypeParamList(D->getTypeParamList()); | 658 | 1 | } |
|
659 | | |
660 | 109 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { |
661 | 109 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); |
662 | 109 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCInterfaceDecl(clang::ObjCInterfaceDecl const*) Line | Count | Source | 660 | 105 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { | 661 | 105 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); | 662 | 105 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCInterfaceDecl(clang::ObjCInterfaceDecl const*) Line | Count | Source | 660 | 4 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { | 661 | 4 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); | 662 | 4 | } |
|
663 | | |
664 | 28 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { |
665 | 28 | for (const auto &I : D->inits()) |
666 | 3 | Visit(I); |
667 | 28 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCImplementationDecl(clang::ObjCImplementationDecl const*) Line | Count | Source | 664 | 25 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { | 665 | 25 | for (const auto &I : D->inits()) | 666 | 3 | Visit(I); | 667 | 25 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCImplementationDecl(clang::ObjCImplementationDecl const*) Line | Count | Source | 664 | 3 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { | 665 | 3 | for (const auto &I : D->inits()) | 666 | 0 | Visit(I); | 667 | 3 | } |
|
668 | | |
669 | 24 | void VisitBlockDecl(const BlockDecl *D) { |
670 | 24 | for (const auto &I : D->parameters()) |
671 | 3 | Visit(I); |
672 | | |
673 | 24 | for (const auto &I : D->captures()) |
674 | 11 | Visit(I); |
675 | 24 | Visit(D->getBody()); |
676 | 24 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBlockDecl(clang::BlockDecl const*) Line | Count | Source | 669 | 21 | void VisitBlockDecl(const BlockDecl *D) { | 670 | 21 | for (const auto &I : D->parameters()) | 671 | 2 | Visit(I); | 672 | | | 673 | 21 | for (const auto &I : D->captures()) | 674 | 8 | Visit(I); | 675 | 21 | Visit(D->getBody()); | 676 | 21 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBlockDecl(clang::BlockDecl const*) Line | Count | Source | 669 | 3 | void VisitBlockDecl(const BlockDecl *D) { | 670 | 3 | for (const auto &I : D->parameters()) | 671 | 1 | Visit(I); | 672 | | | 673 | 3 | for (const auto &I : D->captures()) | 674 | 3 | Visit(I); | 675 | 3 | Visit(D->getBody()); | 676 | 3 | } |
|
677 | | |
678 | 2.10k | void VisitDeclStmt(const DeclStmt *Node) { |
679 | 2.10k | for (const auto &D : Node->decls()) |
680 | 2.18k | Visit(D); |
681 | 2.10k | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDeclStmt(clang::DeclStmt const*) Line | Count | Source | 678 | 92 | void VisitDeclStmt(const DeclStmt *Node) { | 679 | 92 | for (const auto &D : Node->decls()) | 680 | 104 | Visit(D); | 681 | 92 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDeclStmt(clang::DeclStmt const*) Line | Count | Source | 678 | 2.01k | void VisitDeclStmt(const DeclStmt *Node) { | 679 | 2.01k | for (const auto &D : Node->decls()) | 680 | 2.07k | Visit(D); | 681 | 2.01k | } |
|
682 | | |
683 | 16 | void VisitAttributedStmt(const AttributedStmt *Node) { |
684 | 16 | for (const auto *A : Node->getAttrs()) |
685 | 20 | Visit(A); |
686 | 16 | } 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 | 683 | 16 | void VisitAttributedStmt(const AttributedStmt *Node) { | 684 | 16 | for (const auto *A : Node->getAttrs()) | 685 | 20 | Visit(A); | 686 | 16 | } |
|
687 | | |
688 | 12 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { |
689 | 12 | Visit(Node->getExceptionDecl()); |
690 | 12 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCXXCatchStmt(clang::CXXCatchStmt const*) Line | Count | Source | 688 | 2 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { | 689 | 2 | Visit(Node->getExceptionDecl()); | 690 | 2 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCXXCatchStmt(clang::CXXCatchStmt const*) Line | Count | Source | 688 | 10 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { | 689 | 10 | Visit(Node->getExceptionDecl()); | 690 | 10 | } |
|
691 | | |
692 | 564 | void VisitCapturedStmt(const CapturedStmt *Node) { |
693 | 564 | Visit(Node->getCapturedDecl()); |
694 | 564 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCapturedStmt(clang::CapturedStmt const*) Line | Count | Source | 692 | 17 | void VisitCapturedStmt(const CapturedStmt *Node) { | 693 | 17 | Visit(Node->getCapturedDecl()); | 694 | 17 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCapturedStmt(clang::CapturedStmt const*) Line | Count | Source | 692 | 547 | void VisitCapturedStmt(const CapturedStmt *Node) { | 693 | 547 | Visit(Node->getCapturedDecl()); | 694 | 547 | } |
|
695 | | |
696 | 429 | void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) { |
697 | 429 | for (const auto *C : Node->clauses()) |
698 | 410 | Visit(C); |
699 | 429 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPExecutableDirective(clang::OMPExecutableDirective const*) Line | Count | Source | 696 | 12 | void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) { | 697 | 12 | for (const auto *C : Node->clauses()) | 698 | 2 | Visit(C); | 699 | 12 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPExecutableDirective(clang::OMPExecutableDirective const*) Line | Count | Source | 696 | 417 | void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) { | 697 | 417 | for (const auto *C : Node->clauses()) | 698 | 408 | Visit(C); | 699 | 417 | } |
|
700 | | |
701 | 322 | void VisitInitListExpr(const InitListExpr *ILE) { |
702 | 322 | if (auto *Filler = ILE->getArrayFiller()) { |
703 | 26 | Visit(Filler, "array_filler"); |
704 | 26 | } |
705 | 322 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitInitListExpr(clang::InitListExpr const*) Line | Count | Source | 701 | 10 | void VisitInitListExpr(const InitListExpr *ILE) { | 702 | 10 | if (auto *Filler = ILE->getArrayFiller()) { | 703 | 1 | Visit(Filler, "array_filler"); | 704 | 1 | } | 705 | 10 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitInitListExpr(clang::InitListExpr const*) Line | Count | Source | 701 | 312 | void VisitInitListExpr(const InitListExpr *ILE) { | 702 | 312 | if (auto *Filler = ILE->getArrayFiller()) { | 703 | 25 | Visit(Filler, "array_filler"); | 704 | 25 | } | 705 | 312 | } |
|
706 | | |
707 | 24 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBlockExpr(clang::BlockExpr const*) Line | Count | Source | 707 | 3 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBlockExpr(clang::BlockExpr const*) Line | Count | Source | 707 | 21 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } |
|
708 | | |
709 | 176 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { |
710 | 176 | if (Expr *Source = Node->getSourceExpr()) |
711 | 176 | Visit(Source); |
712 | 176 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOpaqueValueExpr(clang::OpaqueValueExpr const*) Line | Count | Source | 709 | 52 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { | 710 | 52 | if (Expr *Source = Node->getSourceExpr()) | 711 | 52 | Visit(Source); | 712 | 52 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOpaqueValueExpr(clang::OpaqueValueExpr const*) Line | Count | Source | 709 | 124 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { | 710 | 124 | if (Expr *Source = Node->getSourceExpr()) | 711 | 124 | Visit(Source); | 712 | 124 | } |
|
713 | | |
714 | 21 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { |
715 | 21 | Visit(E->getControllingExpr()); |
716 | 21 | Visit(E->getControllingExpr()->getType()); // FIXME: remove |
717 | | |
718 | 38 | for (const auto Assoc : E->associations()) { |
719 | 38 | Visit(Assoc); |
720 | 38 | } |
721 | 21 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitGenericSelectionExpr(clang::GenericSelectionExpr const*) Line | Count | Source | 714 | 7 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { | 715 | 7 | Visit(E->getControllingExpr()); | 716 | 7 | Visit(E->getControllingExpr()->getType()); // FIXME: remove | 717 | | | 718 | 12 | for (const auto Assoc : E->associations()) { | 719 | 12 | Visit(Assoc); | 720 | 12 | } | 721 | 7 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitGenericSelectionExpr(clang::GenericSelectionExpr const*) Line | Count | Source | 714 | 14 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { | 715 | 14 | Visit(E->getControllingExpr()); | 716 | 14 | Visit(E->getControllingExpr()->getType()); // FIXME: remove | 717 | | | 718 | 26 | for (const auto Assoc : E->associations()) { | 719 | 26 | Visit(Assoc); | 720 | 26 | } | 721 | 14 | } |
|
722 | | |
723 | 3 | void VisitRequiresExpr(const RequiresExpr *E) { |
724 | 3 | for (auto *D : E->getLocalParameters()) |
725 | 3 | Visit(D); |
726 | 3 | for (auto *R : E->getRequirements()) |
727 | 12 | Visit(R); |
728 | 3 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitRequiresExpr(clang::RequiresExpr const*) Line | Count | Source | 723 | 1 | void VisitRequiresExpr(const RequiresExpr *E) { | 724 | 1 | for (auto *D : E->getLocalParameters()) | 725 | 1 | Visit(D); | 726 | 1 | for (auto *R : E->getRequirements()) | 727 | 4 | Visit(R); | 728 | 1 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitRequiresExpr(clang::RequiresExpr const*) Line | Count | Source | 723 | 2 | void VisitRequiresExpr(const RequiresExpr *E) { | 724 | 2 | for (auto *D : E->getLocalParameters()) | 725 | 2 | Visit(D); | 726 | 2 | for (auto *R : E->getRequirements()) | 727 | 8 | Visit(R); | 728 | 2 | } |
|
729 | | |
730 | 162 | void VisitLambdaExpr(const LambdaExpr *Node) { |
731 | 162 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { |
732 | 0 | for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) { |
733 | 0 | const auto *C = Node->capture_begin() + I; |
734 | 0 | if (!C->isExplicit()) |
735 | 0 | continue; |
736 | 0 | if (Node->isInitCapture(C)) |
737 | 0 | Visit(C->getCapturedVar()); |
738 | 0 | else |
739 | 0 | Visit(Node->capture_init_begin()[I]); |
740 | 0 | } |
741 | 0 | dumpTemplateParameters(Node->getTemplateParameterList()); |
742 | 0 | for (const auto *P : Node->getCallOperator()->parameters()) |
743 | 0 | Visit(P); |
744 | 0 | Visit(Node->getBody()); |
745 | 162 | } else { |
746 | 162 | return Visit(Node->getLambdaClass()); |
747 | 162 | } |
748 | 162 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitLambdaExpr(clang::LambdaExpr const*) Line | Count | Source | 730 | 17 | void VisitLambdaExpr(const LambdaExpr *Node) { | 731 | 17 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { | 732 | 0 | for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) { | 733 | 0 | const auto *C = Node->capture_begin() + I; | 734 | 0 | if (!C->isExplicit()) | 735 | 0 | continue; | 736 | 0 | if (Node->isInitCapture(C)) | 737 | 0 | Visit(C->getCapturedVar()); | 738 | 0 | else | 739 | 0 | Visit(Node->capture_init_begin()[I]); | 740 | 0 | } | 741 | 0 | dumpTemplateParameters(Node->getTemplateParameterList()); | 742 | 0 | for (const auto *P : Node->getCallOperator()->parameters()) | 743 | 0 | Visit(P); | 744 | 0 | Visit(Node->getBody()); | 745 | 17 | } else { | 746 | 17 | return Visit(Node->getLambdaClass()); | 747 | 17 | } | 748 | 17 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitLambdaExpr(clang::LambdaExpr const*) Line | Count | Source | 730 | 145 | void VisitLambdaExpr(const LambdaExpr *Node) { | 731 | 145 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { | 732 | 0 | for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) { | 733 | 0 | const auto *C = Node->capture_begin() + I; | 734 | 0 | if (!C->isExplicit()) | 735 | 0 | continue; | 736 | 0 | if (Node->isInitCapture(C)) | 737 | 0 | Visit(C->getCapturedVar()); | 738 | 0 | else | 739 | 0 | Visit(Node->capture_init_begin()[I]); | 740 | 0 | } | 741 | 0 | dumpTemplateParameters(Node->getTemplateParameterList()); | 742 | 0 | for (const auto *P : Node->getCallOperator()->parameters()) | 743 | 0 | Visit(P); | 744 | 0 | Visit(Node->getBody()); | 745 | 145 | } else { | 746 | 145 | return Visit(Node->getLambdaClass()); | 747 | 145 | } | 748 | 145 | } |
|
749 | | |
750 | 13 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { |
751 | 13 | if (Node->isPartiallySubstituted()) |
752 | 0 | for (const auto &A : Node->getPartialArguments()) |
753 | 0 | Visit(A); |
754 | 13 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSizeOfPackExpr(clang::SizeOfPackExpr const*) Line | Count | Source | 750 | 1 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { | 751 | 1 | if (Node->isPartiallySubstituted()) | 752 | 0 | for (const auto &A : Node->getPartialArguments()) | 753 | 0 | Visit(A); | 754 | 1 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSizeOfPackExpr(clang::SizeOfPackExpr const*) Line | Count | Source | 750 | 12 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { | 751 | 12 | if (Node->isPartiallySubstituted()) | 752 | 0 | for (const auto &A : Node->getPartialArguments()) | 753 | 0 | Visit(A); | 754 | 12 | } |
|
755 | | |
756 | 118 | void VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E) { |
757 | 118 | Visit(E->getParameter()); |
758 | 118 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstNonTypeTemplateParmExpr(clang::SubstNonTypeTemplateParmExpr const*) Line | Count | Source | 756 | 50 | void VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E) { | 757 | 50 | Visit(E->getParameter()); | 758 | 50 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstNonTypeTemplateParmExpr(clang::SubstNonTypeTemplateParmExpr const*) Line | Count | Source | 756 | 68 | void VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E) { | 757 | 68 | Visit(E->getParameter()); | 758 | 68 | } |
|
759 | | void VisitSubstNonTypeTemplateParmPackExpr( |
760 | 1 | const SubstNonTypeTemplateParmPackExpr *E) { |
761 | 1 | Visit(E->getParameterPack()); |
762 | 1 | Visit(E->getArgumentPack()); |
763 | 1 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstNonTypeTemplateParmPackExpr(clang::SubstNonTypeTemplateParmPackExpr const*) clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstNonTypeTemplateParmPackExpr(clang::SubstNonTypeTemplateParmPackExpr const*) Line | Count | Source | 760 | 1 | const SubstNonTypeTemplateParmPackExpr *E) { | 761 | 1 | Visit(E->getParameterPack()); | 762 | 1 | Visit(E->getArgumentPack()); | 763 | 1 | } |
|
764 | | |
765 | 11 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { |
766 | 11 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) |
767 | 8 | Visit(CatchParam); |
768 | 11 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCAtCatchStmt(clang::ObjCAtCatchStmt const*) Line | Count | Source | 765 | 2 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { | 766 | 2 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) | 767 | 1 | Visit(CatchParam); | 768 | 2 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCAtCatchStmt(clang::ObjCAtCatchStmt const*) Line | Count | Source | 765 | 9 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { | 766 | 9 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) | 767 | 7 | Visit(CatchParam); | 768 | 9 | } |
|
769 | | |
770 | 14 | void VisitCXXForRangeStmt(const CXXForRangeStmt *Node) { |
771 | 14 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { |
772 | 0 | Visit(Node->getInit()); |
773 | 0 | Visit(Node->getLoopVariable()); |
774 | 0 | Visit(Node->getRangeInit()); |
775 | 0 | Visit(Node->getBody()); |
776 | 0 | } |
777 | 14 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCXXForRangeStmt(clang::CXXForRangeStmt const*) Line | Count | Source | 770 | 3 | void VisitCXXForRangeStmt(const CXXForRangeStmt *Node) { | 771 | 3 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { | 772 | 0 | Visit(Node->getInit()); | 773 | 0 | Visit(Node->getLoopVariable()); | 774 | 0 | Visit(Node->getRangeInit()); | 775 | 0 | Visit(Node->getBody()); | 776 | 0 | } | 777 | 3 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCXXForRangeStmt(clang::CXXForRangeStmt const*) Line | Count | Source | 770 | 11 | void VisitCXXForRangeStmt(const CXXForRangeStmt *Node) { | 771 | 11 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { | 772 | 0 | Visit(Node->getInit()); | 773 | 0 | Visit(Node->getLoopVariable()); | 774 | 0 | Visit(Node->getRangeInit()); | 775 | 0 | Visit(Node->getBody()); | 776 | 0 | } | 777 | 11 | } |
|
778 | | |
779 | 1.31k | void VisitCallExpr(const CallExpr *Node) { |
780 | 1.31k | for (const auto *Child : |
781 | 2.02k | make_filter_range(Node->children(), [this](const Stmt *Child) { |
782 | 2.02k | if (Traversal != TK_IgnoreUnlessSpelledInSource) |
783 | 2.02k | return false; |
784 | 0 | return !isa<CXXDefaultArgExpr>(Child); |
785 | 2.02k | })) { clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCallExpr(clang::CallExpr const*)::'lambda'(clang::Stmt const*)::operator()(clang::Stmt const*) const Line | Count | Source | 781 | 86 | make_filter_range(Node->children(), [this](const Stmt *Child) { | 782 | 86 | if (Traversal != TK_IgnoreUnlessSpelledInSource) | 783 | 86 | return false; | 784 | 0 | return !isa<CXXDefaultArgExpr>(Child); | 785 | 86 | })) { |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCallExpr(clang::CallExpr const*)::'lambda'(clang::Stmt const*)::operator()(clang::Stmt const*) const Line | Count | Source | 781 | 1.94k | make_filter_range(Node->children(), [this](const Stmt *Child) { | 782 | 1.94k | if (Traversal != TK_IgnoreUnlessSpelledInSource) | 783 | 1.94k | return false; | 784 | 0 | return !isa<CXXDefaultArgExpr>(Child); | 785 | 1.94k | })) { |
|
786 | 0 | Visit(Child); |
787 | 0 | } |
788 | 1.31k | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCallExpr(clang::CallExpr const*) Line | Count | Source | 779 | 56 | void VisitCallExpr(const CallExpr *Node) { | 780 | 56 | for (const auto *Child : | 781 | 56 | make_filter_range(Node->children(), [this](const Stmt *Child) { | 782 | 56 | if (Traversal != TK_IgnoreUnlessSpelledInSource) | 783 | 56 | return false; | 784 | 56 | return !isa<CXXDefaultArgExpr>(Child); | 785 | 56 | })) { | 786 | 0 | Visit(Child); | 787 | 0 | } | 788 | 56 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCallExpr(clang::CallExpr const*) Line | Count | Source | 779 | 1.25k | void VisitCallExpr(const CallExpr *Node) { | 780 | 1.25k | for (const auto *Child : | 781 | 1.25k | make_filter_range(Node->children(), [this](const Stmt *Child) { | 782 | 1.25k | if (Traversal != TK_IgnoreUnlessSpelledInSource) | 783 | 1.25k | return false; | 784 | 1.25k | return !isa<CXXDefaultArgExpr>(Child); | 785 | 1.25k | })) { | 786 | 0 | Visit(Child); | 787 | 0 | } | 788 | 1.25k | } |
|
789 | | |
790 | 0 | void VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *Node) { |
791 | 0 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { |
792 | 0 | Visit(Node->getLHS()); |
793 | 0 | Visit(Node->getRHS()); |
794 | 0 | } else { |
795 | 0 | ConstStmtVisitor<Derived>::VisitCXXRewrittenBinaryOperator(Node); |
796 | 0 | } |
797 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCXXRewrittenBinaryOperator(clang::CXXRewrittenBinaryOperator const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCXXRewrittenBinaryOperator(clang::CXXRewrittenBinaryOperator const*) |
798 | | |
799 | 71 | void VisitExpressionTemplateArgument(const TemplateArgument &TA) { |
800 | 71 | Visit(TA.getAsExpr()); |
801 | 71 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitExpressionTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 799 | 71 | void VisitExpressionTemplateArgument(const TemplateArgument &TA) { | 800 | 71 | Visit(TA.getAsExpr()); | 801 | 71 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitExpressionTemplateArgument(clang::TemplateArgument const&) |
802 | | |
803 | 590 | void VisitTypeTemplateArgument(const TemplateArgument &TA) { |
804 | 590 | Visit(TA.getAsType()); |
805 | 590 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 803 | 565 | void VisitTypeTemplateArgument(const TemplateArgument &TA) { | 804 | 565 | Visit(TA.getAsType()); | 805 | 565 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 803 | 25 | void VisitTypeTemplateArgument(const TemplateArgument &TA) { | 804 | 25 | Visit(TA.getAsType()); | 805 | 25 | } |
|
806 | | |
807 | 54 | void VisitPackTemplateArgument(const TemplateArgument &TA) { |
808 | 54 | for (const auto &TArg : TA.pack_elements()) |
809 | 113 | Visit(TArg); |
810 | 54 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPackTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 807 | 54 | void VisitPackTemplateArgument(const TemplateArgument &TA) { | 808 | 54 | for (const auto &TArg : TA.pack_elements()) | 809 | 113 | Visit(TArg); | 810 | 54 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPackTemplateArgument(clang::TemplateArgument const&) |
811 | | |
812 | | // Implements Visit methods for Attrs. |
813 | | #include "clang/AST/AttrNodeTraverse.inc" |
814 | | }; |
815 | | |
816 | | } // namespace clang |
817 | | |
818 | | #endif // LLVM_CLANG_AST_ASTNODETRAVERSER_H |