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   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::ParenExpression:
22     return OS << "ParenExpression";
23   case NodeKind::ThisExpression:
24     return OS << "ThisExpression";
25   case NodeKind::IntegerLiteralExpression:
26     return OS << "IntegerLiteralExpression";
27   case NodeKind::CharacterLiteralExpression:
28     return OS << "CharacterLiteralExpression";
29   case NodeKind::FloatingLiteralExpression:
30     return OS << "FloatingLiteralExpression";
31   case NodeKind::StringLiteralExpression:
32     return OS << "StringLiteralExpression";
33   case NodeKind::BoolLiteralExpression:
34     return OS << "BoolLiteralExpression";
35   case NodeKind::CxxNullPtrExpression:
36     return OS << "CxxNullPtrExpression";
37   case NodeKind::IntegerUserDefinedLiteralExpression:
38     return OS << "IntegerUserDefinedLiteralExpression";
39   case NodeKind::FloatUserDefinedLiteralExpression:
40     return OS << "FloatUserDefinedLiteralExpression";
41   case NodeKind::CharUserDefinedLiteralExpression:
42     return OS << "CharUserDefinedLiteralExpression";
43   case NodeKind::StringUserDefinedLiteralExpression:
44     return OS << "StringUserDefinedLiteralExpression";
45   case NodeKind::PrefixUnaryOperatorExpression:
46     return OS << "PrefixUnaryOperatorExpression";
47   case NodeKind::PostfixUnaryOperatorExpression:
48     return OS << "PostfixUnaryOperatorExpression";
49   case NodeKind::BinaryOperatorExpression:
50     return OS << "BinaryOperatorExpression";
51   case NodeKind::UnqualifiedId:
52     return OS << "UnqualifiedId";
53   case NodeKind::IdExpression:
54     return OS << "IdExpression";
55   case NodeKind::CallExpression:
56     return OS << "CallExpression";
57   case NodeKind::UnknownStatement:
58     return OS << "UnknownStatement";
59   case NodeKind::DeclarationStatement:
60     return OS << "DeclarationStatement";
61   case NodeKind::EmptyStatement:
62     return OS << "EmptyStatement";
63   case NodeKind::SwitchStatement:
64     return OS << "SwitchStatement";
65   case NodeKind::CaseStatement:
66     return OS << "CaseStatement";
67   case NodeKind::DefaultStatement:
68     return OS << "DefaultStatement";
69   case NodeKind::IfStatement:
70     return OS << "IfStatement";
71   case NodeKind::ForStatement:
72     return OS << "ForStatement";
73   case NodeKind::WhileStatement:
74     return OS << "WhileStatement";
75   case NodeKind::ContinueStatement:
76     return OS << "ContinueStatement";
77   case NodeKind::BreakStatement:
78     return OS << "BreakStatement";
79   case NodeKind::ReturnStatement:
80     return OS << "ReturnStatement";
81   case NodeKind::RangeBasedForStatement:
82     return OS << "RangeBasedForStatement";
83   case NodeKind::ExpressionStatement:
84     return OS << "ExpressionStatement";
85   case NodeKind::CompoundStatement:
86     return OS << "CompoundStatement";
87   case NodeKind::UnknownDeclaration:
88     return OS << "UnknownDeclaration";
89   case NodeKind::EmptyDeclaration:
90     return OS << "EmptyDeclaration";
91   case NodeKind::StaticAssertDeclaration:
92     return OS << "StaticAssertDeclaration";
93   case NodeKind::LinkageSpecificationDeclaration:
94     return OS << "LinkageSpecificationDeclaration";
95   case NodeKind::SimpleDeclaration:
96     return OS << "SimpleDeclaration";
97   case NodeKind::TemplateDeclaration:
98     return OS << "TemplateDeclaration";
99   case NodeKind::ExplicitTemplateInstantiation:
100     return OS << "ExplicitTemplateInstantiation";
101   case NodeKind::NamespaceDefinition:
102     return OS << "NamespaceDefinition";
103   case NodeKind::NamespaceAliasDefinition:
104     return OS << "NamespaceAliasDefinition";
105   case NodeKind::UsingNamespaceDirective:
106     return OS << "UsingNamespaceDirective";
107   case NodeKind::UsingDeclaration:
108     return OS << "UsingDeclaration";
109   case NodeKind::TypeAliasDeclaration:
110     return OS << "TypeAliasDeclaration";
111   case NodeKind::SimpleDeclarator:
112     return OS << "SimpleDeclarator";
113   case NodeKind::ParenDeclarator:
114     return OS << "ParenDeclarator";
115   case NodeKind::ArraySubscript:
116     return OS << "ArraySubscript";
117   case NodeKind::TrailingReturnType:
118     return OS << "TrailingReturnType";
119   case NodeKind::ParametersAndQualifiers:
120     return OS << "ParametersAndQualifiers";
121   case NodeKind::MemberPointer:
122     return OS << "MemberPointer";
123   case NodeKind::GlobalNameSpecifier:
124     return OS << "GlobalNameSpecifier";
125   case NodeKind::DecltypeNameSpecifier:
126     return OS << "DecltypeNameSpecifier";
127   case NodeKind::IdentifierNameSpecifier:
128     return OS << "IdentifierNameSpecifier";
129   case NodeKind::SimpleTemplateNameSpecifier:
130     return OS << "SimpleTemplateNameSpecifier";
131   case NodeKind::NestedNameSpecifier:
132     return OS << "NestedNameSpecifier";
133   case NodeKind::MemberExpression:
134     return OS << "MemberExpression";
135   case NodeKind::CallArguments:
136     return OS << "CallArguments";
137   }
138   llvm_unreachable("unknown node kind");
139 }
140 
141 raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
142   switch (R) {
143   case syntax::NodeRole::Detached:
144     return OS << "Detached";
145   case syntax::NodeRole::Unknown:
146     return OS << "Unknown";
147   case syntax::NodeRole::OpenParen:
148     return OS << "OpenParen";
149   case syntax::NodeRole::CloseParen:
150     return OS << "CloseParen";
151   case syntax::NodeRole::IntroducerKeyword:
152     return OS << "IntroducerKeyword";
153   case syntax::NodeRole::LiteralToken:
154     return OS << "LiteralToken";
155   case syntax::NodeRole::ArrowToken:
156     return OS << "ArrowToken";
157   case syntax::NodeRole::ExternKeyword:
158     return OS << "ExternKeyword";
159   case syntax::NodeRole::TemplateKeyword:
160     return OS << "TemplateKeyword";
161   case syntax::NodeRole::BodyStatement:
162     return OS << "BodyStatement";
163   case syntax::NodeRole::List_element:
164     return OS << "List_element";
165   case syntax::NodeRole::List_delimiter:
166     return OS << "List_delimiter";
167   case syntax::NodeRole::CaseStatement_value:
168     return OS << "CaseStatement_value";
169   case syntax::NodeRole::IfStatement_thenStatement:
170     return OS << "IfStatement_thenStatement";
171   case syntax::NodeRole::IfStatement_elseKeyword:
172     return OS << "IfStatement_elseKeyword";
173   case syntax::NodeRole::IfStatement_elseStatement:
174     return OS << "IfStatement_elseStatement";
175   case syntax::NodeRole::OperatorExpression_operatorToken:
176     return OS << "OperatorExpression_operatorToken";
177   case syntax::NodeRole::UnaryOperatorExpression_operand:
178     return OS << "UnaryOperatorExpression_operand";
179   case syntax::NodeRole::BinaryOperatorExpression_leftHandSide:
180     return OS << "BinaryOperatorExpression_leftHandSide";
181   case syntax::NodeRole::BinaryOperatorExpression_rightHandSide:
182     return OS << "BinaryOperatorExpression_rightHandSide";
183   case syntax::NodeRole::ReturnStatement_value:
184     return OS << "ReturnStatement_value";
185   case syntax::NodeRole::ExpressionStatement_expression:
186     return OS << "ExpressionStatement_expression";
187   case syntax::NodeRole::CompoundStatement_statement:
188     return OS << "CompoundStatement_statement";
189   case syntax::NodeRole::StaticAssertDeclaration_condition:
190     return OS << "StaticAssertDeclaration_condition";
191   case syntax::NodeRole::StaticAssertDeclaration_message:
192     return OS << "StaticAssertDeclaration_message";
193   case syntax::NodeRole::SimpleDeclaration_declarator:
194     return OS << "SimpleDeclaration_declarator";
195   case syntax::NodeRole::TemplateDeclaration_declaration:
196     return OS << "TemplateDeclaration_declaration";
197   case syntax::NodeRole::ExplicitTemplateInstantiation_declaration:
198     return OS << "ExplicitTemplateInstantiation_declaration";
199   case syntax::NodeRole::ArraySubscript_sizeExpression:
200     return OS << "ArraySubscript_sizeExpression";
201   case syntax::NodeRole::TrailingReturnType_declarator:
202     return OS << "TrailingReturnType_declarator";
203   case syntax::NodeRole::ParametersAndQualifiers_parameter:
204     return OS << "ParametersAndQualifiers_parameter";
205   case syntax::NodeRole::ParametersAndQualifiers_trailingReturn:
206     return OS << "ParametersAndQualifiers_trailingReturn";
207   case syntax::NodeRole::IdExpression_id:
208     return OS << "IdExpression_id";
209   case syntax::NodeRole::IdExpression_qualifier:
210     return OS << "IdExpression_qualifier";
211   case syntax::NodeRole::ParenExpression_subExpression:
212     return OS << "ParenExpression_subExpression";
213   case syntax::NodeRole::MemberExpression_object:
214     return OS << "MemberExpression_object";
215   case syntax::NodeRole::MemberExpression_accessToken:
216     return OS << "MemberExpression_accessToken";
217   case syntax::NodeRole::MemberExpression_member:
218     return OS << "MemberExpression_member";
219   case syntax::NodeRole::CallExpression_callee:
220     return OS << "CallExpression_callee";
221   case syntax::NodeRole::CallExpression_arguments:
222     return OS << "CallExpression_arguments";
223   }
224   llvm_unreachable("invalid role");
225 }
226 
227 // We could have an interator in list to not pay memory costs of temporary
228 // vector
229 std::vector<syntax::NameSpecifier *> syntax::NestedNameSpecifier::specifiers() {
230   auto specifiersAsNodes = getElementsAsNodes();
231   std::vector<syntax::NameSpecifier *> Children;
232   for (const auto &element : specifiersAsNodes) {
233     Children.push_back(llvm::cast<syntax::NameSpecifier>(element));
234   }
235   return Children;
236 }
237 
238 std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
239 syntax::NestedNameSpecifier::specifiersAndDoubleColons() {
240   auto specifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
241   std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
242       Children;
243   for (const auto &specifierAndDoubleColon : specifiersAsNodesAndDoubleColons) {
244     Children.push_back(
245         {llvm::cast<syntax::NameSpecifier>(specifierAndDoubleColon.element),
246          specifierAndDoubleColon.delimiter});
247   }
248   return Children;
249 }
250 
251 std::vector<syntax::Expression *> syntax::CallArguments::arguments() {
252   auto ArgumentsAsNodes = getElementsAsNodes();
253   std::vector<syntax::Expression *> Children;
254   for (const auto &ArgumentAsNode : ArgumentsAsNodes) {
255     Children.push_back(llvm::cast<syntax::Expression>(ArgumentAsNode));
256   }
257   return Children;
258 }
259 
260 std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
261 syntax::CallArguments::argumentsAndCommas() {
262   auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
263   std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> Children;
264   for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
265     Children.push_back(
266         {llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
267          ArgumentAsNodeAndComma.delimiter});
268   }
269   return Children;
270 }
271 
272 syntax::Expression *syntax::MemberExpression::object() {
273   return cast_or_null<syntax::Expression>(
274       findChild(syntax::NodeRole::MemberExpression_object));
275 }
276 
277 syntax::Leaf *syntax::MemberExpression::templateKeyword() {
278   return llvm::cast_or_null<syntax::Leaf>(
279       findChild(syntax::NodeRole::TemplateKeyword));
280 }
281 
282 syntax::Leaf *syntax::MemberExpression::accessToken() {
283   return llvm::cast_or_null<syntax::Leaf>(
284       findChild(syntax::NodeRole::MemberExpression_accessToken));
285 }
286 
287 syntax::IdExpression *syntax::MemberExpression::member() {
288   return cast_or_null<syntax::IdExpression>(
289       findChild(syntax::NodeRole::MemberExpression_member));
290 }
291 
292 syntax::NestedNameSpecifier *syntax::IdExpression::qualifier() {
293   return cast_or_null<syntax::NestedNameSpecifier>(
294       findChild(syntax::NodeRole::IdExpression_qualifier));
295 }
296 
297 syntax::Leaf *syntax::IdExpression::templateKeyword() {
298   return llvm::cast_or_null<syntax::Leaf>(
299       findChild(syntax::NodeRole::TemplateKeyword));
300 }
301 
302 syntax::UnqualifiedId *syntax::IdExpression::unqualifiedId() {
303   return cast_or_null<syntax::UnqualifiedId>(
304       findChild(syntax::NodeRole::IdExpression_id));
305 }
306 
307 syntax::Leaf *syntax::ParenExpression::openParen() {
308   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
309 }
310 
311 syntax::Expression *syntax::ParenExpression::subExpression() {
312   return cast_or_null<syntax::Expression>(
313       findChild(syntax::NodeRole::ParenExpression_subExpression));
314 }
315 
316 syntax::Leaf *syntax::ParenExpression::closeParen() {
317   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
318 }
319 
320 syntax::Leaf *syntax::ThisExpression::thisKeyword() {
321   return cast_or_null<syntax::Leaf>(
322       findChild(syntax::NodeRole::IntroducerKeyword));
323 }
324 
325 syntax::Leaf *syntax::LiteralExpression::literalToken() {
326   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
327 }
328 
329 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
330   return cast_or_null<syntax::Expression>(
331       findChild(syntax::NodeRole::BinaryOperatorExpression_leftHandSide));
332 }
333 
334 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
335   return cast_or_null<syntax::Leaf>(
336       findChild(syntax::NodeRole::OperatorExpression_operatorToken));
337 }
338 
339 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
340   return cast_or_null<syntax::Expression>(
341       findChild(syntax::NodeRole::UnaryOperatorExpression_operand));
342 }
343 
344 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
345   return cast_or_null<syntax::Leaf>(
346       findChild(syntax::NodeRole::OperatorExpression_operatorToken));
347 }
348 
349 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
350   return cast_or_null<syntax::Expression>(
351       findChild(syntax::NodeRole::BinaryOperatorExpression_rightHandSide));
352 }
353 
354 syntax::Expression *syntax::CallExpression::callee() {
355   return cast_or_null<syntax::Expression>(
356       findChild(syntax::NodeRole::CallExpression_callee));
357 }
358 
359 syntax::Leaf *syntax::CallExpression::openParen() {
360   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
361 }
362 
363 syntax::CallArguments *syntax::CallExpression::arguments() {
364   return cast_or_null<syntax::CallArguments>(
365       findChild(syntax::NodeRole::CallExpression_arguments));
366 }
367 
368 syntax::Leaf *syntax::CallExpression::closeParen() {
369   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
370 }
371 
372 syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
373   return cast_or_null<syntax::Leaf>(
374       findChild(syntax::NodeRole::IntroducerKeyword));
375 }
376 
377 syntax::Statement *syntax::SwitchStatement::body() {
378   return cast_or_null<syntax::Statement>(
379       findChild(syntax::NodeRole::BodyStatement));
380 }
381 
382 syntax::Leaf *syntax::CaseStatement::caseKeyword() {
383   return cast_or_null<syntax::Leaf>(
384       findChild(syntax::NodeRole::IntroducerKeyword));
385 }
386 
387 syntax::Expression *syntax::CaseStatement::value() {
388   return cast_or_null<syntax::Expression>(
389       findChild(syntax::NodeRole::CaseStatement_value));
390 }
391 
392 syntax::Statement *syntax::CaseStatement::body() {
393   return cast_or_null<syntax::Statement>(
394       findChild(syntax::NodeRole::BodyStatement));
395 }
396 
397 syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {
398   return cast_or_null<syntax::Leaf>(
399       findChild(syntax::NodeRole::IntroducerKeyword));
400 }
401 
402 syntax::Statement *syntax::DefaultStatement::body() {
403   return cast_or_null<syntax::Statement>(
404       findChild(syntax::NodeRole::BodyStatement));
405 }
406 
407 syntax::Leaf *syntax::IfStatement::ifKeyword() {
408   return cast_or_null<syntax::Leaf>(
409       findChild(syntax::NodeRole::IntroducerKeyword));
410 }
411 
412 syntax::Statement *syntax::IfStatement::thenStatement() {
413   return cast_or_null<syntax::Statement>(
414       findChild(syntax::NodeRole::IfStatement_thenStatement));
415 }
416 
417 syntax::Leaf *syntax::IfStatement::elseKeyword() {
418   return cast_or_null<syntax::Leaf>(
419       findChild(syntax::NodeRole::IfStatement_elseKeyword));
420 }
421 
422 syntax::Statement *syntax::IfStatement::elseStatement() {
423   return cast_or_null<syntax::Statement>(
424       findChild(syntax::NodeRole::IfStatement_elseStatement));
425 }
426 
427 syntax::Leaf *syntax::ForStatement::forKeyword() {
428   return cast_or_null<syntax::Leaf>(
429       findChild(syntax::NodeRole::IntroducerKeyword));
430 }
431 
432 syntax::Statement *syntax::ForStatement::body() {
433   return cast_or_null<syntax::Statement>(
434       findChild(syntax::NodeRole::BodyStatement));
435 }
436 
437 syntax::Leaf *syntax::WhileStatement::whileKeyword() {
438   return cast_or_null<syntax::Leaf>(
439       findChild(syntax::NodeRole::IntroducerKeyword));
440 }
441 
442 syntax::Statement *syntax::WhileStatement::body() {
443   return cast_or_null<syntax::Statement>(
444       findChild(syntax::NodeRole::BodyStatement));
445 }
446 
447 syntax::Leaf *syntax::ContinueStatement::continueKeyword() {
448   return cast_or_null<syntax::Leaf>(
449       findChild(syntax::NodeRole::IntroducerKeyword));
450 }
451 
452 syntax::Leaf *syntax::BreakStatement::breakKeyword() {
453   return cast_or_null<syntax::Leaf>(
454       findChild(syntax::NodeRole::IntroducerKeyword));
455 }
456 
457 syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
458   return cast_or_null<syntax::Leaf>(
459       findChild(syntax::NodeRole::IntroducerKeyword));
460 }
461 
462 syntax::Expression *syntax::ReturnStatement::value() {
463   return cast_or_null<syntax::Expression>(
464       findChild(syntax::NodeRole::ReturnStatement_value));
465 }
466 
467 syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {
468   return cast_or_null<syntax::Leaf>(
469       findChild(syntax::NodeRole::IntroducerKeyword));
470 }
471 
472 syntax::Statement *syntax::RangeBasedForStatement::body() {
473   return cast_or_null<syntax::Statement>(
474       findChild(syntax::NodeRole::BodyStatement));
475 }
476 
477 syntax::Expression *syntax::ExpressionStatement::expression() {
478   return cast_or_null<syntax::Expression>(
479       findChild(syntax::NodeRole::ExpressionStatement_expression));
480 }
481 
482 syntax::Leaf *syntax::CompoundStatement::lbrace() {
483   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
484 }
485 
486 std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
487   std::vector<syntax::Statement *> Children;
488   for (auto *C = firstChild(); C; C = C->nextSibling()) {
489     assert(C->role() == syntax::NodeRole::CompoundStatement_statement);
490     Children.push_back(cast<syntax::Statement>(C));
491   }
492   return Children;
493 }
494 
495 syntax::Leaf *syntax::CompoundStatement::rbrace() {
496   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
497 }
498 
499 syntax::Expression *syntax::StaticAssertDeclaration::condition() {
500   return cast_or_null<syntax::Expression>(
501       findChild(syntax::NodeRole::StaticAssertDeclaration_condition));
502 }
503 
504 syntax::Expression *syntax::StaticAssertDeclaration::message() {
505   return cast_or_null<syntax::Expression>(
506       findChild(syntax::NodeRole::StaticAssertDeclaration_message));
507 }
508 
509 std::vector<syntax::SimpleDeclarator *>
510 syntax::SimpleDeclaration::declarators() {
511   std::vector<syntax::SimpleDeclarator *> Children;
512   for (auto *C = firstChild(); C; C = C->nextSibling()) {
513     if (C->role() == syntax::NodeRole::SimpleDeclaration_declarator)
514       Children.push_back(cast<syntax::SimpleDeclarator>(C));
515   }
516   return Children;
517 }
518 
519 syntax::Leaf *syntax::TemplateDeclaration::templateKeyword() {
520   return cast_or_null<syntax::Leaf>(
521       findChild(syntax::NodeRole::IntroducerKeyword));
522 }
523 
524 syntax::Declaration *syntax::TemplateDeclaration::declaration() {
525   return cast_or_null<syntax::Declaration>(
526       findChild(syntax::NodeRole::TemplateDeclaration_declaration));
527 }
528 
529 syntax::Leaf *syntax::ExplicitTemplateInstantiation::templateKeyword() {
530   return cast_or_null<syntax::Leaf>(
531       findChild(syntax::NodeRole::IntroducerKeyword));
532 }
533 
534 syntax::Leaf *syntax::ExplicitTemplateInstantiation::externKeyword() {
535   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
536 }
537 
538 syntax::Declaration *syntax::ExplicitTemplateInstantiation::declaration() {
539   return cast_or_null<syntax::Declaration>(
540       findChild(syntax::NodeRole::ExplicitTemplateInstantiation_declaration));
541 }
542 
543 syntax::Leaf *syntax::ParenDeclarator::lparen() {
544   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
545 }
546 
547 syntax::Leaf *syntax::ParenDeclarator::rparen() {
548   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
549 }
550 
551 syntax::Leaf *syntax::ArraySubscript::lbracket() {
552   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
553 }
554 
555 syntax::Expression *syntax::ArraySubscript::sizeExpression() {
556   return cast_or_null<syntax::Expression>(
557       findChild(syntax::NodeRole::ArraySubscript_sizeExpression));
558 }
559 
560 syntax::Leaf *syntax::ArraySubscript::rbracket() {
561   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
562 }
563 
564 syntax::Leaf *syntax::TrailingReturnType::arrowToken() {
565   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
566 }
567 
568 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
569   return cast_or_null<syntax::SimpleDeclarator>(
570       findChild(syntax::NodeRole::TrailingReturnType_declarator));
571 }
572 
573 syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
574   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
575 }
576 
577 std::vector<syntax::SimpleDeclaration *>
578 syntax::ParametersAndQualifiers::parameters() {
579   std::vector<syntax::SimpleDeclaration *> Children;
580   for (auto *C = firstChild(); C; C = C->nextSibling()) {
581     if (C->role() == syntax::NodeRole::ParametersAndQualifiers_parameter)
582       Children.push_back(cast<syntax::SimpleDeclaration>(C));
583   }
584   return Children;
585 }
586 
587 syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
588   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
589 }
590 
591 syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
592   return cast_or_null<syntax::TrailingReturnType>(
593       findChild(syntax::NodeRole::ParametersAndQualifiers_trailingReturn));
594 }
595