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