/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 | 150k | NodeDelegateType &getNodeDelegate() { |
77 | 150k | return getDerived().doGetNodeDelegate(); |
78 | 150k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::getNodeDelegate() Line | Count | Source | 76 | 139k | NodeDelegateType &getNodeDelegate() { | 77 | 139k | return getDerived().doGetNodeDelegate(); | 78 | 139k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::getNodeDelegate() Line | Count | Source | 76 | 10.1k | NodeDelegateType &getNodeDelegate() { | 77 | 10.1k | return getDerived().doGetNodeDelegate(); | 78 | 10.1k | } |
|
79 | 150k | Derived &getDerived() { return *static_cast<Derived *>(this); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::getDerived() Line | Count | Source | 79 | 139k | Derived &getDerived() { return *static_cast<Derived *>(this); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::getDerived() Line | Count | Source | 79 | 10.1k | Derived &getDerived() { return *static_cast<Derived *>(this); } |
|
80 | | |
81 | | public: |
82 | 1.66k | void setDeserialize(bool D) { Deserialize = D; } |
83 | 7 | bool getDeserialize() const { return Deserialize; } |
84 | | |
85 | | void SetTraversalKind(TraversalKind TK) { Traversal = TK; } |
86 | 565 | TraversalKind GetTraversalKind() const { return Traversal; } |
87 | | |
88 | 28.0k | void Visit(const Decl *D) { |
89 | 28.0k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isImplicit()0 ) |
90 | 0 | return; |
91 | | |
92 | 28.0k | getNodeDelegate().AddChild([=] { |
93 | 28.0k | getNodeDelegate().Visit(D); |
94 | 28.0k | if (!D) |
95 | 4 | return; |
96 | | |
97 | 28.0k | ConstDeclVisitor<Derived>::Visit(D); |
98 | | |
99 | 28.0k | for (const auto &A : D->attrs()) |
100 | 2.44k | Visit(A); |
101 | | |
102 | 28.0k | if (const comments::FullComment *Comment = |
103 | 28.0k | D->getASTContext().getLocalCommentForDeclUncached(D)) |
104 | 57 | Visit(Comment, Comment); |
105 | | |
106 | | // Decls within functions are visited by the body. |
107 | 28.0k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)22.7k ) { |
108 | 22.5k | 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 | 22.5k | if (const auto *DC = dyn_cast<DeclContext>(D)) |
117 | 5.26k | dumpDeclContext(DC); |
118 | 22.5k | } |
119 | 28.0k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Decl const*)::'lambda'()::operator()() const Line | Count | Source | 92 | 26.1k | getNodeDelegate().AddChild([=] { | 93 | 26.1k | getNodeDelegate().Visit(D); | 94 | 26.1k | if (!D) | 95 | 3 | return; | 96 | | | 97 | 26.1k | ConstDeclVisitor<Derived>::Visit(D); | 98 | | | 99 | 26.1k | for (const auto &A : D->attrs()) | 100 | 2.41k | Visit(A); | 101 | | | 102 | 26.1k | if (const comments::FullComment *Comment = | 103 | 26.1k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 104 | 45 | Visit(Comment, Comment); | 105 | | | 106 | | // Decls within functions are visited by the body. | 107 | 26.1k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)21.3k ) { | 108 | 21.1k | 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.1k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 117 | 4.90k | dumpDeclContext(DC); | 118 | 21.1k | } | 119 | 26.1k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Decl const*)::'lambda'()::operator()() const Line | Count | Source | 92 | 1.88k | getNodeDelegate().AddChild([=] { | 93 | 1.88k | getNodeDelegate().Visit(D); | 94 | 1.88k | if (!D) | 95 | 1 | return; | 96 | | | 97 | 1.88k | ConstDeclVisitor<Derived>::Visit(D); | 98 | | | 99 | 1.88k | for (const auto &A : D->attrs()) | 100 | 34 | Visit(A); | 101 | | | 102 | 1.88k | if (const comments::FullComment *Comment = | 103 | 1.88k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 104 | 12 | Visit(Comment, Comment); | 105 | | | 106 | | // Decls within functions are visited by the body. | 107 | 1.88k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)1.44k ) { | 108 | 1.43k | 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.43k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 117 | 361 | dumpDeclContext(DC); | 118 | 1.43k | } | 119 | 1.88k | }); |
|
120 | 28.0k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Decl const*) Line | Count | Source | 88 | 26.1k | void Visit(const Decl *D) { | 89 | 26.1k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isImplicit()0 ) | 90 | 0 | return; | 91 | | | 92 | 26.1k | getNodeDelegate().AddChild([=] { | 93 | 26.1k | getNodeDelegate().Visit(D); | 94 | 26.1k | if (!D) | 95 | 26.1k | return; | 96 | | | 97 | 26.1k | ConstDeclVisitor<Derived>::Visit(D); | 98 | | | 99 | 26.1k | for (const auto &A : D->attrs()) | 100 | 26.1k | Visit(A); | 101 | | | 102 | 26.1k | if (const comments::FullComment *Comment = | 103 | 26.1k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 104 | 26.1k | Visit(Comment, Comment); | 105 | | | 106 | | // Decls within functions are visited by the body. | 107 | 26.1k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) { | 108 | 26.1k | if (Traversal != TK_AsIs) { | 109 | 26.1k | if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) { | 110 | 26.1k | auto SK = CTSD->getSpecializationKind(); | 111 | 26.1k | if (SK == TSK_ExplicitInstantiationDeclaration || | 112 | 26.1k | SK == TSK_ExplicitInstantiationDefinition) | 113 | 26.1k | return; | 114 | 26.1k | } | 115 | 26.1k | } | 116 | 26.1k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 117 | 26.1k | dumpDeclContext(DC); | 118 | 26.1k | } | 119 | 26.1k | }); | 120 | 26.1k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Decl const*) Line | Count | Source | 88 | 1.88k | void Visit(const Decl *D) { | 89 | 1.88k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isImplicit()0 ) | 90 | 0 | return; | 91 | | | 92 | 1.88k | getNodeDelegate().AddChild([=] { | 93 | 1.88k | getNodeDelegate().Visit(D); | 94 | 1.88k | if (!D) | 95 | 1.88k | return; | 96 | | | 97 | 1.88k | ConstDeclVisitor<Derived>::Visit(D); | 98 | | | 99 | 1.88k | for (const auto &A : D->attrs()) | 100 | 1.88k | Visit(A); | 101 | | | 102 | 1.88k | if (const comments::FullComment *Comment = | 103 | 1.88k | D->getASTContext().getLocalCommentForDeclUncached(D)) | 104 | 1.88k | Visit(Comment, Comment); | 105 | | | 106 | | // Decls within functions are visited by the body. | 107 | 1.88k | if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) { | 108 | 1.88k | if (Traversal != TK_AsIs) { | 109 | 1.88k | if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) { | 110 | 1.88k | auto SK = CTSD->getSpecializationKind(); | 111 | 1.88k | if (SK == TSK_ExplicitInstantiationDeclaration || | 112 | 1.88k | SK == TSK_ExplicitInstantiationDefinition) | 113 | 1.88k | return; | 114 | 1.88k | } | 115 | 1.88k | } | 116 | 1.88k | if (const auto *DC = dyn_cast<DeclContext>(D)) | 117 | 1.88k | dumpDeclContext(DC); | 118 | 1.88k | } | 119 | 1.88k | }); | 120 | 1.88k | } |
|
121 | | |
122 | 36.9k | void Visit(const Stmt *Node, StringRef Label = {}) { |
123 | 36.9k | getNodeDelegate().AddChild(Label, [=] { |
124 | 36.9k | const Stmt *S = Node; |
125 | | |
126 | 36.9k | if (auto *E = dyn_cast_or_null<Expr>(S)) { |
127 | 26.8k | switch (Traversal) { |
128 | 26.8k | case TK_AsIs: |
129 | 26.8k | break; |
130 | 0 | case TK_IgnoreUnlessSpelledInSource: |
131 | 0 | S = E->IgnoreUnlessSpelledInSource(); |
132 | 0 | break; |
133 | 26.8k | } |
134 | 26.8k | } |
135 | | |
136 | 36.9k | getNodeDelegate().Visit(S); |
137 | | |
138 | 36.9k | if (!S) { |
139 | 1.05k | return; |
140 | 1.05k | } |
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)33.8k || |
146 | 35.8k | isa<RequiresExpr>(S)33.7k ) |
147 | 2.07k | return; |
148 | | |
149 | 33.7k | if (Traversal == TK_IgnoreUnlessSpelledInSource && |
150 | 33.7k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, |
151 | 0 | CXXRewrittenBinaryOperator>(S)) |
152 | 0 | return; |
153 | | |
154 | 33.7k | for (const Stmt *SubStmt : S->children()) |
155 | 28.5k | Visit(SubStmt); |
156 | 33.7k | }); clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef)::'lambda'()::operator()() const Line | Count | Source | 123 | 2.52k | getNodeDelegate().AddChild(Label, [=] { | 124 | 2.52k | const Stmt *S = Node; | 125 | | | 126 | 2.52k | if (auto *E = dyn_cast_or_null<Expr>(S)) { | 127 | 1.83k | switch (Traversal) { | 128 | 1.83k | case TK_AsIs: | 129 | 1.83k | break; | 130 | 0 | case TK_IgnoreUnlessSpelledInSource: | 131 | 0 | S = E->IgnoreUnlessSpelledInSource(); | 132 | 0 | break; | 133 | 1.83k | } | 134 | 1.83k | } | 135 | | | 136 | 2.52k | getNodeDelegate().Visit(S); | 137 | | | 138 | 2.52k | if (!S) { | 139 | 37 | return; | 140 | 37 | } | 141 | | | 142 | 2.48k | ConstStmtVisitor<Derived>::Visit(S); | 143 | | | 144 | | // Some statements have custom mechanisms for dumping their children. | 145 | 2.48k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)2.39k || | 146 | 2.48k | isa<RequiresExpr>(S)2.38k ) | 147 | 100 | return; | 148 | | | 149 | 2.38k | if (Traversal == TK_IgnoreUnlessSpelledInSource && | 150 | 2.38k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, | 151 | 0 | CXXRewrittenBinaryOperator>(S)) | 152 | 0 | return; | 153 | | | 154 | 2.38k | for (const Stmt *SubStmt : S->children()) | 155 | 2.03k | Visit(SubStmt); | 156 | 2.38k | }); |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef)::'lambda'()::operator()() const Line | Count | Source | 123 | 34.4k | getNodeDelegate().AddChild(Label, [=] { | 124 | 34.4k | const Stmt *S = Node; | 125 | | | 126 | 34.4k | if (auto *E = dyn_cast_or_null<Expr>(S)) { | 127 | 25.0k | switch (Traversal) { | 128 | 25.0k | case TK_AsIs: | 129 | 25.0k | break; | 130 | 0 | case TK_IgnoreUnlessSpelledInSource: | 131 | 0 | S = E->IgnoreUnlessSpelledInSource(); | 132 | 0 | break; | 133 | 25.0k | } | 134 | 25.0k | } | 135 | | | 136 | 34.4k | getNodeDelegate().Visit(S); | 137 | | | 138 | 34.4k | if (!S) { | 139 | 1.02k | return; | 140 | 1.02k | } | 141 | | | 142 | 33.3k | ConstStmtVisitor<Derived>::Visit(S); | 143 | | | 144 | | // Some statements have custom mechanisms for dumping their children. | 145 | 33.3k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)31.4k || | 146 | 33.3k | isa<RequiresExpr>(S)31.4k ) | 147 | 1.97k | return; | 148 | | | 149 | 31.4k | if (Traversal == TK_IgnoreUnlessSpelledInSource && | 150 | 31.4k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, | 151 | 0 | CXXRewrittenBinaryOperator>(S)) | 152 | 0 | return; | 153 | | | 154 | 31.4k | for (const Stmt *SubStmt : S->children()) | 155 | 26.5k | Visit(SubStmt); | 156 | 31.4k | }); |
|
157 | 36.9k | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef) Line | Count | Source | 122 | 2.52k | void Visit(const Stmt *Node, StringRef Label = {}) { | 123 | 2.52k | getNodeDelegate().AddChild(Label, [=] { | 124 | 2.52k | const Stmt *S = Node; | 125 | | | 126 | 2.52k | if (auto *E = dyn_cast_or_null<Expr>(S)) { | 127 | 2.52k | switch (Traversal) { | 128 | 2.52k | case TK_AsIs: | 129 | 2.52k | break; | 130 | 2.52k | case TK_IgnoreUnlessSpelledInSource: | 131 | 2.52k | S = E->IgnoreUnlessSpelledInSource(); | 132 | 2.52k | break; | 133 | 2.52k | } | 134 | 2.52k | } | 135 | | | 136 | 2.52k | getNodeDelegate().Visit(S); | 137 | | | 138 | 2.52k | if (!S) { | 139 | 2.52k | return; | 140 | 2.52k | } | 141 | | | 142 | 2.52k | ConstStmtVisitor<Derived>::Visit(S); | 143 | | | 144 | | // Some statements have custom mechanisms for dumping their children. | 145 | 2.52k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S) || | 146 | 2.52k | isa<RequiresExpr>(S)) | 147 | 2.52k | return; | 148 | | | 149 | 2.52k | if (Traversal == TK_IgnoreUnlessSpelledInSource && | 150 | 2.52k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, | 151 | 2.52k | CXXRewrittenBinaryOperator>(S)) | 152 | 2.52k | return; | 153 | | | 154 | 2.52k | for (const Stmt *SubStmt : S->children()) | 155 | 2.52k | Visit(SubStmt); | 156 | 2.52k | }); | 157 | 2.52k | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Stmt const*, llvm::StringRef) Line | Count | Source | 122 | 34.4k | void Visit(const Stmt *Node, StringRef Label = {}) { | 123 | 34.4k | getNodeDelegate().AddChild(Label, [=] { | 124 | 34.4k | const Stmt *S = Node; | 125 | | | 126 | 34.4k | if (auto *E = dyn_cast_or_null<Expr>(S)) { | 127 | 34.4k | switch (Traversal) { | 128 | 34.4k | case TK_AsIs: | 129 | 34.4k | break; | 130 | 34.4k | case TK_IgnoreUnlessSpelledInSource: | 131 | 34.4k | S = E->IgnoreUnlessSpelledInSource(); | 132 | 34.4k | break; | 133 | 34.4k | } | 134 | 34.4k | } | 135 | | | 136 | 34.4k | getNodeDelegate().Visit(S); | 137 | | | 138 | 34.4k | if (!S) { | 139 | 34.4k | return; | 140 | 34.4k | } | 141 | | | 142 | 34.4k | ConstStmtVisitor<Derived>::Visit(S); | 143 | | | 144 | | // Some statements have custom mechanisms for dumping their children. | 145 | 34.4k | if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S) || | 146 | 34.4k | isa<RequiresExpr>(S)) | 147 | 34.4k | return; | 148 | | | 149 | 34.4k | if (Traversal == TK_IgnoreUnlessSpelledInSource && | 150 | 34.4k | isa<LambdaExpr, CXXForRangeStmt, CallExpr, | 151 | 34.4k | CXXRewrittenBinaryOperator>(S)) | 152 | 34.4k | return; | 153 | | | 154 | 34.4k | for (const Stmt *SubStmt : S->children()) | 155 | 34.4k | Visit(SubStmt); | 156 | 34.4k | }); | 157 | 34.4k | } |
|
158 | | |
159 | 5.43k | void Visit(QualType T) { |
160 | 5.43k | SplitQualType SQT = T.split(); |
161 | 5.43k | if (!SQT.Quals.hasQualifiers()) |
162 | 5.40k | 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 | 4.96k | void Visit(QualType T) { | 160 | 4.96k | SplitQualType SQT = T.split(); | 161 | 4.96k | if (!SQT.Quals.hasQualifiers()) | 162 | 4.93k | 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 | 470 | void Visit(QualType T) { | 160 | 470 | SplitQualType SQT = T.split(); | 161 | 470 | if (!SQT.Quals.hasQualifiers()) | 162 | 469 | 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.47k | void Visit(const Type *T) { |
171 | 5.47k | getNodeDelegate().AddChild([=] { |
172 | 5.47k | getNodeDelegate().Visit(T); |
173 | 5.47k | if (!T) |
174 | 1 | return; |
175 | 5.47k | TypeVisitor<Derived>::Visit(T); |
176 | | |
177 | 5.47k | QualType SingleStepDesugar = |
178 | 5.47k | T->getLocallyUnqualifiedSingleStepDesugaredType(); |
179 | 5.47k | if (SingleStepDesugar != QualType(T, 0)) |
180 | 211 | Visit(SingleStepDesugar); |
181 | 5.47k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Type const*)::'lambda'()::operator()() const Line | Count | Source | 171 | 4.99k | getNodeDelegate().AddChild([=] { | 172 | 4.99k | getNodeDelegate().Visit(T); | 173 | 4.99k | if (!T) | 174 | 0 | return; | 175 | 4.99k | TypeVisitor<Derived>::Visit(T); | 176 | | | 177 | 4.99k | QualType SingleStepDesugar = | 178 | 4.99k | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 179 | 4.99k | if (SingleStepDesugar != QualType(T, 0)) | 180 | 204 | Visit(SingleStepDesugar); | 181 | 4.99k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Type const*)::'lambda'()::operator()() const Line | Count | Source | 171 | 474 | getNodeDelegate().AddChild([=] { | 172 | 474 | getNodeDelegate().Visit(T); | 173 | 474 | if (!T) | 174 | 1 | return; | 175 | 473 | TypeVisitor<Derived>::Visit(T); | 176 | | | 177 | 473 | QualType SingleStepDesugar = | 178 | 473 | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 179 | 473 | if (SingleStepDesugar != QualType(T, 0)) | 180 | 7 | Visit(SingleStepDesugar); | 181 | 473 | }); |
|
182 | 5.47k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Type const*) Line | Count | Source | 170 | 4.99k | void Visit(const Type *T) { | 171 | 4.99k | getNodeDelegate().AddChild([=] { | 172 | 4.99k | getNodeDelegate().Visit(T); | 173 | 4.99k | if (!T) | 174 | 4.99k | return; | 175 | 4.99k | TypeVisitor<Derived>::Visit(T); | 176 | | | 177 | 4.99k | QualType SingleStepDesugar = | 178 | 4.99k | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 179 | 4.99k | if (SingleStepDesugar != QualType(T, 0)) | 180 | 4.99k | Visit(SingleStepDesugar); | 181 | 4.99k | }); | 182 | 4.99k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Type const*) Line | Count | Source | 170 | 474 | void Visit(const Type *T) { | 171 | 474 | getNodeDelegate().AddChild([=] { | 172 | 474 | getNodeDelegate().Visit(T); | 173 | 474 | if (!T) | 174 | 474 | return; | 175 | 474 | TypeVisitor<Derived>::Visit(T); | 176 | | | 177 | 474 | QualType SingleStepDesugar = | 178 | 474 | T->getLocallyUnqualifiedSingleStepDesugaredType(); | 179 | 474 | if (SingleStepDesugar != QualType(T, 0)) | 180 | 474 | Visit(SingleStepDesugar); | 181 | 474 | }); | 182 | 474 | } |
|
183 | | |
184 | 2.46k | void Visit(const Attr *A) { |
185 | 2.46k | getNodeDelegate().AddChild([=] { |
186 | 2.46k | getNodeDelegate().Visit(A); |
187 | 2.46k | ConstAttrVisitor<Derived>::Visit(A); |
188 | 2.46k | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Attr const*)::'lambda'()::operator()() const Line | Count | Source | 185 | 2.43k | getNodeDelegate().AddChild([=] { | 186 | 2.43k | getNodeDelegate().Visit(A); | 187 | 2.43k | ConstAttrVisitor<Derived>::Visit(A); | 188 | 2.43k | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Attr const*)::'lambda'()::operator()() const Line | Count | Source | 185 | 34 | getNodeDelegate().AddChild([=] { | 186 | 34 | getNodeDelegate().Visit(A); | 187 | 34 | ConstAttrVisitor<Derived>::Visit(A); | 188 | 34 | }); |
|
189 | 2.46k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::Attr const*) Line | Count | Source | 184 | 2.43k | void Visit(const Attr *A) { | 185 | 2.43k | getNodeDelegate().AddChild([=] { | 186 | 2.43k | getNodeDelegate().Visit(A); | 187 | 2.43k | ConstAttrVisitor<Derived>::Visit(A); | 188 | 2.43k | }); | 189 | 2.43k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::Attr const*) Line | Count | Source | 184 | 34 | void Visit(const Attr *A) { | 185 | 34 | getNodeDelegate().AddChild([=] { | 186 | 34 | getNodeDelegate().Visit(A); | 187 | 34 | ConstAttrVisitor<Derived>::Visit(A); | 188 | 34 | }); | 189 | 34 | } |
|
190 | | |
191 | 194 | void Visit(const CXXCtorInitializer *Init) { |
192 | 194 | if (Traversal == TK_IgnoreUnlessSpelledInSource && !Init->isWritten()0 ) |
193 | 0 | return; |
194 | 194 | getNodeDelegate().AddChild([=] { |
195 | 194 | getNodeDelegate().Visit(Init); |
196 | 194 | Visit(Init->getInit()); |
197 | 194 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::CXXCtorInitializer const*)::'lambda'()::operator()() const Line | Count | Source | 194 | 173 | getNodeDelegate().AddChild([=] { | 195 | 173 | getNodeDelegate().Visit(Init); | 196 | 173 | Visit(Init->getInit()); | 197 | 173 | }); |
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 | 194 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::CXXCtorInitializer const*) Line | Count | Source | 191 | 173 | void Visit(const CXXCtorInitializer *Init) { | 192 | 173 | if (Traversal == TK_IgnoreUnlessSpelledInSource && !Init->isWritten()0 ) | 193 | 0 | return; | 194 | 173 | getNodeDelegate().AddChild([=] { | 195 | 173 | getNodeDelegate().Visit(Init); | 196 | 173 | Visit(Init->getInit()); | 197 | 173 | }); | 198 | 173 | } |
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 | 760 | const Decl *From = nullptr, const char *Label = nullptr) { |
202 | 760 | getNodeDelegate().AddChild([=] { |
203 | 760 | getNodeDelegate().Visit(A, R, From, Label); |
204 | 760 | ConstTemplateArgumentVisitor<Derived>::Visit(A); |
205 | 760 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*)::'lambda'()::operator()() const Line | Count | Source | 202 | 731 | getNodeDelegate().AddChild([=] { | 203 | 731 | getNodeDelegate().Visit(A, R, From, Label); | 204 | 731 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 205 | 731 | }); |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*)::'lambda'()::operator()() const Line | Count | Source | 202 | 29 | getNodeDelegate().AddChild([=] { | 203 | 29 | getNodeDelegate().Visit(A, R, From, Label); | 204 | 29 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 205 | 29 | }); |
|
206 | 760 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*) Line | Count | Source | 201 | 731 | const Decl *From = nullptr, const char *Label = nullptr) { | 202 | 731 | getNodeDelegate().AddChild([=] { | 203 | 731 | getNodeDelegate().Visit(A, R, From, Label); | 204 | 731 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 205 | 731 | }); | 206 | 731 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::Visit(clang::TemplateArgument const&, clang::SourceRange, clang::Decl const*, char const*) Line | Count | Source | 201 | 29 | const Decl *From = nullptr, const char *Label = nullptr) { | 202 | 29 | getNodeDelegate().AddChild([=] { | 203 | 29 | getNodeDelegate().Visit(A, R, From, Label); | 204 | 29 | ConstTemplateArgumentVisitor<Derived>::Visit(A); | 205 | 29 | }); | 206 | 29 | } |
|
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 | 362 | void Visit(const OMPClause *C) { |
217 | 362 | getNodeDelegate().AddChild([=] { |
218 | 362 | getNodeDelegate().Visit(C); |
219 | 362 | for (const auto *S : C->children()) |
220 | 456 | Visit(S); |
221 | 362 | }); clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::OMPClause const*)::'lambda'()::operator()() const Line | Count | Source | 217 | 360 | getNodeDelegate().AddChild([=] { | 218 | 360 | getNodeDelegate().Visit(C); | 219 | 360 | for (const auto *S : C->children()) | 220 | 454 | Visit(S); | 221 | 360 | }); |
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 | 362 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::Visit(clang::OMPClause const*) Line | Count | Source | 216 | 360 | void Visit(const OMPClause *C) { | 217 | 360 | getNodeDelegate().AddChild([=] { | 218 | 360 | getNodeDelegate().Visit(C); | 219 | 360 | for (const auto *S : C->children()) | 220 | 360 | Visit(S); | 221 | 360 | }); | 222 | 360 | } |
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.30k | void dumpDeclContext(const DeclContext *DC) { |
294 | 5.30k | if (!DC) |
295 | 0 | return; |
296 | | |
297 | 5.30k | for (const auto *D : (Deserialize ? DC->decls()810 : DC->noload_decls()4.49k )) |
298 | 18.3k | Visit(D); |
299 | 5.30k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpDeclContext(clang::DeclContext const*) Line | Count | Source | 293 | 4.93k | void dumpDeclContext(const DeclContext *DC) { | 294 | 4.93k | if (!DC) | 295 | 0 | return; | 296 | | | 297 | 4.93k | for (const auto *D : (Deserialize ? DC->decls()810 : DC->noload_decls()4.12k )) | 298 | 17.1k | Visit(D); | 299 | 4.93k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpDeclContext(clang::DeclContext const*) Line | Count | Source | 293 | 364 | void dumpDeclContext(const DeclContext *DC) { | 294 | 364 | if (!DC) | 295 | 0 | return; | 296 | | | 297 | 364 | for (const auto *D : (Deserialize ? DC->decls()0 : DC->noload_decls())) | 298 | 1.21k | Visit(D); | 299 | 364 | } |
|
300 | | |
301 | 673 | void dumpTemplateParameters(const TemplateParameterList *TPL) { |
302 | 673 | if (!TPL) |
303 | 0 | return; |
304 | | |
305 | 673 | for (const auto &TP : *TPL) |
306 | 807 | Visit(TP); |
307 | | |
308 | 673 | if (const Expr *RC = TPL->getRequiresClause()) |
309 | 2 | Visit(RC); |
310 | 673 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpTemplateParameters(clang::TemplateParameterList const*) Line | Count | Source | 301 | 621 | void dumpTemplateParameters(const TemplateParameterList *TPL) { | 302 | 621 | if (!TPL) | 303 | 0 | return; | 304 | | | 305 | 621 | for (const auto &TP : *TPL) | 306 | 751 | Visit(TP); | 307 | | | 308 | 621 | if (const Expr *RC = TPL->getRequiresClause()) | 309 | 2 | Visit(RC); | 310 | 621 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpTemplateParameters(clang::TemplateParameterList const*) Line | Count | Source | 301 | 52 | void dumpTemplateParameters(const TemplateParameterList *TPL) { | 302 | 52 | if (!TPL) | 303 | 0 | return; | 304 | | | 305 | 52 | for (const auto &TP : *TPL) | 306 | 56 | Visit(TP); | 307 | | | 308 | 52 | if (const Expr *RC = TPL->getRequiresClause()) | 309 | 0 | Visit(RC); | 310 | 52 | } |
|
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 | 407 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { |
328 | 908 | for (unsigned i = 0, e = TAL.size(); i < e; ++i501 ) |
329 | 501 | Visit(TAL[i]); |
330 | 407 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::dumpTemplateArgumentList(clang::TemplateArgumentList const&) Line | Count | Source | 327 | 388 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { | 328 | 867 | for (unsigned i = 0, e = TAL.size(); i < e; ++i479 ) | 329 | 479 | Visit(TAL[i]); | 330 | 388 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::dumpTemplateArgumentList(clang::TemplateArgumentList const&) Line | Count | Source | 327 | 19 | void dumpTemplateArgumentList(const TemplateArgumentList &TAL) { | 328 | 41 | for (unsigned i = 0, e = TAL.size(); i < e; ++i22 ) | 329 | 22 | Visit(TAL[i]); | 330 | 19 | } |
|
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 | 567 | void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPointerType(clang::PointerType const*) Line | Count | Source | 345 | 508 | void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPointerType(clang::PointerType const*) Line | Count | Source | 345 | 59 | 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 | 417 | void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitArrayType(clang::ArrayType const*) Line | Count | Source | 356 | 360 | void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitArrayType(clang::ArrayType const*) Line | Count | Source | 356 | 57 | 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 | 0 | void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) { |
366 | 0 | Visit(T->getElementType()); |
367 | 0 | Visit(T->getSizeExpr()); |
368 | 0 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDependentSizedExtVectorType(clang::DependentSizedExtVectorType const*) Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDependentSizedExtVectorType(clang::DependentSizedExtVectorType const*) |
369 | 6 | void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVectorType(clang::VectorType const*) Line | Count | Source | 369 | 6 | void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVectorType(clang::VectorType const*) |
370 | 32 | void VisitFunctionType(const FunctionType *T) { Visit(T->getReturnType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionType(clang::FunctionType const*) Line | Count | Source | 370 | 28 | 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 | 32 | void VisitFunctionProtoType(const FunctionProtoType *T) { |
372 | 32 | VisitFunctionType(T); |
373 | 32 | for (const QualType &PT : T->getParamTypes()) |
374 | 25 | Visit(PT); |
375 | 32 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionProtoType(clang::FunctionProtoType const*) Line | Count | Source | 371 | 28 | void VisitFunctionProtoType(const FunctionProtoType *T) { | 372 | 28 | VisitFunctionType(T); | 373 | 28 | for (const QualType &PT : T->getParamTypes()) | 374 | 24 | Visit(PT); | 375 | 28 | } |
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 | 33 | void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { |
393 | 33 | Visit(T->getReplacedParameter()); |
394 | 33 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstTemplateTypeParmType(clang::SubstTemplateTypeParmType const*) Line | Count | Source | 392 | 33 | void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) { | 393 | 33 | Visit(T->getReplacedParameter()); | 394 | 33 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstTemplateTypeParmType(clang::SubstTemplateTypeParmType const*) |
395 | | void |
396 | 1 | VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) { |
397 | 1 | Visit(T->getReplacedParameter()); |
398 | 1 | Visit(T->getArgumentPack()); |
399 | 1 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstTemplateTypeParmPackType(clang::SubstTemplateTypeParmPackType const*) Line | Count | Source | 396 | 1 | VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) { | 397 | 1 | Visit(T->getReplacedParameter()); | 398 | 1 | Visit(T->getArgumentPack()); | 399 | 1 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstTemplateTypeParmPackType(clang::SubstTemplateTypeParmPackType const*) |
400 | 66 | void VisitTemplateSpecializationType(const TemplateSpecializationType *T) { |
401 | 66 | for (const auto &Arg : *T) |
402 | 93 | Visit(Arg); |
403 | 66 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateSpecializationType(clang::TemplateSpecializationType const*) Line | Count | Source | 400 | 66 | void VisitTemplateSpecializationType(const TemplateSpecializationType *T) { | 401 | 66 | for (const auto &Arg : *T) | 402 | 93 | Visit(Arg); | 403 | 66 | } |
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 | 6 | void VisitPackExpansionType(const PackExpansionType *T) { |
411 | 6 | if (!T->isSugared()) |
412 | 6 | Visit(T->getPattern()); |
413 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPackExpansionType(clang::PackExpansionType const*) Line | Count | Source | 410 | 6 | void VisitPackExpansionType(const PackExpansionType *T) { | 411 | 6 | if (!T->isSugared()) | 412 | 6 | Visit(T->getPattern()); | 413 | 6 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPackExpansionType(clang::PackExpansionType const*) |
414 | | // FIXME: ElaboratedType, DependentNameType, |
415 | | // DependentTemplateSpecializationType, ObjCObjectType |
416 | | |
417 | 3.24k | void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypedefDecl(clang::TypedefDecl const*) Line | Count | Source | 417 | 2.95k | void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypedefDecl(clang::TypedefDecl const*) Line | Count | Source | 417 | 294 | 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.30k | void VisitFunctionDecl(const FunctionDecl *D) { |
425 | 5.30k | if (const auto *FTSI = D->getTemplateSpecializationInfo()) |
426 | 185 | dumpTemplateArgumentList(*FTSI->TemplateArguments); |
427 | | |
428 | 5.30k | if (D->param_begin()) |
429 | 2.44k | for (const auto *Parameter : D->parameters()) |
430 | 3.14k | Visit(Parameter); |
431 | | |
432 | 5.30k | if (const Expr *TRC = D->getTrailingRequiresClause()) |
433 | 15 | Visit(TRC); |
434 | | |
435 | 5.30k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isDefaulted()0 ) |
436 | 0 | return; |
437 | | |
438 | 5.30k | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) |
439 | 969 | for (const auto *I : C->inits()) |
440 | 191 | Visit(I); |
441 | | |
442 | 5.30k | if (D->doesThisDeclarationHaveABody()) |
443 | 2.70k | Visit(D->getBody()); |
444 | 5.30k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFunctionDecl(clang::FunctionDecl const*) Line | Count | Source | 424 | 4.86k | void VisitFunctionDecl(const FunctionDecl *D) { | 425 | 4.86k | if (const auto *FTSI = D->getTemplateSpecializationInfo()) | 426 | 183 | dumpTemplateArgumentList(*FTSI->TemplateArguments); | 427 | | | 428 | 4.86k | if (D->param_begin()) | 429 | 2.23k | for (const auto *Parameter : D->parameters()) | 430 | 2.89k | Visit(Parameter); | 431 | | | 432 | 4.86k | if (const Expr *TRC = D->getTrailingRequiresClause()) | 433 | 14 | Visit(TRC); | 434 | | | 435 | 4.86k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isDefaulted()0 ) | 436 | 0 | return; | 437 | | | 438 | 4.86k | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) | 439 | 915 | for (const auto *I : C->inits()) | 440 | 170 | Visit(I); | 441 | | | 442 | 4.86k | if (D->doesThisDeclarationHaveABody()) | 443 | 2.44k | Visit(D->getBody()); | 444 | 4.86k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFunctionDecl(clang::FunctionDecl const*) Line | Count | Source | 424 | 440 | void VisitFunctionDecl(const FunctionDecl *D) { | 425 | 440 | if (const auto *FTSI = D->getTemplateSpecializationInfo()) | 426 | 2 | dumpTemplateArgumentList(*FTSI->TemplateArguments); | 427 | | | 428 | 440 | if (D->param_begin()) | 429 | 211 | for (const auto *Parameter : D->parameters()) | 430 | 248 | Visit(Parameter); | 431 | | | 432 | 440 | if (const Expr *TRC = D->getTrailingRequiresClause()) | 433 | 1 | Visit(TRC); | 434 | | | 435 | 440 | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isDefaulted()0 ) | 436 | 0 | return; | 437 | | | 438 | 440 | if (const auto *C = dyn_cast<CXXConstructorDecl>(D)) | 439 | 54 | for (const auto *I : C->inits()) | 440 | 21 | Visit(I); | 441 | | | 442 | 440 | if (D->doesThisDeclarationHaveABody()) | 443 | 260 | Visit(D->getBody()); | 444 | 440 | } |
|
445 | | |
446 | 2.07k | void VisitFieldDecl(const FieldDecl *D) { |
447 | 2.07k | if (D->isBitField()) |
448 | 103 | Visit(D->getBitWidth()); |
449 | 2.07k | if (Expr *Init = D->getInClassInitializer()) |
450 | 46 | Visit(Init); |
451 | 2.07k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFieldDecl(clang::FieldDecl const*) Line | Count | Source | 446 | 1.96k | void VisitFieldDecl(const FieldDecl *D) { | 447 | 1.96k | if (D->isBitField()) | 448 | 96 | Visit(D->getBitWidth()); | 449 | 1.96k | if (Expr *Init = D->getInClassInitializer()) | 450 | 45 | Visit(Init); | 451 | 1.96k | } |
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.60k | void VisitVarDecl(const VarDecl *D) { |
454 | 9.60k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isCXXForRangeDecl()0 ) |
455 | 0 | return; |
456 | | |
457 | 9.60k | if (D->hasInit()) |
458 | 2.79k | Visit(D->getInit()); |
459 | 9.60k | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVarDecl(clang::VarDecl const*) Line | Count | Source | 453 | 9.13k | void VisitVarDecl(const VarDecl *D) { | 454 | 9.13k | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isCXXForRangeDecl()0 ) | 455 | 0 | return; | 456 | | | 457 | 9.13k | if (D->hasInit()) | 458 | 2.71k | Visit(D->getInit()); | 459 | 9.13k | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVarDecl(clang::VarDecl const*) Line | Count | Source | 453 | 466 | void VisitVarDecl(const VarDecl *D) { | 454 | 466 | if (Traversal == TK_IgnoreUnlessSpelledInSource && D->isCXXForRangeDecl()0 ) | 455 | 0 | return; | 456 | | | 457 | 466 | if (D->hasInit()) | 458 | 84 | Visit(D->getInit()); | 459 | 466 | } |
|
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 | 0 | if (const auto *E = D->getBinding()) |
471 | 0 | Visit(E); |
472 | 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*) |
473 | | |
474 | 3 | void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) { |
475 | 3 | Visit(D->getAsmString()); |
476 | 3 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFileScopeAsmDecl(clang::FileScopeAsmDecl const*) Line | Count | Source | 474 | 3 | void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) { | 475 | 3 | Visit(D->getAsmString()); | 476 | 3 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFileScopeAsmDecl(clang::FileScopeAsmDecl const*) |
477 | | |
478 | 857 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCapturedDecl(clang::CapturedDecl const*) Line | Count | Source | 478 | 836 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCapturedDecl(clang::CapturedDecl const*) Line | Count | Source | 478 | 21 | void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); } |
|
479 | | |
480 | 2 | void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { |
481 | 2 | for (const auto *E : D->varlists()) |
482 | 4 | Visit(E); |
483 | 2 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPThreadPrivateDecl(clang::OMPThreadPrivateDecl const*) Line | Count | Source | 480 | 2 | void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) { | 481 | 2 | for (const auto *E : D->varlists()) | 482 | 4 | Visit(E); | 483 | 2 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPThreadPrivateDecl(clang::OMPThreadPrivateDecl const*) |
484 | | |
485 | 6 | void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) { |
486 | 6 | Visit(D->getCombiner()); |
487 | 6 | if (const auto *Initializer = D->getInitializer()) |
488 | 2 | Visit(Initializer); |
489 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPDeclareReductionDecl(clang::OMPDeclareReductionDecl const*) Line | Count | Source | 485 | 6 | void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) { | 486 | 6 | Visit(D->getCombiner()); | 487 | 6 | if (const auto *Initializer = D->getInitializer()) | 488 | 2 | Visit(Initializer); | 489 | 6 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPDeclareReductionDecl(clang::OMPDeclareReductionDecl const*) |
490 | | |
491 | 0 | void VisitOMPDeclareMapperDecl(const OMPDeclareMapperDecl *D) { |
492 | 0 | for (const auto *C : D->clauselists()) |
493 | 0 | Visit(C); |
494 | 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*) |
495 | | |
496 | 96 | void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) { |
497 | 96 | Visit(D->getInit()); |
498 | 96 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPCapturedExprDecl(clang::OMPCapturedExprDecl const*) Line | Count | Source | 496 | 96 | void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) { | 497 | 96 | Visit(D->getInit()); | 498 | 96 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPCapturedExprDecl(clang::OMPCapturedExprDecl const*) |
499 | | |
500 | 8 | void VisitOMPAllocateDecl(const OMPAllocateDecl *D) { |
501 | 8 | for (const auto *E : D->varlists()) |
502 | 8 | Visit(E); |
503 | 8 | for (const auto *C : D->clauselists()) |
504 | 12 | Visit(C); |
505 | 8 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPAllocateDecl(clang::OMPAllocateDecl const*) Line | Count | Source | 500 | 8 | void VisitOMPAllocateDecl(const OMPAllocateDecl *D) { | 501 | 8 | for (const auto *E : D->varlists()) | 502 | 8 | Visit(E); | 503 | 8 | for (const auto *C : D->clauselists()) | 504 | 12 | Visit(C); | 505 | 8 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPAllocateDecl(clang::OMPAllocateDecl const*) |
506 | | |
507 | | template <typename SpecializationDecl> |
508 | | void dumpTemplateDeclSpecialization(const SpecializationDecl *D) { |
509 | | for (const auto *RedeclWithBadType : D->redecls()) { |
510 | | // FIXME: The redecls() range sometimes has elements of a less-specific |
511 | | // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives |
512 | | // us TagDecls, and should give CXXRecordDecls). |
513 | | auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType); |
514 | | if (!Redecl) { |
515 | | // Found the injected-class-name for a class template. This will be |
516 | | // dumped as part of its surrounding class so we don't need to dump it |
517 | | // here. |
518 | | assert(isa<CXXRecordDecl>(RedeclWithBadType) && |
519 | | "expected an injected-class-name"); |
520 | | continue; |
521 | | } |
522 | | Visit(Redecl); |
523 | | } |
524 | | } |
525 | | |
526 | | template <typename TemplateDecl> |
527 | | void dumpTemplateDecl(const TemplateDecl *D) { |
528 | | dumpTemplateParameters(D->getTemplateParameters()); |
529 | | |
530 | | Visit(D->getTemplatedDecl()); |
531 | | |
532 | | if (Traversal == TK_AsIs) { |
533 | | for (const auto *Child : D->specializations()) |
534 | | dumpTemplateDeclSpecialization(Child); |
535 | | } |
536 | | } |
537 | | |
538 | 102 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { |
539 | 102 | Visit(D->getUnderlyingType()); |
540 | 102 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeAliasDecl(clang::TypeAliasDecl const*) Line | Count | Source | 538 | 97 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { | 539 | 97 | Visit(D->getUnderlyingType()); | 540 | 97 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeAliasDecl(clang::TypeAliasDecl const*) Line | Count | Source | 538 | 5 | void VisitTypeAliasDecl(const TypeAliasDecl *D) { | 539 | 5 | Visit(D->getUnderlyingType()); | 540 | 5 | } |
|
541 | | |
542 | 8 | void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) { |
543 | 8 | dumpTemplateParameters(D->getTemplateParameters()); |
544 | 8 | Visit(D->getTemplatedDecl()); |
545 | 8 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl const*) Line | Count | Source | 542 | 8 | void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) { | 543 | 8 | dumpTemplateParameters(D->getTemplateParameters()); | 544 | 8 | Visit(D->getTemplatedDecl()); | 545 | 8 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl const*) |
546 | | |
547 | 48 | void VisitStaticAssertDecl(const StaticAssertDecl *D) { |
548 | 48 | Visit(D->getAssertExpr()); |
549 | 48 | Visit(D->getMessage()); |
550 | 48 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitStaticAssertDecl(clang::StaticAssertDecl const*) Line | Count | Source | 547 | 47 | void VisitStaticAssertDecl(const StaticAssertDecl *D) { | 548 | 47 | Visit(D->getAssertExpr()); | 549 | 47 | Visit(D->getMessage()); | 550 | 47 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitStaticAssertDecl(clang::StaticAssertDecl const*) Line | Count | Source | 547 | 1 | void VisitStaticAssertDecl(const StaticAssertDecl *D) { | 548 | 1 | Visit(D->getAssertExpr()); | 549 | 1 | Visit(D->getMessage()); | 550 | 1 | } |
|
551 | | |
552 | | void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) { |
553 | | dumpTemplateDecl(D); |
554 | | } |
555 | | |
556 | | void VisitClassTemplateDecl(const ClassTemplateDecl *D) { |
557 | | dumpTemplateDecl(D); |
558 | | } |
559 | | |
560 | | void VisitClassTemplateSpecializationDecl( |
561 | 216 | const ClassTemplateSpecializationDecl *D) { |
562 | 216 | dumpTemplateArgumentList(D->getTemplateArgs()); |
563 | 216 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassTemplateSpecializationDecl(clang::ClassTemplateSpecializationDecl const*) Line | Count | Source | 561 | 199 | const ClassTemplateSpecializationDecl *D) { | 562 | 199 | dumpTemplateArgumentList(D->getTemplateArgs()); | 563 | 199 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassTemplateSpecializationDecl(clang::ClassTemplateSpecializationDecl const*) Line | Count | Source | 561 | 17 | const ClassTemplateSpecializationDecl *D) { | 562 | 17 | dumpTemplateArgumentList(D->getTemplateArgs()); | 563 | 17 | } |
|
564 | | |
565 | | void VisitClassTemplatePartialSpecializationDecl( |
566 | 26 | const ClassTemplatePartialSpecializationDecl *D) { |
567 | 26 | VisitClassTemplateSpecializationDecl(D); |
568 | 26 | dumpTemplateParameters(D->getTemplateParameters()); |
569 | 26 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplatePartialSpecializationDecl const*) Line | Count | Source | 566 | 24 | const ClassTemplatePartialSpecializationDecl *D) { | 567 | 24 | VisitClassTemplateSpecializationDecl(D); | 568 | 24 | dumpTemplateParameters(D->getTemplateParameters()); | 569 | 24 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplatePartialSpecializationDecl const*) Line | Count | Source | 566 | 2 | const ClassTemplatePartialSpecializationDecl *D) { | 567 | 2 | VisitClassTemplateSpecializationDecl(D); | 568 | 2 | dumpTemplateParameters(D->getTemplateParameters()); | 569 | 2 | } |
|
570 | | |
571 | | void VisitClassScopeFunctionSpecializationDecl( |
572 | 1 | const ClassScopeFunctionSpecializationDecl *D) { |
573 | 1 | Visit(D->getSpecialization()); |
574 | 1 | dumpASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten()); |
575 | 1 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitClassScopeFunctionSpecializationDecl(clang::ClassScopeFunctionSpecializationDecl const*) Line | Count | Source | 572 | 1 | const ClassScopeFunctionSpecializationDecl *D) { | 573 | 1 | Visit(D->getSpecialization()); | 574 | 1 | dumpASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten()); | 575 | 1 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitClassScopeFunctionSpecializationDecl(clang::ClassScopeFunctionSpecializationDecl const*) |
576 | | void VisitVarTemplateDecl(const VarTemplateDecl *D) { dumpTemplateDecl(D); } |
577 | | |
578 | 4 | void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) { |
579 | 4 | dumpTemplateParameters(D->getTemplateParameters()); |
580 | 4 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBuiltinTemplateDecl(clang::BuiltinTemplateDecl const*) Line | Count | Source | 578 | 4 | void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) { | 579 | 4 | dumpTemplateParameters(D->getTemplateParameters()); | 580 | 4 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBuiltinTemplateDecl(clang::BuiltinTemplateDecl const*) |
581 | | |
582 | | void |
583 | 6 | VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) { |
584 | 6 | dumpTemplateArgumentList(D->getTemplateArgs()); |
585 | 6 | VisitVarDecl(D); |
586 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitVarTemplateSpecializationDecl(clang::VarTemplateSpecializationDecl const*) Line | Count | Source | 583 | 6 | VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) { | 584 | 6 | dumpTemplateArgumentList(D->getTemplateArgs()); | 585 | 6 | VisitVarDecl(D); | 586 | 6 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitVarTemplateSpecializationDecl(clang::VarTemplateSpecializationDecl const*) |
587 | | |
588 | | void VisitVarTemplatePartialSpecializationDecl( |
589 | 0 | const VarTemplatePartialSpecializationDecl *D) { |
590 | 0 | dumpTemplateParameters(D->getTemplateParameters()); |
591 | 0 | VisitVarTemplateSpecializationDecl(D); |
592 | 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*) |
593 | | |
594 | 638 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { |
595 | 638 | if (const auto *TC = D->getTypeConstraint()) |
596 | 14 | Visit(TC->getImmediatelyDeclaredConstraint()); |
597 | 638 | if (D->hasDefaultArgument()) |
598 | 22 | Visit(D->getDefaultArgument(), SourceRange(), |
599 | 22 | D->getDefaultArgStorage().getInheritedFrom(), |
600 | 22 | D->defaultArgumentWasInherited() ? "inherited from"7 : "previous"15 ); |
601 | 638 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateTypeParmDecl(clang::TemplateTypeParmDecl const*) Line | Count | Source | 594 | 590 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { | 595 | 590 | if (const auto *TC = D->getTypeConstraint()) | 596 | 12 | Visit(TC->getImmediatelyDeclaredConstraint()); | 597 | 590 | if (D->hasDefaultArgument()) | 598 | 20 | Visit(D->getDefaultArgument(), SourceRange(), | 599 | 20 | D->getDefaultArgStorage().getInheritedFrom(), | 600 | 20 | D->defaultArgumentWasInherited() ? "inherited from"7 : "previous"13 ); | 601 | 590 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTemplateTypeParmDecl(clang::TemplateTypeParmDecl const*) Line | Count | Source | 594 | 48 | void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) { | 595 | 48 | if (const auto *TC = D->getTypeConstraint()) | 596 | 2 | Visit(TC->getImmediatelyDeclaredConstraint()); | 597 | 48 | if (D->hasDefaultArgument()) | 598 | 2 | Visit(D->getDefaultArgument(), SourceRange(), | 599 | 2 | D->getDefaultArgStorage().getInheritedFrom(), | 600 | 2 | D->defaultArgumentWasInherited() ? "inherited from"0 : "previous"); | 601 | 48 | } |
|
602 | | |
603 | 220 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { |
604 | 220 | if (const auto *E = D->getPlaceholderTypeConstraint()) |
605 | 0 | Visit(E); |
606 | 220 | if (D->hasDefaultArgument()) |
607 | 16 | Visit(D->getDefaultArgument(), SourceRange(), |
608 | 16 | D->getDefaultArgStorage().getInheritedFrom(), |
609 | 16 | D->defaultArgumentWasInherited() ? "inherited from"4 : "previous"12 ); |
610 | 220 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitNonTypeTemplateParmDecl(clang::NonTypeTemplateParmDecl const*) Line | Count | Source | 603 | 214 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { | 604 | 214 | if (const auto *E = D->getPlaceholderTypeConstraint()) | 605 | 0 | Visit(E); | 606 | 214 | if (D->hasDefaultArgument()) | 607 | 16 | Visit(D->getDefaultArgument(), SourceRange(), | 608 | 16 | D->getDefaultArgStorage().getInheritedFrom(), | 609 | 16 | D->defaultArgumentWasInherited() ? "inherited from"4 : "previous"12 ); | 610 | 214 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitNonTypeTemplateParmDecl(clang::NonTypeTemplateParmDecl const*) Line | Count | Source | 603 | 6 | void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) { | 604 | 6 | if (const auto *E = D->getPlaceholderTypeConstraint()) | 605 | 0 | Visit(E); | 606 | 6 | if (D->hasDefaultArgument()) | 607 | 0 | Visit(D->getDefaultArgument(), SourceRange(), | 608 | 0 | D->getDefaultArgStorage().getInheritedFrom(), | 609 | 0 | D->defaultArgumentWasInherited() ? "inherited from" : "previous"); | 610 | 6 | } |
|
611 | | |
612 | 18 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { |
613 | 18 | dumpTemplateParameters(D->getTemplateParameters()); |
614 | 18 | if (D->hasDefaultArgument()) |
615 | 4 | dumpTemplateArgumentLoc( |
616 | 4 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), |
617 | 4 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"3 ); |
618 | 18 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl const*) Line | Count | Source | 612 | 16 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { | 613 | 16 | dumpTemplateParameters(D->getTemplateParameters()); | 614 | 16 | if (D->hasDefaultArgument()) | 615 | 3 | dumpTemplateArgumentLoc( | 616 | 3 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), | 617 | 3 | D->defaultArgumentWasInherited() ? "inherited from"1 : "previous"2 ); | 618 | 16 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl const*) Line | Count | Source | 612 | 2 | void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) { | 613 | 2 | dumpTemplateParameters(D->getTemplateParameters()); | 614 | 2 | if (D->hasDefaultArgument()) | 615 | 1 | dumpTemplateArgumentLoc( | 616 | 1 | D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(), | 617 | 1 | D->defaultArgumentWasInherited() ? "inherited from"0 : "previous"); | 618 | 2 | } |
|
619 | | |
620 | 6 | void VisitConceptDecl(const ConceptDecl *D) { |
621 | 6 | dumpTemplateParameters(D->getTemplateParameters()); |
622 | 6 | Visit(D->getConstraintExpr()); |
623 | 6 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitConceptDecl(clang::ConceptDecl const*) Line | Count | Source | 620 | 4 | void VisitConceptDecl(const ConceptDecl *D) { | 621 | 4 | dumpTemplateParameters(D->getTemplateParameters()); | 622 | 4 | Visit(D->getConstraintExpr()); | 623 | 4 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitConceptDecl(clang::ConceptDecl const*) Line | Count | Source | 620 | 2 | void VisitConceptDecl(const ConceptDecl *D) { | 621 | 2 | dumpTemplateParameters(D->getTemplateParameters()); | 622 | 2 | Visit(D->getConstraintExpr()); | 623 | 2 | } |
|
624 | | |
625 | 24 | void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *CSE) { |
626 | 24 | if (CSE->hasExplicitTemplateArgs()) |
627 | 24 | for (const auto &ArgLoc : CSE->getTemplateArgsAsWritten()->arguments()) |
628 | 28 | dumpTemplateArgumentLoc(ArgLoc); |
629 | 24 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitConceptSpecializationExpr(clang::ConceptSpecializationExpr const*) Line | Count | Source | 625 | 4 | void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *CSE) { | 626 | 4 | if (CSE->hasExplicitTemplateArgs()) | 627 | 4 | for (const auto &ArgLoc : CSE->getTemplateArgsAsWritten()->arguments()) | 628 | 4 | dumpTemplateArgumentLoc(ArgLoc); | 629 | 4 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitConceptSpecializationExpr(clang::ConceptSpecializationExpr const*) Line | Count | Source | 625 | 20 | void VisitConceptSpecializationExpr(const ConceptSpecializationExpr *CSE) { | 626 | 20 | if (CSE->hasExplicitTemplateArgs()) | 627 | 20 | for (const auto &ArgLoc : CSE->getTemplateArgsAsWritten()->arguments()) | 628 | 24 | dumpTemplateArgumentLoc(ArgLoc); | 629 | 20 | } |
|
630 | | |
631 | 84 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { |
632 | 84 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) |
633 | 2 | Visit(TD->getTypeForDecl()); |
634 | 84 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitUsingShadowDecl(clang::UsingShadowDecl const*) Line | Count | Source | 631 | 80 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { | 632 | 80 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) | 633 | 1 | Visit(TD->getTypeForDecl()); | 634 | 80 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitUsingShadowDecl(clang::UsingShadowDecl const*) Line | Count | Source | 631 | 4 | void VisitUsingShadowDecl(const UsingShadowDecl *D) { | 632 | 4 | if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl())) | 633 | 1 | Visit(TD->getTypeForDecl()); | 634 | 4 | } |
|
635 | | |
636 | 12 | void VisitFriendDecl(const FriendDecl *D) { |
637 | 12 | if (!D->getFriendType()) |
638 | 7 | Visit(D->getFriendDecl()); |
639 | 12 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitFriendDecl(clang::FriendDecl const*) Line | Count | Source | 636 | 10 | void VisitFriendDecl(const FriendDecl *D) { | 637 | 10 | if (!D->getFriendType()) | 638 | 6 | Visit(D->getFriendDecl()); | 639 | 10 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitFriendDecl(clang::FriendDecl const*) Line | Count | Source | 636 | 2 | void VisitFriendDecl(const FriendDecl *D) { | 637 | 2 | if (!D->getFriendType()) | 638 | 1 | Visit(D->getFriendDecl()); | 639 | 2 | } |
|
640 | | |
641 | 193 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { |
642 | 193 | if (D->isThisDeclarationADefinition()) |
643 | 35 | dumpDeclContext(D); |
644 | 158 | else |
645 | 158 | for (const ParmVarDecl *Parameter : D->parameters()) |
646 | 59 | Visit(Parameter); |
647 | | |
648 | 193 | if (D->hasBody()) |
649 | 35 | Visit(D->getBody()); |
650 | 193 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCMethodDecl(clang::ObjCMethodDecl const*) Line | Count | Source | 641 | 178 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { | 642 | 178 | if (D->isThisDeclarationADefinition()) | 643 | 32 | dumpDeclContext(D); | 644 | 146 | else | 645 | 146 | for (const ParmVarDecl *Parameter : D->parameters()) | 646 | 54 | Visit(Parameter); | 647 | | | 648 | 178 | if (D->hasBody()) | 649 | 32 | Visit(D->getBody()); | 650 | 178 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCMethodDecl(clang::ObjCMethodDecl const*) Line | Count | Source | 641 | 15 | void VisitObjCMethodDecl(const ObjCMethodDecl *D) { | 642 | 15 | if (D->isThisDeclarationADefinition()) | 643 | 3 | dumpDeclContext(D); | 644 | 12 | else | 645 | 12 | for (const ParmVarDecl *Parameter : D->parameters()) | 646 | 5 | Visit(Parameter); | 647 | | | 648 | 15 | if (D->hasBody()) | 649 | 3 | Visit(D->getBody()); | 650 | 15 | } |
|
651 | | |
652 | 20 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { |
653 | 20 | dumpObjCTypeParamList(D->getTypeParamList()); |
654 | 20 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCCategoryDecl(clang::ObjCCategoryDecl const*) Line | Count | Source | 652 | 19 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { | 653 | 19 | dumpObjCTypeParamList(D->getTypeParamList()); | 654 | 19 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCCategoryDecl(clang::ObjCCategoryDecl const*) Line | Count | Source | 652 | 1 | void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) { | 653 | 1 | dumpObjCTypeParamList(D->getTypeParamList()); | 654 | 1 | } |
|
655 | | |
656 | 109 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { |
657 | 109 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); |
658 | 109 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCInterfaceDecl(clang::ObjCInterfaceDecl const*) Line | Count | Source | 656 | 105 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { | 657 | 105 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); | 658 | 105 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCInterfaceDecl(clang::ObjCInterfaceDecl const*) Line | Count | Source | 656 | 4 | void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) { | 657 | 4 | dumpObjCTypeParamList(D->getTypeParamListAsWritten()); | 658 | 4 | } |
|
659 | | |
660 | 28 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { |
661 | 28 | for (const auto &I : D->inits()) |
662 | 3 | Visit(I); |
663 | 28 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCImplementationDecl(clang::ObjCImplementationDecl const*) Line | Count | Source | 660 | 25 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { | 661 | 25 | for (const auto &I : D->inits()) | 662 | 3 | Visit(I); | 663 | 25 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCImplementationDecl(clang::ObjCImplementationDecl const*) Line | Count | Source | 660 | 3 | void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) { | 661 | 3 | for (const auto &I : D->inits()) | 662 | 0 | Visit(I); | 663 | 3 | } |
|
664 | | |
665 | 24 | void VisitBlockDecl(const BlockDecl *D) { |
666 | 24 | for (const auto &I : D->parameters()) |
667 | 3 | Visit(I); |
668 | | |
669 | 24 | for (const auto &I : D->captures()) |
670 | 11 | Visit(I); |
671 | 24 | Visit(D->getBody()); |
672 | 24 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBlockDecl(clang::BlockDecl const*) Line | Count | Source | 665 | 21 | void VisitBlockDecl(const BlockDecl *D) { | 666 | 21 | for (const auto &I : D->parameters()) | 667 | 2 | Visit(I); | 668 | | | 669 | 21 | for (const auto &I : D->captures()) | 670 | 8 | Visit(I); | 671 | 21 | Visit(D->getBody()); | 672 | 21 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBlockDecl(clang::BlockDecl const*) Line | Count | Source | 665 | 3 | void VisitBlockDecl(const BlockDecl *D) { | 666 | 3 | for (const auto &I : D->parameters()) | 667 | 1 | Visit(I); | 668 | | | 669 | 3 | for (const auto &I : D->captures()) | 670 | 3 | Visit(I); | 671 | 3 | Visit(D->getBody()); | 672 | 3 | } |
|
673 | | |
674 | 2.05k | void VisitDeclStmt(const DeclStmt *Node) { |
675 | 2.05k | for (const auto &D : Node->decls()) |
676 | 2.12k | Visit(D); |
677 | 2.05k | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitDeclStmt(clang::DeclStmt const*) Line | Count | Source | 674 | 92 | void VisitDeclStmt(const DeclStmt *Node) { | 675 | 92 | for (const auto &D : Node->decls()) | 676 | 104 | Visit(D); | 677 | 92 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitDeclStmt(clang::DeclStmt const*) Line | Count | Source | 674 | 1.96k | void VisitDeclStmt(const DeclStmt *Node) { | 675 | 1.96k | for (const auto &D : Node->decls()) | 676 | 2.01k | Visit(D); | 677 | 1.96k | } |
|
678 | | |
679 | 16 | void VisitAttributedStmt(const AttributedStmt *Node) { |
680 | 16 | for (const auto *A : Node->getAttrs()) |
681 | 20 | Visit(A); |
682 | 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 | 679 | 16 | void VisitAttributedStmt(const AttributedStmt *Node) { | 680 | 16 | for (const auto *A : Node->getAttrs()) | 681 | 20 | Visit(A); | 682 | 16 | } |
|
683 | | |
684 | 12 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { |
685 | 12 | Visit(Node->getExceptionDecl()); |
686 | 12 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCXXCatchStmt(clang::CXXCatchStmt const*) Line | Count | Source | 684 | 2 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { | 685 | 2 | Visit(Node->getExceptionDecl()); | 686 | 2 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCXXCatchStmt(clang::CXXCatchStmt const*) Line | Count | Source | 684 | 10 | void VisitCXXCatchStmt(const CXXCatchStmt *Node) { | 685 | 10 | Visit(Node->getExceptionDecl()); | 686 | 10 | } |
|
687 | | |
688 | 536 | void VisitCapturedStmt(const CapturedStmt *Node) { |
689 | 536 | Visit(Node->getCapturedDecl()); |
690 | 536 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCapturedStmt(clang::CapturedStmt const*) Line | Count | Source | 688 | 17 | void VisitCapturedStmt(const CapturedStmt *Node) { | 689 | 17 | Visit(Node->getCapturedDecl()); | 690 | 17 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCapturedStmt(clang::CapturedStmt const*) Line | Count | Source | 688 | 519 | void VisitCapturedStmt(const CapturedStmt *Node) { | 689 | 519 | Visit(Node->getCapturedDecl()); | 690 | 519 | } |
|
691 | | |
692 | 401 | void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) { |
693 | 401 | for (const auto *C : Node->clauses()) |
694 | 350 | Visit(C); |
695 | 401 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOMPExecutableDirective(clang::OMPExecutableDirective const*) Line | Count | Source | 692 | 12 | void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) { | 693 | 12 | for (const auto *C : Node->clauses()) | 694 | 2 | Visit(C); | 695 | 12 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOMPExecutableDirective(clang::OMPExecutableDirective const*) Line | Count | Source | 692 | 389 | void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) { | 693 | 389 | for (const auto *C : Node->clauses()) | 694 | 348 | Visit(C); | 695 | 389 | } |
|
696 | | |
697 | 293 | void VisitInitListExpr(const InitListExpr *ILE) { |
698 | 293 | if (auto *Filler = ILE->getArrayFiller()) { |
699 | 21 | Visit(Filler, "array_filler"); |
700 | 21 | } |
701 | 293 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitInitListExpr(clang::InitListExpr const*) Line | Count | Source | 697 | 10 | void VisitInitListExpr(const InitListExpr *ILE) { | 698 | 10 | if (auto *Filler = ILE->getArrayFiller()) { | 699 | 1 | Visit(Filler, "array_filler"); | 700 | 1 | } | 701 | 10 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitInitListExpr(clang::InitListExpr const*) Line | Count | Source | 697 | 283 | void VisitInitListExpr(const InitListExpr *ILE) { | 698 | 283 | if (auto *Filler = ILE->getArrayFiller()) { | 699 | 20 | Visit(Filler, "array_filler"); | 700 | 20 | } | 701 | 283 | } |
|
702 | | |
703 | 24 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitBlockExpr(clang::BlockExpr const*) Line | Count | Source | 703 | 3 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitBlockExpr(clang::BlockExpr const*) Line | Count | Source | 703 | 21 | void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); } |
|
704 | | |
705 | 158 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { |
706 | 158 | if (Expr *Source = Node->getSourceExpr()) |
707 | 158 | Visit(Source); |
708 | 158 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitOpaqueValueExpr(clang::OpaqueValueExpr const*) Line | Count | Source | 705 | 52 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { | 706 | 52 | if (Expr *Source = Node->getSourceExpr()) | 707 | 52 | Visit(Source); | 708 | 52 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitOpaqueValueExpr(clang::OpaqueValueExpr const*) Line | Count | Source | 705 | 106 | void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) { | 706 | 106 | if (Expr *Source = Node->getSourceExpr()) | 707 | 106 | Visit(Source); | 708 | 106 | } |
|
709 | | |
710 | 21 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { |
711 | 21 | Visit(E->getControllingExpr()); |
712 | 21 | Visit(E->getControllingExpr()->getType()); // FIXME: remove |
713 | | |
714 | 38 | for (const auto Assoc : E->associations()) { |
715 | 38 | Visit(Assoc); |
716 | 38 | } |
717 | 21 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitGenericSelectionExpr(clang::GenericSelectionExpr const*) Line | Count | Source | 710 | 7 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { | 711 | 7 | Visit(E->getControllingExpr()); | 712 | 7 | Visit(E->getControllingExpr()->getType()); // FIXME: remove | 713 | | | 714 | 12 | for (const auto Assoc : E->associations()) { | 715 | 12 | Visit(Assoc); | 716 | 12 | } | 717 | 7 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitGenericSelectionExpr(clang::GenericSelectionExpr const*) Line | Count | Source | 710 | 14 | void VisitGenericSelectionExpr(const GenericSelectionExpr *E) { | 711 | 14 | Visit(E->getControllingExpr()); | 712 | 14 | Visit(E->getControllingExpr()->getType()); // FIXME: remove | 713 | | | 714 | 26 | for (const auto Assoc : E->associations()) { | 715 | 26 | Visit(Assoc); | 716 | 26 | } | 717 | 14 | } |
|
718 | | |
719 | 3 | void VisitRequiresExpr(const RequiresExpr *E) { |
720 | 3 | for (auto *D : E->getLocalParameters()) |
721 | 3 | Visit(D); |
722 | 3 | for (auto *R : E->getRequirements()) |
723 | 12 | Visit(R); |
724 | 3 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitRequiresExpr(clang::RequiresExpr const*) Line | Count | Source | 719 | 1 | void VisitRequiresExpr(const RequiresExpr *E) { | 720 | 1 | for (auto *D : E->getLocalParameters()) | 721 | 1 | Visit(D); | 722 | 1 | for (auto *R : E->getRequirements()) | 723 | 4 | Visit(R); | 724 | 1 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitRequiresExpr(clang::RequiresExpr const*) Line | Count | Source | 719 | 2 | void VisitRequiresExpr(const RequiresExpr *E) { | 720 | 2 | for (auto *D : E->getLocalParameters()) | 721 | 2 | Visit(D); | 722 | 2 | for (auto *R : E->getRequirements()) | 723 | 8 | Visit(R); | 724 | 2 | } |
|
725 | | |
726 | 158 | void VisitLambdaExpr(const LambdaExpr *Node) { |
727 | 158 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { |
728 | 0 | for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) { |
729 | 0 | const auto *C = Node->capture_begin() + I; |
730 | 0 | if (!C->isExplicit()) |
731 | 0 | continue; |
732 | 0 | if (Node->isInitCapture(C)) |
733 | 0 | Visit(C->getCapturedVar()); |
734 | 0 | else |
735 | 0 | Visit(Node->capture_init_begin()[I]); |
736 | 0 | } |
737 | 0 | dumpTemplateParameters(Node->getTemplateParameterList()); |
738 | 0 | for (const auto *P : Node->getCallOperator()->parameters()) |
739 | 0 | Visit(P); |
740 | 0 | Visit(Node->getBody()); |
741 | 158 | } else { |
742 | 158 | return Visit(Node->getLambdaClass()); |
743 | 158 | } |
744 | 158 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitLambdaExpr(clang::LambdaExpr const*) Line | Count | Source | 726 | 17 | void VisitLambdaExpr(const LambdaExpr *Node) { | 727 | 17 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { | 728 | 0 | for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) { | 729 | 0 | const auto *C = Node->capture_begin() + I; | 730 | 0 | if (!C->isExplicit()) | 731 | 0 | continue; | 732 | 0 | if (Node->isInitCapture(C)) | 733 | 0 | Visit(C->getCapturedVar()); | 734 | 0 | else | 735 | 0 | Visit(Node->capture_init_begin()[I]); | 736 | 0 | } | 737 | 0 | dumpTemplateParameters(Node->getTemplateParameterList()); | 738 | 0 | for (const auto *P : Node->getCallOperator()->parameters()) | 739 | 0 | Visit(P); | 740 | 0 | Visit(Node->getBody()); | 741 | 17 | } else { | 742 | 17 | return Visit(Node->getLambdaClass()); | 743 | 17 | } | 744 | 17 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitLambdaExpr(clang::LambdaExpr const*) Line | Count | Source | 726 | 141 | void VisitLambdaExpr(const LambdaExpr *Node) { | 727 | 141 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { | 728 | 0 | for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) { | 729 | 0 | const auto *C = Node->capture_begin() + I; | 730 | 0 | if (!C->isExplicit()) | 731 | 0 | continue; | 732 | 0 | if (Node->isInitCapture(C)) | 733 | 0 | Visit(C->getCapturedVar()); | 734 | 0 | else | 735 | 0 | Visit(Node->capture_init_begin()[I]); | 736 | 0 | } | 737 | 0 | dumpTemplateParameters(Node->getTemplateParameterList()); | 738 | 0 | for (const auto *P : Node->getCallOperator()->parameters()) | 739 | 0 | Visit(P); | 740 | 0 | Visit(Node->getBody()); | 741 | 141 | } else { | 742 | 141 | return Visit(Node->getLambdaClass()); | 743 | 141 | } | 744 | 141 | } |
|
745 | | |
746 | 13 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { |
747 | 13 | if (Node->isPartiallySubstituted()) |
748 | 0 | for (const auto &A : Node->getPartialArguments()) |
749 | 0 | Visit(A); |
750 | 13 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSizeOfPackExpr(clang::SizeOfPackExpr const*) Line | Count | Source | 746 | 1 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { | 747 | 1 | if (Node->isPartiallySubstituted()) | 748 | 0 | for (const auto &A : Node->getPartialArguments()) | 749 | 0 | Visit(A); | 750 | 1 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSizeOfPackExpr(clang::SizeOfPackExpr const*) Line | Count | Source | 746 | 12 | void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) { | 747 | 12 | if (Node->isPartiallySubstituted()) | 748 | 0 | for (const auto &A : Node->getPartialArguments()) | 749 | 0 | Visit(A); | 750 | 12 | } |
|
751 | | |
752 | 68 | void VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E) { |
753 | 68 | Visit(E->getParameter()); |
754 | 68 | } Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitSubstNonTypeTemplateParmExpr(clang::SubstNonTypeTemplateParmExpr const*) clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitSubstNonTypeTemplateParmExpr(clang::SubstNonTypeTemplateParmExpr const*) Line | Count | Source | 752 | 68 | void VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E) { | 753 | 68 | Visit(E->getParameter()); | 754 | 68 | } |
|
755 | | void VisitSubstNonTypeTemplateParmPackExpr( |
756 | 1 | const SubstNonTypeTemplateParmPackExpr *E) { |
757 | 1 | Visit(E->getParameterPack()); |
758 | 1 | Visit(E->getArgumentPack()); |
759 | 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 | 756 | 1 | const SubstNonTypeTemplateParmPackExpr *E) { | 757 | 1 | Visit(E->getParameterPack()); | 758 | 1 | Visit(E->getArgumentPack()); | 759 | 1 | } |
|
760 | | |
761 | 11 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { |
762 | 11 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) |
763 | 8 | Visit(CatchParam); |
764 | 11 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitObjCAtCatchStmt(clang::ObjCAtCatchStmt const*) Line | Count | Source | 761 | 2 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { | 762 | 2 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) | 763 | 1 | Visit(CatchParam); | 764 | 2 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitObjCAtCatchStmt(clang::ObjCAtCatchStmt const*) Line | Count | Source | 761 | 9 | void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) { | 762 | 9 | if (const VarDecl *CatchParam = Node->getCatchParamDecl()) | 763 | 7 | Visit(CatchParam); | 764 | 9 | } |
|
765 | | |
766 | 14 | void VisitCXXForRangeStmt(const CXXForRangeStmt *Node) { |
767 | 14 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { |
768 | 0 | Visit(Node->getInit()); |
769 | 0 | Visit(Node->getLoopVariable()); |
770 | 0 | Visit(Node->getRangeInit()); |
771 | 0 | Visit(Node->getBody()); |
772 | 0 | } |
773 | 14 | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCXXForRangeStmt(clang::CXXForRangeStmt const*) Line | Count | Source | 766 | 3 | void VisitCXXForRangeStmt(const CXXForRangeStmt *Node) { | 767 | 3 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { | 768 | 0 | Visit(Node->getInit()); | 769 | 0 | Visit(Node->getLoopVariable()); | 770 | 0 | Visit(Node->getRangeInit()); | 771 | 0 | Visit(Node->getBody()); | 772 | 0 | } | 773 | 3 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCXXForRangeStmt(clang::CXXForRangeStmt const*) Line | Count | Source | 766 | 11 | void VisitCXXForRangeStmt(const CXXForRangeStmt *Node) { | 767 | 11 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { | 768 | 0 | Visit(Node->getInit()); | 769 | 0 | Visit(Node->getLoopVariable()); | 770 | 0 | Visit(Node->getRangeInit()); | 771 | 0 | Visit(Node->getBody()); | 772 | 0 | } | 773 | 11 | } |
|
774 | | |
775 | 1.19k | void VisitCallExpr(const CallExpr *Node) { |
776 | 1.19k | for (const auto *Child : |
777 | 1.86k | make_filter_range(Node->children(), [this](const Stmt *Child) { |
778 | 1.86k | if (Traversal != TK_IgnoreUnlessSpelledInSource) |
779 | 1.86k | return false; |
780 | 0 | return !isa<CXXDefaultArgExpr>(Child); |
781 | 1.86k | })) { clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCallExpr(clang::CallExpr const*)::'lambda'(clang::Stmt const*)::operator()(clang::Stmt const*) const Line | Count | Source | 777 | 86 | make_filter_range(Node->children(), [this](const Stmt *Child) { | 778 | 86 | if (Traversal != TK_IgnoreUnlessSpelledInSource) | 779 | 86 | return false; | 780 | 0 | return !isa<CXXDefaultArgExpr>(Child); | 781 | 86 | })) { |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCallExpr(clang::CallExpr const*)::'lambda'(clang::Stmt const*)::operator()(clang::Stmt const*) const Line | Count | Source | 777 | 1.77k | make_filter_range(Node->children(), [this](const Stmt *Child) { | 778 | 1.77k | if (Traversal != TK_IgnoreUnlessSpelledInSource) | 779 | 1.77k | return false; | 780 | 0 | return !isa<CXXDefaultArgExpr>(Child); | 781 | 1.77k | })) { |
|
782 | 0 | Visit(Child); |
783 | 0 | } |
784 | 1.19k | } clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitCallExpr(clang::CallExpr const*) Line | Count | Source | 775 | 56 | void VisitCallExpr(const CallExpr *Node) { | 776 | 56 | for (const auto *Child : | 777 | 56 | make_filter_range(Node->children(), [this](const Stmt *Child) { | 778 | 56 | if (Traversal != TK_IgnoreUnlessSpelledInSource) | 779 | 56 | return false; | 780 | 56 | return !isa<CXXDefaultArgExpr>(Child); | 781 | 56 | })) { | 782 | 0 | Visit(Child); | 783 | 0 | } | 784 | 56 | } |
clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitCallExpr(clang::CallExpr const*) Line | Count | Source | 775 | 1.13k | void VisitCallExpr(const CallExpr *Node) { | 776 | 1.13k | for (const auto *Child : | 777 | 1.13k | make_filter_range(Node->children(), [this](const Stmt *Child) { | 778 | 1.13k | if (Traversal != TK_IgnoreUnlessSpelledInSource) | 779 | 1.13k | return false; | 780 | 1.13k | return !isa<CXXDefaultArgExpr>(Child); | 781 | 1.13k | })) { | 782 | 0 | Visit(Child); | 783 | 0 | } | 784 | 1.13k | } |
|
785 | | |
786 | 0 | void VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *Node) { |
787 | 0 | if (Traversal == TK_IgnoreUnlessSpelledInSource) { |
788 | 0 | Visit(Node->getLHS()); |
789 | 0 | Visit(Node->getRHS()); |
790 | 0 | } else { |
791 | 0 | ConstStmtVisitor<Derived>::VisitCXXRewrittenBinaryOperator(Node); |
792 | 0 | } |
793 | 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*) |
794 | | |
795 | 50 | void VisitExpressionTemplateArgument(const TemplateArgument &TA) { |
796 | 50 | Visit(TA.getAsExpr()); |
797 | 50 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitExpressionTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 795 | 50 | void VisitExpressionTemplateArgument(const TemplateArgument &TA) { | 796 | 50 | Visit(TA.getAsExpr()); | 797 | 50 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitExpressionTemplateArgument(clang::TemplateArgument const&) |
798 | | |
799 | 499 | void VisitTypeTemplateArgument(const TemplateArgument &TA) { |
800 | 499 | Visit(TA.getAsType()); |
801 | 499 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitTypeTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 799 | 474 | void VisitTypeTemplateArgument(const TemplateArgument &TA) { | 800 | 474 | Visit(TA.getAsType()); | 801 | 474 | } |
clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitTypeTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 799 | 25 | void VisitTypeTemplateArgument(const TemplateArgument &TA) { | 800 | 25 | Visit(TA.getAsType()); | 801 | 25 | } |
|
802 | | |
803 | 46 | void VisitPackTemplateArgument(const TemplateArgument &TA) { |
804 | 46 | for (const auto &TArg : TA.pack_elements()) |
805 | 93 | Visit(TArg); |
806 | 46 | } clang::ASTNodeTraverser<clang::ASTDumper, clang::TextNodeDumper>::VisitPackTemplateArgument(clang::TemplateArgument const&) Line | Count | Source | 803 | 46 | void VisitPackTemplateArgument(const TemplateArgument &TA) { | 804 | 46 | for (const auto &TArg : TA.pack_elements()) | 805 | 93 | Visit(TArg); | 806 | 46 | } |
Unexecuted instantiation: clang::ASTNodeTraverser<clang::JSONDumper, clang::JSONNodeDumper>::VisitPackTemplateArgument(clang::TemplateArgument const&) |
807 | | |
808 | | // Implements Visit methods for Attrs. |
809 | | #include "clang/AST/AttrNodeTraverse.inc" |
810 | | }; |
811 | | |
812 | | } // namespace clang |
813 | | |
814 | | #endif // LLVM_CLANG_AST_ASTNODETRAVERSER_H |