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