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