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