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