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