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 *> syntax::NestedNameSpecifier::specifiers() {
228   auto specifiersAsNodes = getElementsAsNodes();
229   std::vector<syntax::NameSpecifier *> Children;
230   for (const auto &element : specifiersAsNodes) {
231     Children.push_back(llvm::cast<syntax::NameSpecifier>(element));
232   }
233   return Children;
234 }
235 
236 std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
237 syntax::NestedNameSpecifier::specifiersAndDoubleColons() {
238   auto specifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
239   std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
240       Children;
241   for (const auto &specifierAndDoubleColon : specifiersAsNodesAndDoubleColons) {
242     Children.push_back(
243         {llvm::cast<syntax::NameSpecifier>(specifierAndDoubleColon.element),
244          specifierAndDoubleColon.delimiter});
245   }
246   return Children;
247 }
248 
249 std::vector<syntax::Expression *> syntax::CallArguments::arguments() {
250   auto ArgumentsAsNodes = getElementsAsNodes();
251   std::vector<syntax::Expression *> Children;
252   for (const auto &ArgumentAsNode : ArgumentsAsNodes) {
253     Children.push_back(llvm::cast<syntax::Expression>(ArgumentAsNode));
254   }
255   return Children;
256 }
257 
258 std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
259 syntax::CallArguments::argumentsAndCommas() {
260   auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
261   std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> Children;
262   for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
263     Children.push_back(
264         {llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
265          ArgumentAsNodeAndComma.delimiter});
266   }
267   return Children;
268 }
269 
270 std::vector<syntax::SimpleDeclaration *>
271 syntax::ParameterDeclarationList::parameterDeclarations() {
272   auto ParametersAsNodes = getElementsAsNodes();
273   std::vector<syntax::SimpleDeclaration *> Children;
274   for (const auto &ParameterAsNode : ParametersAsNodes) {
275     Children.push_back(llvm::cast<syntax::SimpleDeclaration>(ParameterAsNode));
276   }
277   return Children;
278 }
279 
280 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
281 syntax::ParameterDeclarationList::parametersAndCommas() {
282   auto ParametersAsNodesAndCommas = getElementsAsNodesAndDelimiters();
283   std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
284       Children;
285   for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {
286     Children.push_back(
287         {llvm::cast<syntax::SimpleDeclaration>(ParameterAsNodeAndComma.element),
288          ParameterAsNodeAndComma.delimiter});
289   }
290   return Children;
291 }
292 
293 syntax::Expression *syntax::MemberExpression::object() {
294   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Object));
295 }
296 
297 syntax::Leaf *syntax::MemberExpression::templateKeyword() {
298   return llvm::cast_or_null<syntax::Leaf>(
299       findChild(syntax::NodeRole::TemplateKeyword));
300 }
301 
302 syntax::Leaf *syntax::MemberExpression::accessToken() {
303   return llvm::cast_or_null<syntax::Leaf>(
304       findChild(syntax::NodeRole::AccessToken));
305 }
306 
307 syntax::IdExpression *syntax::MemberExpression::member() {
308   return cast_or_null<syntax::IdExpression>(
309       findChild(syntax::NodeRole::Member));
310 }
311 
312 syntax::NestedNameSpecifier *syntax::IdExpression::qualifier() {
313   return cast_or_null<syntax::NestedNameSpecifier>(
314       findChild(syntax::NodeRole::Qualifier));
315 }
316 
317 syntax::Leaf *syntax::IdExpression::templateKeyword() {
318   return llvm::cast_or_null<syntax::Leaf>(
319       findChild(syntax::NodeRole::TemplateKeyword));
320 }
321 
322 syntax::UnqualifiedId *syntax::IdExpression::unqualifiedId() {
323   return cast_or_null<syntax::UnqualifiedId>(
324       findChild(syntax::NodeRole::UnqualifiedId));
325 }
326 
327 syntax::Leaf *syntax::ParenExpression::openParen() {
328   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
329 }
330 
331 syntax::Expression *syntax::ParenExpression::subExpression() {
332   return cast_or_null<syntax::Expression>(
333       findChild(syntax::NodeRole::SubExpression));
334 }
335 
336 syntax::Leaf *syntax::ParenExpression::closeParen() {
337   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
338 }
339 
340 syntax::Leaf *syntax::ThisExpression::thisKeyword() {
341   return cast_or_null<syntax::Leaf>(
342       findChild(syntax::NodeRole::IntroducerKeyword));
343 }
344 
345 syntax::Leaf *syntax::LiteralExpression::literalToken() {
346   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::LiteralToken));
347 }
348 
349 syntax::Expression *syntax::BinaryOperatorExpression::lhs() {
350   return cast_or_null<syntax::Expression>(
351       findChild(syntax::NodeRole::LeftHandSide));
352 }
353 
354 syntax::Leaf *syntax::UnaryOperatorExpression::operatorToken() {
355   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
356 }
357 
358 syntax::Expression *syntax::UnaryOperatorExpression::operand() {
359   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Operand));
360 }
361 
362 syntax::Leaf *syntax::BinaryOperatorExpression::operatorToken() {
363   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
364 }
365 
366 syntax::Expression *syntax::BinaryOperatorExpression::rhs() {
367   return cast_or_null<syntax::Expression>(
368       findChild(syntax::NodeRole::RightHandSide));
369 }
370 
371 syntax::Expression *syntax::CallExpression::callee() {
372   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Callee));
373 }
374 
375 syntax::Leaf *syntax::CallExpression::openParen() {
376   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
377 }
378 
379 syntax::CallArguments *syntax::CallExpression::arguments() {
380   return cast_or_null<syntax::CallArguments>(
381       findChild(syntax::NodeRole::Arguments));
382 }
383 
384 syntax::Leaf *syntax::CallExpression::closeParen() {
385   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
386 }
387 
388 syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
389   return cast_or_null<syntax::Leaf>(
390       findChild(syntax::NodeRole::IntroducerKeyword));
391 }
392 
393 syntax::Statement *syntax::SwitchStatement::body() {
394   return cast_or_null<syntax::Statement>(
395       findChild(syntax::NodeRole::BodyStatement));
396 }
397 
398 syntax::Leaf *syntax::CaseStatement::caseKeyword() {
399   return cast_or_null<syntax::Leaf>(
400       findChild(syntax::NodeRole::IntroducerKeyword));
401 }
402 
403 syntax::Expression *syntax::CaseStatement::caseValue() {
404   return cast_or_null<syntax::Expression>(
405       findChild(syntax::NodeRole::CaseValue));
406 }
407 
408 syntax::Statement *syntax::CaseStatement::body() {
409   return cast_or_null<syntax::Statement>(
410       findChild(syntax::NodeRole::BodyStatement));
411 }
412 
413 syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {
414   return cast_or_null<syntax::Leaf>(
415       findChild(syntax::NodeRole::IntroducerKeyword));
416 }
417 
418 syntax::Statement *syntax::DefaultStatement::body() {
419   return cast_or_null<syntax::Statement>(
420       findChild(syntax::NodeRole::BodyStatement));
421 }
422 
423 syntax::Leaf *syntax::IfStatement::ifKeyword() {
424   return cast_or_null<syntax::Leaf>(
425       findChild(syntax::NodeRole::IntroducerKeyword));
426 }
427 
428 syntax::Statement *syntax::IfStatement::thenStatement() {
429   return cast_or_null<syntax::Statement>(
430       findChild(syntax::NodeRole::ThenStatement));
431 }
432 
433 syntax::Leaf *syntax::IfStatement::elseKeyword() {
434   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ElseKeyword));
435 }
436 
437 syntax::Statement *syntax::IfStatement::elseStatement() {
438   return cast_or_null<syntax::Statement>(
439       findChild(syntax::NodeRole::ElseStatement));
440 }
441 
442 syntax::Leaf *syntax::ForStatement::forKeyword() {
443   return cast_or_null<syntax::Leaf>(
444       findChild(syntax::NodeRole::IntroducerKeyword));
445 }
446 
447 syntax::Statement *syntax::ForStatement::body() {
448   return cast_or_null<syntax::Statement>(
449       findChild(syntax::NodeRole::BodyStatement));
450 }
451 
452 syntax::Leaf *syntax::WhileStatement::whileKeyword() {
453   return cast_or_null<syntax::Leaf>(
454       findChild(syntax::NodeRole::IntroducerKeyword));
455 }
456 
457 syntax::Statement *syntax::WhileStatement::body() {
458   return cast_or_null<syntax::Statement>(
459       findChild(syntax::NodeRole::BodyStatement));
460 }
461 
462 syntax::Leaf *syntax::ContinueStatement::continueKeyword() {
463   return cast_or_null<syntax::Leaf>(
464       findChild(syntax::NodeRole::IntroducerKeyword));
465 }
466 
467 syntax::Leaf *syntax::BreakStatement::breakKeyword() {
468   return cast_or_null<syntax::Leaf>(
469       findChild(syntax::NodeRole::IntroducerKeyword));
470 }
471 
472 syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
473   return cast_or_null<syntax::Leaf>(
474       findChild(syntax::NodeRole::IntroducerKeyword));
475 }
476 
477 syntax::Expression *syntax::ReturnStatement::returnValue() {
478   return cast_or_null<syntax::Expression>(
479       findChild(syntax::NodeRole::ReturnValue));
480 }
481 
482 syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {
483   return cast_or_null<syntax::Leaf>(
484       findChild(syntax::NodeRole::IntroducerKeyword));
485 }
486 
487 syntax::Statement *syntax::RangeBasedForStatement::body() {
488   return cast_or_null<syntax::Statement>(
489       findChild(syntax::NodeRole::BodyStatement));
490 }
491 
492 syntax::Expression *syntax::ExpressionStatement::expression() {
493   return cast_or_null<syntax::Expression>(
494       findChild(syntax::NodeRole::Expression));
495 }
496 
497 syntax::Leaf *syntax::CompoundStatement::lbrace() {
498   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
499 }
500 
501 std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
502   std::vector<syntax::Statement *> Children;
503   for (auto *C = firstChild(); C; C = C->nextSibling()) {
504     assert(C->role() == syntax::NodeRole::Statement);
505     Children.push_back(cast<syntax::Statement>(C));
506   }
507   return Children;
508 }
509 
510 syntax::Leaf *syntax::CompoundStatement::rbrace() {
511   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
512 }
513 
514 syntax::Expression *syntax::StaticAssertDeclaration::condition() {
515   return cast_or_null<syntax::Expression>(
516       findChild(syntax::NodeRole::Condition));
517 }
518 
519 syntax::Expression *syntax::StaticAssertDeclaration::message() {
520   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message));
521 }
522 
523 std::vector<syntax::SimpleDeclarator *>
524 syntax::SimpleDeclaration::declarators() {
525   std::vector<syntax::SimpleDeclarator *> Children;
526   for (auto *C = firstChild(); C; C = C->nextSibling()) {
527     if (C->role() == syntax::NodeRole::Declarator)
528       Children.push_back(cast<syntax::SimpleDeclarator>(C));
529   }
530   return Children;
531 }
532 
533 syntax::Leaf *syntax::TemplateDeclaration::templateKeyword() {
534   return cast_or_null<syntax::Leaf>(
535       findChild(syntax::NodeRole::IntroducerKeyword));
536 }
537 
538 syntax::Declaration *syntax::TemplateDeclaration::declaration() {
539   return cast_or_null<syntax::Declaration>(
540       findChild(syntax::NodeRole::Declaration));
541 }
542 
543 syntax::Leaf *syntax::ExplicitTemplateInstantiation::templateKeyword() {
544   return cast_or_null<syntax::Leaf>(
545       findChild(syntax::NodeRole::IntroducerKeyword));
546 }
547 
548 syntax::Leaf *syntax::ExplicitTemplateInstantiation::externKeyword() {
549   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
550 }
551 
552 syntax::Declaration *syntax::ExplicitTemplateInstantiation::declaration() {
553   return cast_or_null<syntax::Declaration>(
554       findChild(syntax::NodeRole::Declaration));
555 }
556 
557 syntax::Leaf *syntax::ParenDeclarator::lparen() {
558   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
559 }
560 
561 syntax::Leaf *syntax::ParenDeclarator::rparen() {
562   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
563 }
564 
565 syntax::Leaf *syntax::ArraySubscript::lbracket() {
566   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
567 }
568 
569 syntax::Expression *syntax::ArraySubscript::size() {
570   return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Size));
571 }
572 
573 syntax::Leaf *syntax::ArraySubscript::rbracket() {
574   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
575 }
576 
577 syntax::Leaf *syntax::TrailingReturnType::arrowToken() {
578   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
579 }
580 
581 syntax::SimpleDeclarator *syntax::TrailingReturnType::declarator() {
582   return cast_or_null<syntax::SimpleDeclarator>(
583       findChild(syntax::NodeRole::Declarator));
584 }
585 
586 syntax::Leaf *syntax::ParametersAndQualifiers::lparen() {
587   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
588 }
589 
590 syntax::ParameterDeclarationList *
591 syntax::ParametersAndQualifiers::parameters() {
592   return cast_or_null<syntax::ParameterDeclarationList>(
593       findChild(syntax::NodeRole::Parameters));
594 }
595 
596 syntax::Leaf *syntax::ParametersAndQualifiers::rparen() {
597   return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
598 }
599 
600 syntax::TrailingReturnType *syntax::ParametersAndQualifiers::trailingReturn() {
601   return cast_or_null<syntax::TrailingReturnType>(
602       findChild(syntax::NodeRole::TrailingReturn));
603 }
604