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 #define CONCRETE_NODE(Kind, Parent)                                            \
16   case NodeKind::Kind:                                                         \
17     return OS << #Kind;
18 #include "clang/Tooling/Syntax/Nodes.inc"
19   }
20   llvm_unreachable("unknown node kind");
21 }
22 
23 raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
24   switch (R) {
25   case syntax::NodeRole::Detached:
26     return OS << "Detached";
27   case syntax::NodeRole::Unknown:
28     return OS << "Unknown";
29   case syntax::NodeRole::OpenParen:
30     return OS << "OpenParen";
31   case syntax::NodeRole::CloseParen:
32     return OS << "CloseParen";
33   case syntax::NodeRole::IntroducerKeyword:
34     return OS << "IntroducerKeyword";
35   case syntax::NodeRole::LiteralToken:
36     return OS << "LiteralToken";
37   case syntax::NodeRole::ArrowToken:
38     return OS << "ArrowToken";
39   case syntax::NodeRole::ExternKeyword:
40     return OS << "ExternKeyword";
41   case syntax::NodeRole::TemplateKeyword:
42     return OS << "TemplateKeyword";
43   case syntax::NodeRole::BodyStatement:
44     return OS << "BodyStatement";
45   case syntax::NodeRole::ListElement:
46     return OS << "ListElement";
47   case syntax::NodeRole::ListDelimiter:
48     return OS << "ListDelimiter";
49   case syntax::NodeRole::CaseValue:
50     return OS << "CaseValue";
51   case syntax::NodeRole::ReturnValue:
52     return OS << "ReturnValue";
53   case syntax::NodeRole::ThenStatement:
54     return OS << "ThenStatement";
55   case syntax::NodeRole::ElseKeyword:
56     return OS << "ElseKeyword";
57   case syntax::NodeRole::ElseStatement:
58     return OS << "ElseStatement";
59   case syntax::NodeRole::OperatorToken:
60     return OS << "OperatorToken";
61   case syntax::NodeRole::Operand:
62     return OS << "Operand";
63   case syntax::NodeRole::LeftHandSide:
64     return OS << "LeftHandSide";
65   case syntax::NodeRole::RightHandSide:
66     return OS << "RightHandSide";
67   case syntax::NodeRole::Expression:
68     return OS << "Expression";
69   case syntax::NodeRole::Statement:
70     return OS << "Statement";
71   case syntax::NodeRole::Condition:
72     return OS << "Condition";
73   case syntax::NodeRole::Message:
74     return OS << "Message";
75   case syntax::NodeRole::Declarator:
76     return OS << "Declarator";
77   case syntax::NodeRole::Declaration:
78     return OS << "Declaration";
79   case syntax::NodeRole::Size:
80     return OS << "Size";
81   case syntax::NodeRole::Parameters:
82     return OS << "Parameters";
83   case syntax::NodeRole::TrailingReturn:
84     return OS << "TrailingReturn";
85   case syntax::NodeRole::UnqualifiedId:
86     return OS << "UnqualifiedId";
87   case syntax::NodeRole::Qualifier:
88     return OS << "Qualifier";
89   case syntax::NodeRole::SubExpression:
90     return OS << "SubExpression";
91   case syntax::NodeRole::Object:
92     return OS << "Object";
93   case syntax::NodeRole::AccessToken:
94     return OS << "AccessToken";
95   case syntax::NodeRole::Member:
96     return OS << "Member";
97   case syntax::NodeRole::Callee:
98     return OS << "Callee";
99   case syntax::NodeRole::Arguments:
100     return OS << "Arguments";
101   case syntax::NodeRole::Declarators:
102     return OS << "Declarators";
103   }
104   llvm_unreachable("invalid role");
105 }
106 
107 // We could have an interator in list to not pay memory costs of temporary
108 // vector
109 std::vector<syntax::NameSpecifier *>
110 syntax::NestedNameSpecifier::getSpecifiers() {
111   auto SpecifiersAsNodes = getElementsAsNodes();
112   std::vector<syntax::NameSpecifier *> Children;
113   for (const auto &Element : SpecifiersAsNodes) {
114     Children.push_back(llvm::cast<syntax::NameSpecifier>(Element));
115   }
116   return Children;
117 }
118 
119 std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
120 syntax::NestedNameSpecifier::getSpecifiersAndDoubleColons() {
121   auto SpecifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
122   std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
123       Children;
124   for (const auto &SpecifierAndDoubleColon : SpecifiersAsNodesAndDoubleColons) {
125     Children.push_back(
126         {llvm::cast<syntax::NameSpecifier>(SpecifierAndDoubleColon.element),
127          SpecifierAndDoubleColon.delimiter});
128   }
129   return Children;
130 }
131 
132 std::vector<syntax::Expression *> syntax::CallArguments::getArguments() {
133   auto ArgumentsAsNodes = getElementsAsNodes();
134   std::vector<syntax::Expression *> Children;
135   for (const auto &ArgumentAsNode : ArgumentsAsNodes) {
136     Children.push_back(llvm::cast<syntax::Expression>(ArgumentAsNode));
137   }
138   return Children;
139 }
140 
141 std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
142 syntax::CallArguments::getArgumentsAndCommas() {
143   auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
144   std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> Children;
145   for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
146     Children.push_back(
147         {llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
148          ArgumentAsNodeAndComma.delimiter});
149   }
150   return Children;
151 }
152 
153 std::vector<syntax::SimpleDeclaration *>
154 syntax::ParameterDeclarationList::getParameterDeclarations() {
155   auto ParametersAsNodes = getElementsAsNodes();
156   std::vector<syntax::SimpleDeclaration *> Children;
157   for (const auto &ParameterAsNode : ParametersAsNodes) {
158     Children.push_back(llvm::cast<syntax::SimpleDeclaration>(ParameterAsNode));
159   }
160   return Children;
161 }
162 
163 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
164 syntax::ParameterDeclarationList::getParametersAndCommas() {
165   auto ParametersAsNodesAndCommas = getElementsAsNodesAndDelimiters();
166   std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
167       Children;
168   for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {
169     Children.push_back(
170         {llvm::cast<syntax::SimpleDeclaration>(ParameterAsNodeAndComma.element),
171          ParameterAsNodeAndComma.delimiter});
172   }
173   return Children;
174 }
175 
176 std::vector<syntax::SimpleDeclarator *>
177 syntax::DeclaratorList::getDeclarators() {
178   auto DeclaratorsAsNodes = getElementsAsNodes();
179   std::vector<syntax::SimpleDeclarator *> Children;
180   for (const auto &DeclaratorAsNode : DeclaratorsAsNodes) {
181     Children.push_back(llvm::cast<syntax::SimpleDeclarator>(DeclaratorAsNode));
182   }
183   return Children;
184 }
185 
186 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclarator>>
187 syntax::DeclaratorList::getDeclaratorsAndCommas() {
188   auto DeclaratorsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
189   std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclarator>>
190       Children;
191   for (const auto &DeclaratorAsNodeAndComma : DeclaratorsAsNodesAndCommas) {
192     Children.push_back(
193         {llvm::cast<syntax::SimpleDeclarator>(DeclaratorAsNodeAndComma.element),
194          DeclaratorAsNodeAndComma.delimiter});
195   }
196   return Children;
197 }
198 
199 syntax::Leaf *syntax::LiteralExpression::getLiteralToken() {
200   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
201 }
202 
203 syntax::Expression *syntax::BinaryOperatorExpression::getLhs() {
204   return cast_or_null<syntax::Expression>(
205       findChild(syntax::NodeRole::LeftHandSide));
206 }
207 
208 syntax::Leaf *syntax::UnaryOperatorExpression::getOperatorToken() {
209   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
210 }
211 
212 syntax::Expression *syntax::UnaryOperatorExpression::getOperand() {
213   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Operand));
214 }
215 
216 syntax::Leaf *syntax::BinaryOperatorExpression::getOperatorToken() {
217   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
218 }
219 
220 syntax::Expression *syntax::BinaryOperatorExpression::getRhs() {
221   return cast_or_null<syntax::Expression>(
222       findChild(syntax::NodeRole::RightHandSide));
223 }
224 
225 syntax::Leaf *syntax::SwitchStatement::getSwitchKeyword() {
226   return cast_or_null<syntax::Leaf>(
227       findChild(syntax::NodeRole::IntroducerKeyword));
228 }
229 
230 syntax::Statement *syntax::SwitchStatement::getBody() {
231   return cast_or_null<syntax::Statement>(
232       findChild(syntax::NodeRole::BodyStatement));
233 }
234 
235 syntax::Leaf *syntax::CaseStatement::getCaseKeyword() {
236   return cast_or_null<syntax::Leaf>(
237       findChild(syntax::NodeRole::IntroducerKeyword));
238 }
239 
240 syntax::Expression *syntax::CaseStatement::getCaseValue() {
241   return cast_or_null<syntax::Expression>(
242       findChild(syntax::NodeRole::CaseValue));
243 }
244 
245 syntax::Statement *syntax::CaseStatement::getBody() {
246   return cast_or_null<syntax::Statement>(
247       findChild(syntax::NodeRole::BodyStatement));
248 }
249 
250 syntax::Leaf *syntax::DefaultStatement::getDefaultKeyword() {
251   return cast_or_null<syntax::Leaf>(
252       findChild(syntax::NodeRole::IntroducerKeyword));
253 }
254 
255 syntax::Statement *syntax::DefaultStatement::getBody() {
256   return cast_or_null<syntax::Statement>(
257       findChild(syntax::NodeRole::BodyStatement));
258 }
259 
260 syntax::Leaf *syntax::IfStatement::getIfKeyword() {
261   return cast_or_null<syntax::Leaf>(
262       findChild(syntax::NodeRole::IntroducerKeyword));
263 }
264 
265 syntax::Statement *syntax::IfStatement::getThenStatement() {
266   return cast_or_null<syntax::Statement>(
267       findChild(syntax::NodeRole::ThenStatement));
268 }
269 
270 syntax::Leaf *syntax::IfStatement::getElseKeyword() {
271   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ElseKeyword));
272 }
273 
274 syntax::Statement *syntax::IfStatement::getElseStatement() {
275   return cast_or_null<syntax::Statement>(
276       findChild(syntax::NodeRole::ElseStatement));
277 }
278 
279 syntax::Leaf *syntax::ForStatement::getForKeyword() {
280   return cast_or_null<syntax::Leaf>(
281       findChild(syntax::NodeRole::IntroducerKeyword));
282 }
283 
284 syntax::Statement *syntax::ForStatement::getBody() {
285   return cast_or_null<syntax::Statement>(
286       findChild(syntax::NodeRole::BodyStatement));
287 }
288 
289 syntax::Leaf *syntax::WhileStatement::getWhileKeyword() {
290   return cast_or_null<syntax::Leaf>(
291       findChild(syntax::NodeRole::IntroducerKeyword));
292 }
293 
294 syntax::Statement *syntax::WhileStatement::getBody() {
295   return cast_or_null<syntax::Statement>(
296       findChild(syntax::NodeRole::BodyStatement));
297 }
298 
299 syntax::Leaf *syntax::ContinueStatement::getContinueKeyword() {
300   return cast_or_null<syntax::Leaf>(
301       findChild(syntax::NodeRole::IntroducerKeyword));
302 }
303 
304 syntax::Leaf *syntax::BreakStatement::getBreakKeyword() {
305   return cast_or_null<syntax::Leaf>(
306       findChild(syntax::NodeRole::IntroducerKeyword));
307 }
308 
309 syntax::Leaf *syntax::ReturnStatement::getReturnKeyword() {
310   return cast_or_null<syntax::Leaf>(
311       findChild(syntax::NodeRole::IntroducerKeyword));
312 }
313 
314 syntax::Expression *syntax::ReturnStatement::getReturnValue() {
315   return cast_or_null<syntax::Expression>(
316       findChild(syntax::NodeRole::ReturnValue));
317 }
318 
319 syntax::Leaf *syntax::RangeBasedForStatement::getForKeyword() {
320   return cast_or_null<syntax::Leaf>(
321       findChild(syntax::NodeRole::IntroducerKeyword));
322 }
323 
324 syntax::Statement *syntax::RangeBasedForStatement::getBody() {
325   return cast_or_null<syntax::Statement>(
326       findChild(syntax::NodeRole::BodyStatement));
327 }
328 
329 syntax::Expression *syntax::ExpressionStatement::getExpression() {
330   return cast_or_null<syntax::Expression>(
331       findChild(syntax::NodeRole::Expression));
332 }
333 
334 syntax::Leaf *syntax::CompoundStatement::getLbrace() {
335   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
336 }
337 
338 std::vector<syntax::Statement *> syntax::CompoundStatement::getStatements() {
339   std::vector<syntax::Statement *> Children;
340   for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
341     assert(C->getRole() == syntax::NodeRole::Statement);
342     Children.push_back(cast<syntax::Statement>(C));
343   }
344   return Children;
345 }
346 
347 syntax::Leaf *syntax::CompoundStatement::getRbrace() {
348   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
349 }
350 
351 syntax::Expression *syntax::StaticAssertDeclaration::getCondition() {
352   return cast_or_null<syntax::Expression>(
353       findChild(syntax::NodeRole::Condition));
354 }
355 
356 syntax::Expression *syntax::StaticAssertDeclaration::getMessage() {
357   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message));
358 }
359 
360 std::vector<syntax::SimpleDeclarator *>
361 syntax::SimpleDeclaration::getDeclarators() {
362   std::vector<syntax::SimpleDeclarator *> Children;
363   for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
364     if (C->getRole() == syntax::NodeRole::Declarator)
365       Children.push_back(cast<syntax::SimpleDeclarator>(C));
366   }
367   return Children;
368 }
369 
370 syntax::Leaf *syntax::TemplateDeclaration::getTemplateKeyword() {
371   return cast_or_null<syntax::Leaf>(
372       findChild(syntax::NodeRole::IntroducerKeyword));
373 }
374 
375 syntax::Declaration *syntax::TemplateDeclaration::getDeclaration() {
376   return cast_or_null<syntax::Declaration>(
377       findChild(syntax::NodeRole::Declaration));
378 }
379 
380 syntax::Leaf *syntax::ExplicitTemplateInstantiation::getTemplateKeyword() {
381   return cast_or_null<syntax::Leaf>(
382       findChild(syntax::NodeRole::IntroducerKeyword));
383 }
384 
385 syntax::Leaf *syntax::ExplicitTemplateInstantiation::getExternKeyword() {
386   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
387 }
388 
389 syntax::Declaration *syntax::ExplicitTemplateInstantiation::getDeclaration() {
390   return cast_or_null<syntax::Declaration>(
391       findChild(syntax::NodeRole::Declaration));
392 }
393 
394 syntax::Leaf *syntax::ParenDeclarator::getLparen() {
395   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
396 }
397 
398 syntax::Leaf *syntax::ParenDeclarator::getRparen() {
399   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
400 }
401 
402 syntax::Leaf *syntax::ArraySubscript::getLbracket() {
403   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
404 }
405 
406 syntax::Expression *syntax::ArraySubscript::getSize() {
407   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Size));
408 }
409 
410 syntax::Leaf *syntax::ArraySubscript::getRbracket() {
411   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
412 }
413 
414 syntax::Leaf *syntax::TrailingReturnType::getArrowToken() {
415   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
416 }
417 
418 syntax::SimpleDeclarator *syntax::TrailingReturnType::getDeclarator() {
419   return cast_or_null<syntax::SimpleDeclarator>(
420       findChild(syntax::NodeRole::Declarator));
421 }
422 
423 syntax::Leaf *syntax::ParametersAndQualifiers::getLparen() {
424   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
425 }
426 
427 syntax::ParameterDeclarationList *
428 syntax::ParametersAndQualifiers::getParameters() {
429   return cast_or_null<syntax::ParameterDeclarationList>(
430       findChild(syntax::NodeRole::Parameters));
431 }
432 
433 syntax::Leaf *syntax::ParametersAndQualifiers::getRparen() {
434   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
435 }
436 
437 syntax::TrailingReturnType *
438 syntax::ParametersAndQualifiers::getTrailingReturn() {
439   return cast_or_null<syntax::TrailingReturnType>(
440       findChild(syntax::NodeRole::TrailingReturn));
441 }
442 
443 #define NODE(Kind, Parent)                                                     \
444   static_assert(sizeof(syntax::Kind) > 0, "Missing Node subclass definition");
445 #include "clang/Tooling/Syntax/Nodes.inc"
446