1 //===- Nodes.cpp ----------------------------------------------*- C++ -*-=====//
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 #include "clang/Tooling/Syntax/Nodes.h"
9 #include "clang/Basic/TokenKinds.h"
10 
11 using namespace clang;
12 
13 llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) {
14   switch (K) {
15   case NodeKind::Leaf:
16     return OS << "Leaf";
17   case NodeKind::TranslationUnit:
18     return OS << "TranslationUnit";
19   case NodeKind::UnknownExpression:
20     return OS << "UnknownExpression";
21   case NodeKind::UnknownStatement:
22     return OS << "UnknownStatement";
23   case NodeKind::DeclarationStatement:
24     return OS << "DeclarationStatement";
25   case NodeKind::EmptyStatement:
26     return OS << "EmptyStatement";
27   case NodeKind::SwitchStatement:
28     return OS << "SwitchStatement";
29   case NodeKind::CaseStatement:
30     return OS << "CaseStatement";
31   case NodeKind::DefaultStatement:
32     return OS << "DefaultStatement";
33   case NodeKind::IfStatement:
34     return OS << "IfStatement";
35   case NodeKind::ForStatement:
36     return OS << "ForStatement";
37   case NodeKind::WhileStatement:
38     return OS << "WhileStatement";
39   case NodeKind::ContinueStatement:
40     return OS << "ContinueStatement";
41   case NodeKind::BreakStatement:
42     return OS << "BreakStatement";
43   case NodeKind::ReturnStatement:
44     return OS << "ReturnStatement";
45   case NodeKind::RangeBasedForStatement:
46     return OS << "RangeBasedForStatement";
47   case NodeKind::ExpressionStatement:
48     return OS << "ExpressionStatement";
49   case NodeKind::CompoundStatement:
50     return OS << "CompoundStatement";
51   case NodeKind::UnknownDeclaration:
52     return OS << "UnknownDeclaration";
53   case NodeKind::EmptyDeclaration:
54     return OS << "EmptyDeclaration";
55   case NodeKind::StaticAssertDeclaration:
56     return OS << "StaticAssertDeclaration";
57   case NodeKind::LinkageSpecificationDeclaration:
58     return OS << "LinkageSpecificationDeclaration";
59   case NodeKind::SimpleDeclaration:
60     return OS << "SimpleDeclaration";
61   case NodeKind::NamespaceDefinition:
62     return OS << "NamespaceDefinition";
63   case NodeKind::NamespaceAliasDefinition:
64     return OS << "NamespaceAliasDefinition";
65   case NodeKind::UsingNamespaceDirective:
66     return OS << "UsingNamespaceDirective";
67   case NodeKind::UsingDeclaration:
68     return OS << "UsingDeclaration";
69   case NodeKind::TypeAliasDeclaration:
70     return OS << "TypeAliasDeclaration";
71   case NodeKind::SimpleDeclarator:
72     return OS << "SimpleDeclarator";
73   case NodeKind::ParenDeclarator:
74     return OS << "ParenDeclarator";
75   case NodeKind::ArraySubscript:
76     return OS << "ArraySubscript";
77   case NodeKind::TrailingReturnType:
78     return OS << "TrailingReturnType";
79   case NodeKind::ParametersAndQualifiers:
80     return OS << "ParametersAndQualifiers";
81   case NodeKind::MemberPointer:
82     return OS << "MemberPointer";
83   }
84   llvm_unreachable("unknown node kind");
85 }
86 
87 llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeRole R) {
88   switch (R) {
89   case syntax::NodeRole::Detached:
90     return OS << "Detached";
91   case syntax::NodeRole::Unknown:
92     return OS << "Unknown";
93   case syntax::NodeRole::OpenParen:
94     return OS << "OpenParen";
95   case syntax::NodeRole::CloseParen:
96     return OS << "CloseParen";
97   case syntax::NodeRole::IntroducerKeyword:
98     return OS << "IntroducerKeyword";
99   case syntax::NodeRole::BodyStatement:
100     return OS << "BodyStatement";
101   case syntax::NodeRole::CaseStatement_value:
102     return OS << "CaseStatement_value";
103   case syntax::NodeRole::IfStatement_thenStatement:
104     return OS << "IfStatement_thenStatement";
105   case syntax::NodeRole::IfStatement_elseKeyword:
106     return OS << "IfStatement_elseKeyword";
107   case syntax::NodeRole::IfStatement_elseStatement:
108     return OS << "IfStatement_elseStatement";
109   case syntax::NodeRole::ReturnStatement_value:
110     return OS << "ReturnStatement_value";
111   case syntax::NodeRole::ExpressionStatement_expression:
112     return OS << "ExpressionStatement_expression";
113   case syntax::NodeRole::CompoundStatement_statement:
114     return OS << "CompoundStatement_statement";
115   case syntax::NodeRole::StaticAssertDeclaration_condition:
116     return OS << "StaticAssertDeclaration_condition";
117   case syntax::NodeRole::StaticAssertDeclaration_message:
118     return OS << "StaticAssertDeclaration_message";
119   case syntax::NodeRole::SimpleDeclaration_declarator:
120     return OS << "SimpleDeclaration_declarator";
121   case syntax::NodeRole::ArraySubscript_sizeExpression:
122     return OS << "ArraySubscript_sizeExpression";
123   case syntax::NodeRole::TrailingReturnType_arrow:
124     return OS << "TrailingReturnType_arrow";
125   case syntax::NodeRole::TrailingReturnType_declarator:
126     return OS << "TrailingReturnType_declarator";
127   case syntax::NodeRole::ParametersAndQualifiers_parameter:
128     return OS << "ParametersAndQualifiers_parameter";
129   case syntax::NodeRole::ParametersAndQualifiers_trailingReturn:
130     return OS << "ParametersAndQualifiers_trailingReturn";
131   }
132   llvm_unreachable("invalid role");
133 }
134 
135 syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
136   return llvm::cast_or_null<syntax::Leaf>(
137       findChild(syntax::NodeRole::IntroducerKeyword));
138 }
139 
140 syntax::Statement *syntax::SwitchStatement::body() {
141   return llvm::cast_or_null<syntax::Statement>(
142       findChild(syntax::NodeRole::BodyStatement));
143 }
144 
145 syntax::Leaf *syntax::CaseStatement::caseKeyword() {
146   return llvm::cast_or_null<syntax::Leaf>(
147       findChild(syntax::NodeRole::IntroducerKeyword));
148 }
149 
150 syntax::Expression *syntax::CaseStatement::value() {
151   return llvm::cast_or_null<syntax::Expression>(
152       findChild(syntax::NodeRole::CaseStatement_value));
153 }
154 
155 syntax::Statement *syntax::CaseStatement::body() {
156   return llvm::cast_or_null<syntax::Statement>(
157       findChild(syntax::NodeRole::BodyStatement));
158 }
159 
160 syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {
161   return llvm::cast_or_null<syntax::Leaf>(
162       findChild(syntax::NodeRole::IntroducerKeyword));
163 }
164 
165 syntax::Statement *syntax::DefaultStatement::body() {
166   return llvm::cast_or_null<syntax::Statement>(
167       findChild(syntax::NodeRole::BodyStatement));
168 }
169 
170 syntax::Leaf *syntax::IfStatement::ifKeyword() {
171   return llvm::cast_or_null<syntax::Leaf>(
172       findChild(syntax::NodeRole::IntroducerKeyword));
173 }
174 
175 syntax::Statement *syntax::IfStatement::thenStatement() {
176   return llvm::cast_or_null<syntax::Statement>(
177       findChild(syntax::NodeRole::IfStatement_thenStatement));
178 }
179 
180 syntax::Leaf *syntax::IfStatement::elseKeyword() {
181   return llvm::cast_or_null<syntax::Leaf>(
182       findChild(syntax::NodeRole::IfStatement_elseKeyword));
183 }
184 
185 syntax::Statement *syntax::IfStatement::elseStatement() {
186   return llvm::cast_or_null<syntax::Statement>(
187       findChild(syntax::NodeRole::IfStatement_elseStatement));
188 }
189 
190 syntax::Leaf *syntax::ForStatement::forKeyword() {
191   return llvm::cast_or_null<syntax::Leaf>(
192       findChild(syntax::NodeRole::IntroducerKeyword));
193 }
194 
195 syntax::Statement *syntax::ForStatement::body() {
196   return llvm::cast_or_null<syntax::Statement>(
197       findChild(syntax::NodeRole::BodyStatement));
198 }
199 
200 syntax::Leaf *syntax::WhileStatement::whileKeyword() {
201   return llvm::cast_or_null<syntax::Leaf>(
202       findChild(syntax::NodeRole::IntroducerKeyword));
203 }
204 
205 syntax::Statement *syntax::WhileStatement::body() {
206   return llvm::cast_or_null<syntax::Statement>(
207       findChild(syntax::NodeRole::BodyStatement));
208 }
209 
210 syntax::Leaf *syntax::ContinueStatement::continueKeyword() {
211   return llvm::cast_or_null<syntax::Leaf>(
212       findChild(syntax::NodeRole::IntroducerKeyword));
213 }
214 
215 syntax::Leaf *syntax::BreakStatement::breakKeyword() {
216   return llvm::cast_or_null<syntax::Leaf>(
217       findChild(syntax::NodeRole::IntroducerKeyword));
218 }
219 
220 syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
221   return llvm::cast_or_null<syntax::Leaf>(
222       findChild(syntax::NodeRole::IntroducerKeyword));
223 }
224 
225 syntax::Expression *syntax::ReturnStatement::value() {
226   return llvm::cast_or_null<syntax::Expression>(
227       findChild(syntax::NodeRole::ReturnStatement_value));
228 }
229 
230 syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {
231   return llvm::cast_or_null<syntax::Leaf>(
232       findChild(syntax::NodeRole::IntroducerKeyword));
233 }
234 
235 syntax::Statement *syntax::RangeBasedForStatement::body() {
236   return llvm::cast_or_null<syntax::Statement>(
237       findChild(syntax::NodeRole::BodyStatement));
238 }
239 
240 syntax::Expression *syntax::ExpressionStatement::expression() {
241   return llvm::cast_or_null<syntax::Expression>(
242       findChild(syntax::NodeRole::ExpressionStatement_expression));
243 }
244 
245 syntax::Leaf *syntax::CompoundStatement::lbrace() {
246   return llvm::cast_or_null<syntax::Leaf>(
247       findChild(syntax::NodeRole::OpenParen));
248 }
249 
250 std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
251   std::vector<syntax::Statement *> Children;
252   for (auto *C = firstChild(); C; C = C->nextSibling()) {
253     if (C->role() == syntax::NodeRole::CompoundStatement_statement)
254       Children.push_back(llvm::cast<syntax::Statement>(C));
255   }
256   return Children;
257 }
258 
259 syntax::Leaf *syntax::CompoundStatement::rbrace() {
260   return llvm::cast_or_null<syntax::Leaf>(
261       findChild(syntax::NodeRole::CloseParen));
262 }
263 
264 syntax::Expression *syntax::StaticAssertDeclaration::condition() {
265   return llvm::cast_or_null<syntax::Expression>(
266       findChild(syntax::NodeRole::StaticAssertDeclaration_condition));
267 }
268 
269 syntax::Expression *syntax::StaticAssertDeclaration::message() {
270   return llvm::cast_or_null<syntax::Expression>(
271       findChild(syntax::NodeRole::StaticAssertDeclaration_message));
272 }
273 
274 std::vector<syntax::SimpleDeclarator *>
275 syntax::SimpleDeclaration::declarators() {
276   std::vector<syntax::SimpleDeclarator *> Children;
277   for (auto *C = firstChild(); C; C = C->nextSibling()) {
278     if (C->role() == syntax::NodeRole::SimpleDeclaration_declarator)
279       Children.push_back(llvm::cast<syntax::SimpleDeclarator>(C));
280   }
281   return Children;
282 }
283 
284 syntax::Leaf *syntax::ParenDeclarator::lparen() {
285   return llvm::cast_or_null<syntax::Leaf>(
286       findChild(syntax::NodeRole::OpenParen));
287 }
288 
289 syntax::Leaf *syntax::ParenDeclarator::rparen() {
290   return llvm::cast_or_null<syntax::Leaf>(
291       findChild(syntax::NodeRole::CloseParen));
292 }
293 
294 syntax::Leaf *syntax::ArraySubscript::lbracket() {
295   return llvm::cast_or_null<syntax::Leaf>(
296       findChild(syntax::NodeRole::OpenParen));
297 }
298 
299 syntax::Expression *syntax::ArraySubscript::sizeExpression() {
300   return llvm::cast_or_null<syntax::Expression>(
301       findChild(syntax::NodeRole::ArraySubscript_sizeExpression));
302 }
303 
304 syntax::Leaf *syntax::ArraySubscript::rbracket() {
305   return llvm::cast_or_null<syntax::Leaf>(
306       findChild(syntax::NodeRole::CloseParen));
307 }
308 
309 syntax::Leaf *syntax::TrailingReturnType::arrow() {
310   return llvm::cast_or_null<syntax::Leaf>(
311       findChild(syntax::NodeRole::TrailingReturnType_arrow));
312 }
313 
314 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
315   return llvm::cast_or_null<syntax::SimpleDeclarator>(
316       findChild(syntax::NodeRole::TrailingReturnType_declarator));
317 }
318 
319 syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
320   return llvm::cast_or_null<syntax::Leaf>(
321       findChild(syntax::NodeRole::OpenParen));
322 }
323 
324 std::vector<syntax::SimpleDeclaration *>
325 syntax::ParametersAndQualifiers::parameters() {
326   std::vector<syntax::SimpleDeclaration *> Children;
327   for (auto *C = firstChild(); C; C = C->nextSibling()) {
328     if (C->role() == syntax::NodeRole::ParametersAndQualifiers_parameter)
329       Children.push_back(llvm::cast<syntax::SimpleDeclaration>(C));
330   }
331   return Children;
332 }
333 
334 syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
335   return llvm::cast_or_null<syntax::Leaf>(
336       findChild(syntax::NodeRole::CloseParen));
337 }
338 
339 syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
340   return llvm::cast_or_null<syntax::TrailingReturnType>(
341       findChild(syntax::NodeRole::ParametersAndQualifiers_trailingReturn));
342 }
343