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   case NodeKind::ParameterDeclarationList:
138     return OS << "ParameterDeclarationList";
139   }
140   llvm_unreachable("unknown node kind");
141 }
142 
143 raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
144   switch (R) {
145   case syntax::NodeRole::Detached:
146     return OS << "Detached";
147   case syntax::NodeRole::Unknown:
148     return OS << "Unknown";
149   case syntax::NodeRole::OpenParen:
150     return OS << "OpenParen";
151   case syntax::NodeRole::CloseParen:
152     return OS << "CloseParen";
153   case syntax::NodeRole::IntroducerKeyword:
154     return OS << "IntroducerKeyword";
155   case syntax::NodeRole::LiteralToken:
156     return OS << "LiteralToken";
157   case syntax::NodeRole::ArrowToken:
158     return OS << "ArrowToken";
159   case syntax::NodeRole::ExternKeyword:
160     return OS << "ExternKeyword";
161   case syntax::NodeRole::TemplateKeyword:
162     return OS << "TemplateKeyword";
163   case syntax::NodeRole::BodyStatement:
164     return OS << "BodyStatement";
165   case syntax::NodeRole::ListElement:
166     return OS << "ListElement";
167   case syntax::NodeRole::ListDelimiter:
168     return OS << "ListDelimiter";
169   case syntax::NodeRole::CaseValue:
170     return OS << "CaseValue";
171   case syntax::NodeRole::ReturnValue:
172     return OS << "ReturnValue";
173   case syntax::NodeRole::ThenStatement:
174     return OS << "ThenStatement";
175   case syntax::NodeRole::ElseKeyword:
176     return OS << "ElseKeyword";
177   case syntax::NodeRole::ElseStatement:
178     return OS << "ElseStatement";
179   case syntax::NodeRole::OperatorToken:
180     return OS << "OperatorToken";
181   case syntax::NodeRole::Operand:
182     return OS << "Operand";
183   case syntax::NodeRole::LeftHandSide:
184     return OS << "LeftHandSide";
185   case syntax::NodeRole::RightHandSide:
186     return OS << "RightHandSide";
187   case syntax::NodeRole::Expression:
188     return OS << "Expression";
189   case syntax::NodeRole::Statement:
190     return OS << "Statement";
191   case syntax::NodeRole::Condition:
192     return OS << "Condition";
193   case syntax::NodeRole::Message:
194     return OS << "Message";
195   case syntax::NodeRole::Declarator:
196     return OS << "Declarator";
197   case syntax::NodeRole::Declaration:
198     return OS << "Declaration";
199   case syntax::NodeRole::Size:
200     return OS << "Size";
201   case syntax::NodeRole::Parameters:
202     return OS << "Parameters";
203   case syntax::NodeRole::TrailingReturn:
204     return OS << "TrailingReturn";
205   case syntax::NodeRole::UnqualifiedId:
206     return OS << "UnqualifiedId";
207   case syntax::NodeRole::Qualifier:
208     return OS << "Qualifier";
209   case syntax::NodeRole::SubExpression:
210     return OS << "SubExpression";
211   case syntax::NodeRole::Object:
212     return OS << "Object";
213   case syntax::NodeRole::AccessToken:
214     return OS << "AccessToken";
215   case syntax::NodeRole::Member:
216     return OS << "Member";
217   case syntax::NodeRole::Callee:
218     return OS << "Callee";
219   case syntax::NodeRole::Arguments:
220     return OS << "Arguments";
221   }
222   llvm_unreachable("invalid role");
223 }
224 
225 // We could have an interator in list to not pay memory costs of temporary
226 // vector
227 std::vector<syntax::NameSpecifier *>
228 syntax::NestedNameSpecifier::getSpecifiers() {
229   auto SpecifiersAsNodes = getElementsAsNodes();
230   std::vector<syntax::NameSpecifier *> Children;
231   for (const auto &Element : SpecifiersAsNodes) {
232     Children.push_back(llvm::cast<syntax::NameSpecifier>(Element));
233   }
234   return Children;
235 }
236 
237 std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
238 syntax::NestedNameSpecifier::getSpecifiersAndDoubleColons() {
239   auto SpecifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
240   std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
241       Children;
242   for (const auto &SpecifierAndDoubleColon : SpecifiersAsNodesAndDoubleColons) {
243     Children.push_back(
244         {llvm::cast<syntax::NameSpecifier>(SpecifierAndDoubleColon.element),
245          SpecifierAndDoubleColon.delimiter});
246   }
247   return Children;
248 }
249 
250 std::vector<syntax::Expression *> syntax::CallArguments::getArguments() {
251   auto ArgumentsAsNodes = getElementsAsNodes();
252   std::vector<syntax::Expression *> Children;
253   for (const auto &ArgumentAsNode : ArgumentsAsNodes) {
254     Children.push_back(llvm::cast<syntax::Expression>(ArgumentAsNode));
255   }
256   return Children;
257 }
258 
259 std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
260 syntax::CallArguments::getArgumentsAndCommas() {
261   auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
262   std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> Children;
263   for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
264     Children.push_back(
265         {llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
266          ArgumentAsNodeAndComma.delimiter});
267   }
268   return Children;
269 }
270 
271 std::vector<syntax::SimpleDeclaration *>
272 syntax::ParameterDeclarationList::getParameterDeclarations() {
273   auto ParametersAsNodes = getElementsAsNodes();
274   std::vector<syntax::SimpleDeclaration *> Children;
275   for (const auto &ParameterAsNode : ParametersAsNodes) {
276     Children.push_back(llvm::cast<syntax::SimpleDeclaration>(ParameterAsNode));
277   }
278   return Children;
279 }
280 
281 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
282 syntax::ParameterDeclarationList::getParametersAndCommas() {
283   auto ParametersAsNodesAndCommas = getElementsAsNodesAndDelimiters();
284   std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
285       Children;
286   for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {
287     Children.push_back(
288         {llvm::cast<syntax::SimpleDeclaration>(ParameterAsNodeAndComma.element),
289          ParameterAsNodeAndComma.delimiter});
290   }
291   return Children;
292 }
293 
294 syntax::Expression *syntax::MemberExpression::getObject() {
295   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Object));
296 }
297 
298 syntax::Leaf *syntax::MemberExpression::getTemplateKeyword() {
299   return llvm::cast_or_null<syntax::Leaf>(
300       findChild(syntax::NodeRole::TemplateKeyword));
301 }
302 
303 syntax::Leaf *syntax::MemberExpression::getAccessToken() {
304   return llvm::cast_or_null<syntax::Leaf>(
305       findChild(syntax::NodeRole::AccessToken));
306 }
307 
308 syntax::IdExpression *syntax::MemberExpression::getMember() {
309   return cast_or_null<syntax::IdExpression>(
310       findChild(syntax::NodeRole::Member));
311 }
312 
313 syntax::NestedNameSpecifier *syntax::IdExpression::getQualifier() {
314   return cast_or_null<syntax::NestedNameSpecifier>(
315       findChild(syntax::NodeRole::Qualifier));
316 }
317 
318 syntax::Leaf *syntax::IdExpression::getTemplateKeyword() {
319   return llvm::cast_or_null<syntax::Leaf>(
320       findChild(syntax::NodeRole::TemplateKeyword));
321 }
322 
323 syntax::UnqualifiedId *syntax::IdExpression::getUnqualifiedId() {
324   return cast_or_null<syntax::UnqualifiedId>(
325       findChild(syntax::NodeRole::UnqualifiedId));
326 }
327 
328 syntax::Leaf *syntax::ParenExpression::getOpenParen() {
329   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
330 }
331 
332 syntax::Expression *syntax::ParenExpression::getSubExpression() {
333   return cast_or_null<syntax::Expression>(
334       findChild(syntax::NodeRole::SubExpression));
335 }
336 
337 syntax::Leaf *syntax::ParenExpression::getCloseParen() {
338   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
339 }
340 
341 syntax::Leaf *syntax::ThisExpression::getThisKeyword() {
342   return cast_or_null<syntax::Leaf>(
343       findChild(syntax::NodeRole::IntroducerKeyword));
344 }
345 
346 syntax::Leaf *syntax::LiteralExpression::getLiteralToken() {
347   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
348 }
349 
350 syntax::Expression *syntax::BinaryOperatorExpression::getLhs() {
351   return cast_or_null<syntax::Expression>(
352       findChild(syntax::NodeRole::LeftHandSide));
353 }
354 
355 syntax::Leaf *syntax::UnaryOperatorExpression::getOperatorToken() {
356   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
357 }
358 
359 syntax::Expression *syntax::UnaryOperatorExpression::getOperand() {
360   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Operand));
361 }
362 
363 syntax::Leaf *syntax::BinaryOperatorExpression::getOperatorToken() {
364   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
365 }
366 
367 syntax::Expression *syntax::BinaryOperatorExpression::getRhs() {
368   return cast_or_null<syntax::Expression>(
369       findChild(syntax::NodeRole::RightHandSide));
370 }
371 
372 syntax::Expression *syntax::CallExpression::getCallee() {
373   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Callee));
374 }
375 
376 syntax::Leaf *syntax::CallExpression::getOpenParen() {
377   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
378 }
379 
380 syntax::CallArguments *syntax::CallExpression::getArguments() {
381   return cast_or_null<syntax::CallArguments>(
382       findChild(syntax::NodeRole::Arguments));
383 }
384 
385 syntax::Leaf *syntax::CallExpression::getCloseParen() {
386   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
387 }
388 
389 syntax::Leaf *syntax::SwitchStatement::getSwitchKeyword() {
390   return cast_or_null<syntax::Leaf>(
391       findChild(syntax::NodeRole::IntroducerKeyword));
392 }
393 
394 syntax::Statement *syntax::SwitchStatement::getBody() {
395   return cast_or_null<syntax::Statement>(
396       findChild(syntax::NodeRole::BodyStatement));
397 }
398 
399 syntax::Leaf *syntax::CaseStatement::getCaseKeyword() {
400   return cast_or_null<syntax::Leaf>(
401       findChild(syntax::NodeRole::IntroducerKeyword));
402 }
403 
404 syntax::Expression *syntax::CaseStatement::getCaseValue() {
405   return cast_or_null<syntax::Expression>(
406       findChild(syntax::NodeRole::CaseValue));
407 }
408 
409 syntax::Statement *syntax::CaseStatement::getBody() {
410   return cast_or_null<syntax::Statement>(
411       findChild(syntax::NodeRole::BodyStatement));
412 }
413 
414 syntax::Leaf *syntax::DefaultStatement::getDefaultKeyword() {
415   return cast_or_null<syntax::Leaf>(
416       findChild(syntax::NodeRole::IntroducerKeyword));
417 }
418 
419 syntax::Statement *syntax::DefaultStatement::getBody() {
420   return cast_or_null<syntax::Statement>(
421       findChild(syntax::NodeRole::BodyStatement));
422 }
423 
424 syntax::Leaf *syntax::IfStatement::getIfKeyword() {
425   return cast_or_null<syntax::Leaf>(
426       findChild(syntax::NodeRole::IntroducerKeyword));
427 }
428 
429 syntax::Statement *syntax::IfStatement::getThenStatement() {
430   return cast_or_null<syntax::Statement>(
431       findChild(syntax::NodeRole::ThenStatement));
432 }
433 
434 syntax::Leaf *syntax::IfStatement::getElseKeyword() {
435   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ElseKeyword));
436 }
437 
438 syntax::Statement *syntax::IfStatement::getElseStatement() {
439   return cast_or_null<syntax::Statement>(
440       findChild(syntax::NodeRole::ElseStatement));
441 }
442 
443 syntax::Leaf *syntax::ForStatement::getForKeyword() {
444   return cast_or_null<syntax::Leaf>(
445       findChild(syntax::NodeRole::IntroducerKeyword));
446 }
447 
448 syntax::Statement *syntax::ForStatement::getBody() {
449   return cast_or_null<syntax::Statement>(
450       findChild(syntax::NodeRole::BodyStatement));
451 }
452 
453 syntax::Leaf *syntax::WhileStatement::getWhileKeyword() {
454   return cast_or_null<syntax::Leaf>(
455       findChild(syntax::NodeRole::IntroducerKeyword));
456 }
457 
458 syntax::Statement *syntax::WhileStatement::getBody() {
459   return cast_or_null<syntax::Statement>(
460       findChild(syntax::NodeRole::BodyStatement));
461 }
462 
463 syntax::Leaf *syntax::ContinueStatement::getContinueKeyword() {
464   return cast_or_null<syntax::Leaf>(
465       findChild(syntax::NodeRole::IntroducerKeyword));
466 }
467 
468 syntax::Leaf *syntax::BreakStatement::getBreakKeyword() {
469   return cast_or_null<syntax::Leaf>(
470       findChild(syntax::NodeRole::IntroducerKeyword));
471 }
472 
473 syntax::Leaf *syntax::ReturnStatement::getReturnKeyword() {
474   return cast_or_null<syntax::Leaf>(
475       findChild(syntax::NodeRole::IntroducerKeyword));
476 }
477 
478 syntax::Expression *syntax::ReturnStatement::getReturnValue() {
479   return cast_or_null<syntax::Expression>(
480       findChild(syntax::NodeRole::ReturnValue));
481 }
482 
483 syntax::Leaf *syntax::RangeBasedForStatement::getForKeyword() {
484   return cast_or_null<syntax::Leaf>(
485       findChild(syntax::NodeRole::IntroducerKeyword));
486 }
487 
488 syntax::Statement *syntax::RangeBasedForStatement::getBody() {
489   return cast_or_null<syntax::Statement>(
490       findChild(syntax::NodeRole::BodyStatement));
491 }
492 
493 syntax::Expression *syntax::ExpressionStatement::getExpression() {
494   return cast_or_null<syntax::Expression>(
495       findChild(syntax::NodeRole::Expression));
496 }
497 
498 syntax::Leaf *syntax::CompoundStatement::getLbrace() {
499   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
500 }
501 
502 std::vector<syntax::Statement *> syntax::CompoundStatement::getStatements() {
503   std::vector<syntax::Statement *> Children;
504   for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
505     assert(C->getRole() == syntax::NodeRole::Statement);
506     Children.push_back(cast<syntax::Statement>(C));
507   }
508   return Children;
509 }
510 
511 syntax::Leaf *syntax::CompoundStatement::getRbrace() {
512   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
513 }
514 
515 syntax::Expression *syntax::StaticAssertDeclaration::getCondition() {
516   return cast_or_null<syntax::Expression>(
517       findChild(syntax::NodeRole::Condition));
518 }
519 
520 syntax::Expression *syntax::StaticAssertDeclaration::getMessage() {
521   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message));
522 }
523 
524 std::vector<syntax::SimpleDeclarator *>
525 syntax::SimpleDeclaration::getDeclarators() {
526   std::vector<syntax::SimpleDeclarator *> Children;
527   for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
528     if (C->getRole() == syntax::NodeRole::Declarator)
529       Children.push_back(cast<syntax::SimpleDeclarator>(C));
530   }
531   return Children;
532 }
533 
534 syntax::Leaf *syntax::TemplateDeclaration::getTemplateKeyword() {
535   return cast_or_null<syntax::Leaf>(
536       findChild(syntax::NodeRole::IntroducerKeyword));
537 }
538 
539 syntax::Declaration *syntax::TemplateDeclaration::getDeclaration() {
540   return cast_or_null<syntax::Declaration>(
541       findChild(syntax::NodeRole::Declaration));
542 }
543 
544 syntax::Leaf *syntax::ExplicitTemplateInstantiation::getTemplateKeyword() {
545   return cast_or_null<syntax::Leaf>(
546       findChild(syntax::NodeRole::IntroducerKeyword));
547 }
548 
549 syntax::Leaf *syntax::ExplicitTemplateInstantiation::getExternKeyword() {
550   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
551 }
552 
553 syntax::Declaration *syntax::ExplicitTemplateInstantiation::getDeclaration() {
554   return cast_or_null<syntax::Declaration>(
555       findChild(syntax::NodeRole::Declaration));
556 }
557 
558 syntax::Leaf *syntax::ParenDeclarator::getLparen() {
559   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
560 }
561 
562 syntax::Leaf *syntax::ParenDeclarator::getRparen() {
563   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
564 }
565 
566 syntax::Leaf *syntax::ArraySubscript::getLbracket() {
567   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
568 }
569 
570 syntax::Expression *syntax::ArraySubscript::getSize() {
571   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Size));
572 }
573 
574 syntax::Leaf *syntax::ArraySubscript::getRbracket() {
575   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
576 }
577 
578 syntax::Leaf *syntax::TrailingReturnType::getArrowToken() {
579   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
580 }
581 
582 syntax::SimpleDeclarator *syntax::TrailingReturnType::getDeclarator() {
583   return cast_or_null<syntax::SimpleDeclarator>(
584       findChild(syntax::NodeRole::Declarator));
585 }
586 
587 syntax::Leaf *syntax::ParametersAndQualifiers::getLparen() {
588   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
589 }
590 
591 syntax::ParameterDeclarationList *
592 syntax::ParametersAndQualifiers::getParameters() {
593   return cast_or_null<syntax::ParameterDeclarationList>(
594       findChild(syntax::NodeRole::Parameters));
595 }
596 
597 syntax::Leaf *syntax::ParametersAndQualifiers::getRparen() {
598   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
599 }
600 
601 syntax::TrailingReturnType *
602 syntax::ParametersAndQualifiers::getTrailingReturn() {
603   return cast_or_null<syntax::TrailingReturnType>(
604       findChild(syntax::NodeRole::TrailingReturn));
605 }
606