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