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 raw_ostream &syntax::operator<<(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::ParenExpression:
22     return OS << "ParenExpression";
23   case NodeKind::IntegerLiteralExpression:
24     return OS << "IntegerLiteralExpression";
25   case NodeKind::CharacterLiteralExpression:
26     return OS << "CharacterLiteralExpression";
27   case NodeKind::FloatingLiteralExpression:
28     return OS << "FloatingLiteralExpression";
29   case NodeKind::StringLiteralExpression:
30     return OS << "StringLiteralExpression";
31   case NodeKind::BoolLiteralExpression:
32     return OS << "BoolLiteralExpression";
33   case NodeKind::CxxNullPtrExpression:
34     return OS << "CxxNullPtrExpression";
35   case NodeKind::IntegerUserDefinedLiteralExpression:
36     return OS << "IntegerUserDefinedLiteralExpression";
37   case NodeKind::FloatUserDefinedLiteralExpression:
38     return OS << "FloatUserDefinedLiteralExpression";
39   case NodeKind::CharUserDefinedLiteralExpression:
40     return OS << "CharUserDefinedLiteralExpression";
41   case NodeKind::StringUserDefinedLiteralExpression:
42     return OS << "StringUserDefinedLiteralExpression";
43   case NodeKind::PrefixUnaryOperatorExpression:
44     return OS << "PrefixUnaryOperatorExpression";
45   case NodeKind::PostfixUnaryOperatorExpression:
46     return OS << "PostfixUnaryOperatorExpression";
47   case NodeKind::BinaryOperatorExpression:
48     return OS << "BinaryOperatorExpression";
49   case NodeKind::UnqualifiedId:
50     return OS << "UnqualifiedId";
51   case NodeKind::IdExpression:
52     return OS << "IdExpression";
53   case NodeKind::UnknownStatement:
54     return OS << "UnknownStatement";
55   case NodeKind::DeclarationStatement:
56     return OS << "DeclarationStatement";
57   case NodeKind::EmptyStatement:
58     return OS << "EmptyStatement";
59   case NodeKind::SwitchStatement:
60     return OS << "SwitchStatement";
61   case NodeKind::CaseStatement:
62     return OS << "CaseStatement";
63   case NodeKind::DefaultStatement:
64     return OS << "DefaultStatement";
65   case NodeKind::IfStatement:
66     return OS << "IfStatement";
67   case NodeKind::ForStatement:
68     return OS << "ForStatement";
69   case NodeKind::WhileStatement:
70     return OS << "WhileStatement";
71   case NodeKind::ContinueStatement:
72     return OS << "ContinueStatement";
73   case NodeKind::BreakStatement:
74     return OS << "BreakStatement";
75   case NodeKind::ReturnStatement:
76     return OS << "ReturnStatement";
77   case NodeKind::RangeBasedForStatement:
78     return OS << "RangeBasedForStatement";
79   case NodeKind::ExpressionStatement:
80     return OS << "ExpressionStatement";
81   case NodeKind::CompoundStatement:
82     return OS << "CompoundStatement";
83   case NodeKind::UnknownDeclaration:
84     return OS << "UnknownDeclaration";
85   case NodeKind::EmptyDeclaration:
86     return OS << "EmptyDeclaration";
87   case NodeKind::StaticAssertDeclaration:
88     return OS << "StaticAssertDeclaration";
89   case NodeKind::LinkageSpecificationDeclaration:
90     return OS << "LinkageSpecificationDeclaration";
91   case NodeKind::SimpleDeclaration:
92     return OS << "SimpleDeclaration";
93   case NodeKind::TemplateDeclaration:
94     return OS << "TemplateDeclaration";
95   case NodeKind::ExplicitTemplateInstantiation:
96     return OS << "ExplicitTemplateInstantiation";
97   case NodeKind::NamespaceDefinition:
98     return OS << "NamespaceDefinition";
99   case NodeKind::NamespaceAliasDefinition:
100     return OS << "NamespaceAliasDefinition";
101   case NodeKind::UsingNamespaceDirective:
102     return OS << "UsingNamespaceDirective";
103   case NodeKind::UsingDeclaration:
104     return OS << "UsingDeclaration";
105   case NodeKind::TypeAliasDeclaration:
106     return OS << "TypeAliasDeclaration";
107   case NodeKind::SimpleDeclarator:
108     return OS << "SimpleDeclarator";
109   case NodeKind::ParenDeclarator:
110     return OS << "ParenDeclarator";
111   case NodeKind::ArraySubscript:
112     return OS << "ArraySubscript";
113   case NodeKind::TrailingReturnType:
114     return OS << "TrailingReturnType";
115   case NodeKind::ParametersAndQualifiers:
116     return OS << "ParametersAndQualifiers";
117   case NodeKind::MemberPointer:
118     return OS << "MemberPointer";
119   case NodeKind::GlobalNameSpecifier:
120     return OS << "GlobalNameSpecifier";
121   case NodeKind::DecltypeNameSpecifier:
122     return OS << "DecltypeNameSpecifier";
123   case NodeKind::IdentifierNameSpecifier:
124     return OS << "IdentifierNameSpecifier";
125   case NodeKind::SimpleTemplateNameSpecifier:
126     return OS << "SimpleTemplateNameSpecifier";
127   case NodeKind::NestedNameSpecifier:
128     return OS << "NestedNameSpecifier";
129   }
130   llvm_unreachable("unknown node kind");
131 }
132 
133 raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
134   switch (R) {
135   case syntax::NodeRole::Detached:
136     return OS << "Detached";
137   case syntax::NodeRole::Unknown:
138     return OS << "Unknown";
139   case syntax::NodeRole::OpenParen:
140     return OS << "OpenParen";
141   case syntax::NodeRole::CloseParen:
142     return OS << "CloseParen";
143   case syntax::NodeRole::IntroducerKeyword:
144     return OS << "IntroducerKeyword";
145   case syntax::NodeRole::LiteralToken:
146     return OS << "LiteralToken";
147   case syntax::NodeRole::ArrowToken:
148     return OS << "ArrowToken";
149   case syntax::NodeRole::ExternKeyword:
150     return OS << "ExternKeyword";
151   case syntax::NodeRole::TemplateKeyword:
152     return OS << "TemplateKeyword";
153   case syntax::NodeRole::BodyStatement:
154     return OS << "BodyStatement";
155   case syntax::NodeRole::CaseStatement_value:
156     return OS << "CaseStatement_value";
157   case syntax::NodeRole::IfStatement_thenStatement:
158     return OS << "IfStatement_thenStatement";
159   case syntax::NodeRole::IfStatement_elseKeyword:
160     return OS << "IfStatement_elseKeyword";
161   case syntax::NodeRole::IfStatement_elseStatement:
162     return OS << "IfStatement_elseStatement";
163   case syntax::NodeRole::OperatorExpression_operatorToken:
164     return OS << "OperatorExpression_operatorToken";
165   case syntax::NodeRole::UnaryOperatorExpression_operand:
166     return OS << "UnaryOperatorExpression_operand";
167   case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
168     return OS << "BinaryOperatorExpression_leftHandSide";
169   case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
170     return OS << "BinaryOperatorExpression_rightHandSide";
171   case syntax::NodeRole::ReturnStatement_value:
172     return OS << "ReturnStatement_value";
173   case syntax::NodeRole::ExpressionStatement_expression:
174     return OS << "ExpressionStatement_expression";
175   case syntax::NodeRole::CompoundStatement_statement:
176     return OS << "CompoundStatement_statement";
177   case syntax::NodeRole::StaticAssertDeclaration_condition:
178     return OS << "StaticAssertDeclaration_condition";
179   case syntax::NodeRole::StaticAssertDeclaration_message:
180     return OS << "StaticAssertDeclaration_message";
181   case syntax::NodeRole::SimpleDeclaration_declarator:
182     return OS << "SimpleDeclaration_declarator";
183   case syntax::NodeRole::TemplateDeclaration_declaration:
184     return OS << "TemplateDeclaration_declaration";
185   case syntax::NodeRole::ExplicitTemplateInstantiation_declaration:
186     return OS << "ExplicitTemplateInstantiation_declaration";
187   case syntax::NodeRole::ArraySubscript_sizeExpression:
188     return OS << "ArraySubscript_sizeExpression";
189   case syntax::NodeRole::TrailingReturnType_declarator:
190     return OS << "TrailingReturnType_declarator";
191   case syntax::NodeRole::ParametersAndQualifiers_parameter:
192     return OS << "ParametersAndQualifiers_parameter";
193   case syntax::NodeRole::ParametersAndQualifiers_trailingReturn:
194     return OS << "ParametersAndQualifiers_trailingReturn";
195   case syntax::NodeRole::IdExpression_id:
196     return OS << "IdExpression_id";
197   case syntax::NodeRole::IdExpression_qualifier:
198     return OS << "IdExpression_qualifier";
199   case syntax::NodeRole::NestedNameSpecifier_specifier:
200     return OS << "NestedNameSpecifier_specifier";
201   case syntax::NodeRole::NestedNameSpecifier_delimiter:
202     return OS << "NestedNameSpecifier_delimiter";
203   case syntax::NodeRole::ParenExpression_subExpression:
204     return OS << "ParenExpression_subExpression";
205   }
206   llvm_unreachable("invalid role");
207 }
208 
209 std::vector<syntax::Leaf *> syntax::NestedNameSpecifier::delimiters() {
210   std::vector<syntax::Leaf *> Children;
211   for (auto *C = firstChild(); C; C = C->nextSibling()) {
212     assert(C->role() == syntax::NodeRole::NestedNameSpecifier_delimiter);
213     Children.push_back(llvm::cast<syntax::Leaf>(C));
214   }
215   return Children;
216 }
217 
218 std::vector<syntax::NameSpecifier *> syntax::NestedNameSpecifier::specifiers() {
219   std::vector<syntax::NameSpecifier *> Children;
220   for (auto *C = firstChild(); C; C = C->nextSibling()) {
221     assert(C->role() == syntax::NodeRole::NestedNameSpecifier_specifier);
222     Children.push_back(cast<syntax::NameSpecifier>(C));
223   }
224   return Children;
225 }
226 
227 syntax::NestedNameSpecifier *syntax::IdExpression::qualifier() {
228   return cast_or_null<syntax::NestedNameSpecifier>(
229       findChild(syntax::NodeRole::IdExpression_qualifier));
230 }
231 
232 syntax::Leaf *syntax::IdExpression::templateKeyword() {
233   return llvm::cast_or_null<syntax::Leaf>(
234       findChild(syntax::NodeRole::TemplateKeyword));
235 }
236 
237 syntax::UnqualifiedId *syntax::IdExpression::unqualifiedId() {
238   return cast_or_null<syntax::UnqualifiedId>(
239       findChild(syntax::NodeRole::IdExpression_id));
240 }
241 
242 syntax::Leaf *syntax::ParenExpression::openParen() {
243   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
244 }
245 
246 syntax::Expression *syntax::ParenExpression::subExpression() {
247   return cast_or_null<syntax::Expression>(
248       findChild(syntax::NodeRole::ParenExpression_subExpression));
249 }
250 
251 syntax::Leaf *syntax::ParenExpression::closeParen() {
252   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
253 }
254 
255 syntax::Leaf *syntax::LiteralExpression::literalToken() {
256   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
257 }
258 
259 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
260   return cast_or_null<syntax::Expression>(
261       findChild(syntax::NodeRole::BinaryOperatorExpression_leftHandSide));
262 }
263 
264 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
265   return cast_or_null<syntax::Leaf>(
266       findChild(syntax::NodeRole::OperatorExpression_operatorToken));
267 }
268 
269 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
270   return cast_or_null<syntax::Expression>(
271       findChild(syntax::NodeRole::UnaryOperatorExpression_operand));
272 }
273 
274 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
275   return cast_or_null<syntax::Leaf>(
276       findChild(syntax::NodeRole::OperatorExpression_operatorToken));
277 }
278 
279 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
280   return cast_or_null<syntax::Expression>(
281       findChild(syntax::NodeRole::BinaryOperatorExpression_rightHandSide));
282 }
283 
284 syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
285   return cast_or_null<syntax::Leaf>(
286       findChild(syntax::NodeRole::IntroducerKeyword));
287 }
288 
289 syntax::Statement *syntax::SwitchStatement::body() {
290   return cast_or_null<syntax::Statement>(
291       findChild(syntax::NodeRole::BodyStatement));
292 }
293 
294 syntax::Leaf *syntax::CaseStatement::caseKeyword() {
295   return cast_or_null<syntax::Leaf>(
296       findChild(syntax::NodeRole::IntroducerKeyword));
297 }
298 
299 syntax::Expression *syntax::CaseStatement::value() {
300   return cast_or_null<syntax::Expression>(
301       findChild(syntax::NodeRole::CaseStatement_value));
302 }
303 
304 syntax::Statement *syntax::CaseStatement::body() {
305   return cast_or_null<syntax::Statement>(
306       findChild(syntax::NodeRole::BodyStatement));
307 }
308 
309 syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {
310   return cast_or_null<syntax::Leaf>(
311       findChild(syntax::NodeRole::IntroducerKeyword));
312 }
313 
314 syntax::Statement *syntax::DefaultStatement::body() {
315   return cast_or_null<syntax::Statement>(
316       findChild(syntax::NodeRole::BodyStatement));
317 }
318 
319 syntax::Leaf *syntax::IfStatement::ifKeyword() {
320   return cast_or_null<syntax::Leaf>(
321       findChild(syntax::NodeRole::IntroducerKeyword));
322 }
323 
324 syntax::Statement *syntax::IfStatement::thenStatement() {
325   return cast_or_null<syntax::Statement>(
326       findChild(syntax::NodeRole::IfStatement_thenStatement));
327 }
328 
329 syntax::Leaf *syntax::IfStatement::elseKeyword() {
330   return cast_or_null<syntax::Leaf>(
331       findChild(syntax::NodeRole::IfStatement_elseKeyword));
332 }
333 
334 syntax::Statement *syntax::IfStatement::elseStatement() {
335   return cast_or_null<syntax::Statement>(
336       findChild(syntax::NodeRole::IfStatement_elseStatement));
337 }
338 
339 syntax::Leaf *syntax::ForStatement::forKeyword() {
340   return cast_or_null<syntax::Leaf>(
341       findChild(syntax::NodeRole::IntroducerKeyword));
342 }
343 
344 syntax::Statement *syntax::ForStatement::body() {
345   return cast_or_null<syntax::Statement>(
346       findChild(syntax::NodeRole::BodyStatement));
347 }
348 
349 syntax::Leaf *syntax::WhileStatement::whileKeyword() {
350   return cast_or_null<syntax::Leaf>(
351       findChild(syntax::NodeRole::IntroducerKeyword));
352 }
353 
354 syntax::Statement *syntax::WhileStatement::body() {
355   return cast_or_null<syntax::Statement>(
356       findChild(syntax::NodeRole::BodyStatement));
357 }
358 
359 syntax::Leaf *syntax::ContinueStatement::continueKeyword() {
360   return cast_or_null<syntax::Leaf>(
361       findChild(syntax::NodeRole::IntroducerKeyword));
362 }
363 
364 syntax::Leaf *syntax::BreakStatement::breakKeyword() {
365   return cast_or_null<syntax::Leaf>(
366       findChild(syntax::NodeRole::IntroducerKeyword));
367 }
368 
369 syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
370   return cast_or_null<syntax::Leaf>(
371       findChild(syntax::NodeRole::IntroducerKeyword));
372 }
373 
374 syntax::Expression *syntax::ReturnStatement::value() {
375   return cast_or_null<syntax::Expression>(
376       findChild(syntax::NodeRole::ReturnStatement_value));
377 }
378 
379 syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {
380   return cast_or_null<syntax::Leaf>(
381       findChild(syntax::NodeRole::IntroducerKeyword));
382 }
383 
384 syntax::Statement *syntax::RangeBasedForStatement::body() {
385   return cast_or_null<syntax::Statement>(
386       findChild(syntax::NodeRole::BodyStatement));
387 }
388 
389 syntax::Expression *syntax::ExpressionStatement::expression() {
390   return cast_or_null<syntax::Expression>(
391       findChild(syntax::NodeRole::ExpressionStatement_expression));
392 }
393 
394 syntax::Leaf *syntax::CompoundStatement::lbrace() {
395   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
396 }
397 
398 std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
399   std::vector<syntax::Statement *> Children;
400   for (auto *C = firstChild(); C; C = C->nextSibling()) {
401     assert(C->role() == syntax::NodeRole::CompoundStatement_statement);
402     Children.push_back(cast<syntax::Statement>(C));
403   }
404   return Children;
405 }
406 
407 syntax::Leaf *syntax::CompoundStatement::rbrace() {
408   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
409 }
410 
411 syntax::Expression *syntax::StaticAssertDeclaration::condition() {
412   return cast_or_null<syntax::Expression>(
413       findChild(syntax::NodeRole::StaticAssertDeclaration_condition));
414 }
415 
416 syntax::Expression *syntax::StaticAssertDeclaration::message() {
417   return cast_or_null<syntax::Expression>(
418       findChild(syntax::NodeRole::StaticAssertDeclaration_message));
419 }
420 
421 std::vector<syntax::SimpleDeclarator *>
422 syntax::SimpleDeclaration::declarators() {
423   std::vector<syntax::SimpleDeclarator *> Children;
424   for (auto *C = firstChild(); C; C = C->nextSibling()) {
425     if (C->role() == syntax::NodeRole::SimpleDeclaration_declarator)
426       Children.push_back(cast<syntax::SimpleDeclarator>(C));
427   }
428   return Children;
429 }
430 
431 syntax::Leaf *syntax::TemplateDeclaration::templateKeyword() {
432   return cast_or_null<syntax::Leaf>(
433       findChild(syntax::NodeRole::IntroducerKeyword));
434 }
435 
436 syntax::Declaration *syntax::TemplateDeclaration::declaration() {
437   return cast_or_null<syntax::Declaration>(
438       findChild(syntax::NodeRole::TemplateDeclaration_declaration));
439 }
440 
441 syntax::Leaf *syntax::ExplicitTemplateInstantiation::templateKeyword() {
442   return cast_or_null<syntax::Leaf>(
443       findChild(syntax::NodeRole::IntroducerKeyword));
444 }
445 
446 syntax::Leaf *syntax::ExplicitTemplateInstantiation::externKeyword() {
447   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
448 }
449 
450 syntax::Declaration *syntax::ExplicitTemplateInstantiation::declaration() {
451   return cast_or_null<syntax::Declaration>(
452       findChild(syntax::NodeRole::ExplicitTemplateInstantiation_declaration));
453 }
454 
455 syntax::Leaf *syntax::ParenDeclarator::lparen() {
456   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
457 }
458 
459 syntax::Leaf *syntax::ParenDeclarator::rparen() {
460   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
461 }
462 
463 syntax::Leaf *syntax::ArraySubscript::lbracket() {
464   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
465 }
466 
467 syntax::Expression *syntax::ArraySubscript::sizeExpression() {
468   return cast_or_null<syntax::Expression>(
469       findChild(syntax::NodeRole::ArraySubscript_sizeExpression));
470 }
471 
472 syntax::Leaf *syntax::ArraySubscript::rbracket() {
473   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
474 }
475 
476 syntax::Leaf *syntax::TrailingReturnType::arrowToken() {
477   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
478 }
479 
480 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
481   return cast_or_null<syntax::SimpleDeclarator>(
482       findChild(syntax::NodeRole::TrailingReturnType_declarator));
483 }
484 
485 syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
486   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
487 }
488 
489 std::vector<syntax::SimpleDeclaration *>
490 syntax::ParametersAndQualifiers::parameters() {
491   std::vector<syntax::SimpleDeclaration *> Children;
492   for (auto *C = firstChild(); C; C = C->nextSibling()) {
493     if (C->role() == syntax::NodeRole::ParametersAndQualifiers_parameter)
494       Children.push_back(cast<syntax::SimpleDeclaration>(C));
495   }
496   return Children;
497 }
498 
499 syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
500   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
501 }
502 
503 syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
504   return cast_or_null<syntax::TrailingReturnType>(
505       findChild(syntax::NodeRole::ParametersAndQualifiers_trailingReturn));
506 }
507