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