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