clang 20.0.0git
Nodes.cpp
Go to the documentation of this file.
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//===----------------------------------------------------------------------===//
9#include "llvm/Support/raw_ostream.h"
10
11using namespace clang;
12
13raw_ostream &syntax::operator<<(raw_ostream &OS, NodeKind K) {
14 switch (K) {
15#define CONCRETE_NODE(Kind, Parent) \
16 case NodeKind::Kind: \
17 return OS << #Kind;
18#include "clang/Tooling/Syntax/Nodes.inc"
19 }
20 llvm_unreachable("unknown node kind");
21}
22
23raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
24 switch (R) {
25 case syntax::NodeRole::Detached:
26 return OS << "Detached";
27 case syntax::NodeRole::Unknown:
28 return OS << "Unknown";
29 case syntax::NodeRole::OpenParen:
30 return OS << "OpenParen";
31 case syntax::NodeRole::CloseParen:
32 return OS << "CloseParen";
33 case syntax::NodeRole::IntroducerKeyword:
34 return OS << "IntroducerKeyword";
35 case syntax::NodeRole::LiteralToken:
36 return OS << "LiteralToken";
37 case syntax::NodeRole::ArrowToken:
38 return OS << "ArrowToken";
39 case syntax::NodeRole::ExternKeyword:
40 return OS << "ExternKeyword";
41 case syntax::NodeRole::TemplateKeyword:
42 return OS << "TemplateKeyword";
43 case syntax::NodeRole::BodyStatement:
44 return OS << "BodyStatement";
45 case syntax::NodeRole::ListElement:
46 return OS << "ListElement";
47 case syntax::NodeRole::ListDelimiter:
48 return OS << "ListDelimiter";
49 case syntax::NodeRole::CaseValue:
50 return OS << "CaseValue";
51 case syntax::NodeRole::ReturnValue:
52 return OS << "ReturnValue";
53 case syntax::NodeRole::ThenStatement:
54 return OS << "ThenStatement";
55 case syntax::NodeRole::ElseKeyword:
56 return OS << "ElseKeyword";
57 case syntax::NodeRole::ElseStatement:
58 return OS << "ElseStatement";
59 case syntax::NodeRole::OperatorToken:
60 return OS << "OperatorToken";
61 case syntax::NodeRole::Operand:
62 return OS << "Operand";
63 case syntax::NodeRole::LeftHandSide:
64 return OS << "LeftHandSide";
65 case syntax::NodeRole::RightHandSide:
66 return OS << "RightHandSide";
67 case syntax::NodeRole::Expression:
68 return OS << "Expression";
69 case syntax::NodeRole::Statement:
70 return OS << "Statement";
71 case syntax::NodeRole::Condition:
72 return OS << "Condition";
73 case syntax::NodeRole::Message:
74 return OS << "Message";
75 case syntax::NodeRole::Declarator:
76 return OS << "Declarator";
77 case syntax::NodeRole::Declaration:
78 return OS << "Declaration";
79 case syntax::NodeRole::Size:
80 return OS << "Size";
81 case syntax::NodeRole::Parameters:
82 return OS << "Parameters";
83 case syntax::NodeRole::TrailingReturn:
84 return OS << "TrailingReturn";
85 case syntax::NodeRole::UnqualifiedId:
86 return OS << "UnqualifiedId";
87 case syntax::NodeRole::Qualifier:
88 return OS << "Qualifier";
89 case syntax::NodeRole::SubExpression:
90 return OS << "SubExpression";
91 case syntax::NodeRole::Object:
92 return OS << "Object";
93 case syntax::NodeRole::AccessToken:
94 return OS << "AccessToken";
95 case syntax::NodeRole::Member:
96 return OS << "Member";
97 case syntax::NodeRole::Callee:
98 return OS << "Callee";
99 case syntax::NodeRole::Arguments:
100 return OS << "Arguments";
101 case syntax::NodeRole::Declarators:
102 return OS << "Declarators";
103 }
104 llvm_unreachable("invalid role");
105}
106
107// We could have an interator in list to not pay memory costs of temporary
108// vector
109std::vector<syntax::NameSpecifier *>
111 auto SpecifiersAsNodes = getElementsAsNodes();
112 std::vector<syntax::NameSpecifier *> Children;
113 for (const auto &Element : SpecifiersAsNodes) {
114 Children.push_back(llvm::cast<syntax::NameSpecifier>(Element));
115 }
116 return Children;
117}
118
119std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
121 auto SpecifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
122 std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
123 Children;
124 for (const auto &SpecifierAndDoubleColon : SpecifiersAsNodesAndDoubleColons) {
125 Children.push_back(
126 {llvm::cast<syntax::NameSpecifier>(SpecifierAndDoubleColon.element),
127 SpecifierAndDoubleColon.delimiter});
128 }
129 return Children;
130}
131
132std::vector<syntax::Expression *> syntax::CallArguments::getArguments() {
133 auto ArgumentsAsNodes = getElementsAsNodes();
134 std::vector<syntax::Expression *> Children;
135 for (const auto &ArgumentAsNode : ArgumentsAsNodes) {
136 Children.push_back(llvm::cast<syntax::Expression>(ArgumentAsNode));
137 }
138 return Children;
139}
140
141std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
143 auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
144 std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> Children;
145 for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
146 Children.push_back(
147 {llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
148 ArgumentAsNodeAndComma.delimiter});
149 }
150 return Children;
151}
152
153std::vector<syntax::SimpleDeclaration *>
155 auto ParametersAsNodes = getElementsAsNodes();
156 std::vector<syntax::SimpleDeclaration *> Children;
157 for (const auto &ParameterAsNode : ParametersAsNodes) {
158 Children.push_back(llvm::cast<syntax::SimpleDeclaration>(ParameterAsNode));
159 }
160 return Children;
161}
162
163std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
165 auto ParametersAsNodesAndCommas = getElementsAsNodesAndDelimiters();
166 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
167 Children;
168 for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {
169 Children.push_back(
170 {llvm::cast<syntax::SimpleDeclaration>(ParameterAsNodeAndComma.element),
171 ParameterAsNodeAndComma.delimiter});
172 }
173 return Children;
174}
175
176std::vector<syntax::SimpleDeclarator *>
178 auto DeclaratorsAsNodes = getElementsAsNodes();
179 std::vector<syntax::SimpleDeclarator *> Children;
180 for (const auto &DeclaratorAsNode : DeclaratorsAsNodes) {
181 Children.push_back(llvm::cast<syntax::SimpleDeclarator>(DeclaratorAsNode));
182 }
183 return Children;
184}
185
186std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclarator>>
188 auto DeclaratorsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
189 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclarator>>
190 Children;
191 for (const auto &DeclaratorAsNodeAndComma : DeclaratorsAsNodesAndCommas) {
192 Children.push_back(
193 {llvm::cast<syntax::SimpleDeclarator>(DeclaratorAsNodeAndComma.element),
194 DeclaratorAsNodeAndComma.delimiter});
195 }
196 return Children;
197}
198
200 return cast_or_null<syntax::Expression>(
202}
203
205 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
206}
207
209 return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Operand));
210}
211
213 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
214}
215
217 return cast_or_null<syntax::Expression>(
219}
220
222 return cast_or_null<syntax::Leaf>(
224}
225
227 return cast_or_null<syntax::Statement>(
229}
230
232 return cast_or_null<syntax::Leaf>(
234}
235
237 return cast_or_null<syntax::Expression>(
238 findChild(syntax::NodeRole::CaseValue));
239}
240
242 return cast_or_null<syntax::Statement>(
244}
245
247 return cast_or_null<syntax::Leaf>(
249}
250
252 return cast_or_null<syntax::Statement>(
254}
255
257 return cast_or_null<syntax::Leaf>(
259}
260
262 return cast_or_null<syntax::Statement>(
264}
265
267 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ElseKeyword));
268}
269
271 return cast_or_null<syntax::Statement>(
273}
274
276 return cast_or_null<syntax::Leaf>(
278}
279
281 return cast_or_null<syntax::Statement>(
283}
284
286 return cast_or_null<syntax::Leaf>(
288}
289
291 return cast_or_null<syntax::Statement>(
293}
294
296 return cast_or_null<syntax::Leaf>(
298}
299
301 return cast_or_null<syntax::Leaf>(
303}
304
306 return cast_or_null<syntax::Leaf>(
308}
309
311 return cast_or_null<syntax::Expression>(
313}
314
316 return cast_or_null<syntax::Leaf>(
318}
319
321 return cast_or_null<syntax::Statement>(
323}
324
326 return cast_or_null<syntax::Expression>(
328}
329
331 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
332}
333
334std::vector<syntax::Statement *> syntax::CompoundStatement::getStatements() {
335 std::vector<syntax::Statement *> Children;
336 for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
337 assert(C->getRole() == syntax::NodeRole::Statement);
338 Children.push_back(cast<syntax::Statement>(C));
339 }
340 return Children;
341}
342
344 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
345}
346
348 return cast_or_null<syntax::Expression>(
349 findChild(syntax::NodeRole::Condition));
350}
351
353 return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message));
354}
355
356std::vector<syntax::SimpleDeclarator *>
358 std::vector<syntax::SimpleDeclarator *> Children;
359 for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
360 if (C->getRole() == syntax::NodeRole::Declarator)
361 Children.push_back(cast<syntax::SimpleDeclarator>(C));
362 }
363 return Children;
364}
365
367 return cast_or_null<syntax::Leaf>(
369}
370
372 return cast_or_null<syntax::Declaration>(
374}
375
377 return cast_or_null<syntax::Leaf>(
379}
380
382 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
383}
384
386 return cast_or_null<syntax::Declaration>(
388}
389
391 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
392}
393
395 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
396}
397
399 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
400}
401
403 return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Size));
404}
405
407 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
408}
409
411 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
412}
413
415 return cast_or_null<syntax::SimpleDeclarator>(
417}
418
420 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
421}
422
425 return cast_or_null<syntax::ParameterDeclarationList>(
427}
428
430 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
431}
432
435 return cast_or_null<syntax::TrailingReturnType>(
437}
438
439#define NODE(Kind, Parent) \
440 static_assert(sizeof(syntax::Kind) > 0, "Missing Node subclass definition");
441#include "clang/Tooling/Syntax/Nodes.inc"
Expression * getSize()
Definition: Nodes.cpp:402
std::vector< List::ElementAndDelimiter< Expression > > getArgumentsAndCommas()
Definition: Nodes.cpp:142
std::vector< Expression * > getArguments()
Definition: Nodes.cpp:132
Expression * getCaseValue()
Definition: Nodes.cpp:236
std::vector< Statement * > getStatements()
FIXME: use custom iterator instead of 'vector'.
Definition: Nodes.cpp:334
A declaration that can appear at the top-level.
Definition: Nodes.h:354
std::vector< SimpleDeclarator * > getDeclarators()
Definition: Nodes.cpp:177
std::vector< List::ElementAndDelimiter< syntax::SimpleDeclarator > > getDeclaratorsAndCommas()
Definition: Nodes.cpp:187
Statement * getBody()
Definition: Nodes.cpp:280
Statement * getThenStatement()
Definition: Nodes.cpp:261
Statement * getElseStatement()
Definition: Nodes.cpp:270
A leaf node points to a single token.
Definition: Tree.h:132
std::vector< Node * > getElementsAsNodes()
Returns the elements of the list.
Definition: Tree.cpp:357
std::vector< NameSpecifier * > getSpecifiers()
Definition: Nodes.cpp:110
std::vector< List::ElementAndDelimiter< syntax::NameSpecifier > > getSpecifiersAndDoubleColons()
Definition: Nodes.cpp:120
Models a parameter-declaration-list which appears within parameters-and-qualifiers.
Definition: Nodes.h:540
std::vector< List::ElementAndDelimiter< syntax::SimpleDeclaration > > getParametersAndCommas()
Definition: Nodes.cpp:164
std::vector< SimpleDeclaration * > getParameterDeclarations()
Definition: Nodes.cpp:154
ParameterDeclarationList * getParameters()
Definition: Nodes.cpp:424
TrailingReturnType * getTrailingReturn()
Definition: Nodes.cpp:434
Expression * getReturnValue()
Definition: Nodes.cpp:310
std::vector< SimpleDeclarator * > getDeclarators()
FIXME: use custom iterator instead of 'vector'.
Definition: Nodes.cpp:357
A top-level declarator without parentheses.
Definition: Nodes.h:494
An abstract node for C++ statements, e.g.
Definition: Nodes.h:209
Declaration * getDeclaration()
Definition: Nodes.cpp:371
Trailing return type after the parameter list, including the arrow token.
Definition: Nodes.h:527
SimpleDeclarator * getDeclarator()
Definition: Nodes.cpp:414
NodeRole
A relation between a parent and child node, e.g.
Definition: Nodes.h:54
@ CloseParen
A closing parenthesis in argument lists and blocks, e.g. '}', ')', etc.
@ IntroducerKeyword
A keywords that introduces some grammar construct, e.g. 'if', 'try', etc.
@ BodyStatement
An inner statement for those that have only a single child of kind statement, e.g.
@ OpenParen
An opening parenthesis in argument lists and blocks, e.g. '{', '(', etc.
@ ArrowToken
Tokens or Keywords.
NodeKind
A kind of a syntax node, used for implementing casts.
Definition: Nodes.h:32
raw_ostream & operator<<(raw_ostream &OS, NodeKind K)
For debugging purposes.
Definition: Nodes.cpp:13
The JSON file list parser is used to communicate input to InstallAPI.