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
11using namespace clang;
12
13llvm::raw_ostream &syntax::operator<<(llvm::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::UnknownStatement:
22    return OS << "UnknownStatement";
23  case NodeKind::DeclarationStatement:
24    return OS << "DeclarationStatement";
25  case NodeKind::EmptyStatement:
26    return OS << "EmptyStatement";
27  case NodeKind::SwitchStatement:
28    return OS << "SwitchStatement";
29  case NodeKind::CaseStatement:
30    return OS << "CaseStatement";
31  case NodeKind::DefaultStatement:
32    return OS << "DefaultStatement";
33  case NodeKind::IfStatement:
34    return OS << "IfStatement";
35  case NodeKind::ForStatement:
36    return OS << "ForStatement";
37  case NodeKind::WhileStatement:
38    return OS << "WhileStatement";
39  case NodeKind::ContinueStatement:
40    return OS << "ContinueStatement";
41  case NodeKind::BreakStatement:
42    return OS << "BreakStatement";
43  case NodeKind::ReturnStatement:
44    return OS << "ReturnStatement";
45  case NodeKind::RangeBasedForStatement:
46    return OS << "RangeBasedForStatement";
47  case NodeKind::ExpressionStatement:
48    return OS << "ExpressionStatement";
49  case NodeKind::CompoundStatement:
50    return OS << "CompoundStatement";
51  case NodeKind::UnknownDeclaration:
52    return OS << "UnknownDeclaration";
53  case NodeKind::EmptyDeclaration:
54    return OS << "EmptyDeclaration";
55  case NodeKind::StaticAssertDeclaration:
56    return OS << "StaticAssertDeclaration";
57  case NodeKind::LinkageSpecificationDeclaration:
58    return OS << "LinkageSpecificationDeclaration";
59  case NodeKind::SimpleDeclaration:
60    return OS << "SimpleDeclaration";
61  case NodeKind::NamespaceDefinition:
62    return OS << "NamespaceDefinition";
63  case NodeKind::NamespaceAliasDefinition:
64    return OS << "NamespaceAliasDefinition";
65  case NodeKind::UsingNamespaceDirective:
66    return OS << "UsingNamespaceDirective";
67  case NodeKind::UsingDeclaration:
68    return OS << "UsingDeclaration";
69  case NodeKind::TypeAliasDeclaration:
70    return OS << "TypeAliasDeclaration";
71  }
72  llvm_unreachable("unknown node kind");
73}
74
75llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeRole R) {
76  switch (R) {
77  case syntax::NodeRole::Detached:
78    return OS << "Detached";
79  case syntax::NodeRole::Unknown:
80    return OS << "Unknown";
81  case syntax::NodeRole::OpenParen:
82    return OS << "OpenParen";
83  case syntax::NodeRole::CloseParen:
84    return OS << "CloseParen";
85  case syntax::NodeRole::IntroducerKeyword:
86    return OS << "IntroducerKeyword";
87  case syntax::NodeRole::BodyStatement:
88    return OS << "BodyStatement";
89  case syntax::NodeRole::CaseStatement_value:
90    return OS << "CaseStatement_value";
91  case syntax::NodeRole::IfStatement_thenStatement:
92    return OS << "IfStatement_thenStatement";
93  case syntax::NodeRole::IfStatement_elseKeyword:
94    return OS << "IfStatement_elseKeyword";
95  case syntax::NodeRole::IfStatement_elseStatement:
96    return OS << "IfStatement_elseStatement";
97  case syntax::NodeRole::ReturnStatement_value:
98    return OS << "ReturnStatement_value";
99  case syntax::NodeRole::ExpressionStatement_expression:
100    return OS << "ExpressionStatement_expression";
101  case syntax::NodeRole::CompoundStatement_statement:
102    return OS << "CompoundStatement_statement";
103  case syntax::NodeRole::StaticAssertDeclaration_condition:
104    return OS << "StaticAssertDeclaration_condition";
105  case syntax::NodeRole::StaticAssertDeclaration_message:
106    return OS << "StaticAssertDeclaration_message";
107  }
108  llvm_unreachable("invalid role");
109}
110
111syntax::Leaf *syntax::SwitchStatement::switchKeyword() {
112  return llvm::cast_or_null<syntax::Leaf>(
113      findChild(syntax::NodeRole::IntroducerKeyword));
114}
115
116syntax::Statement *syntax::SwitchStatement::body() {
117  return llvm::cast_or_null<syntax::Statement>(
118      findChild(syntax::NodeRole::BodyStatement));
119}
120
121syntax::Leaf *syntax::CaseStatement::caseKeyword() {
122  return llvm::cast_or_null<syntax::Leaf>(
123      findChild(syntax::NodeRole::IntroducerKeyword));
124}
125
126syntax::Expression *syntax::CaseStatement::value() {
127  return llvm::cast_or_null<syntax::Expression>(
128      findChild(syntax::NodeRole::CaseStatement_value));
129}
130
131syntax::Statement *syntax::CaseStatement::body() {
132  return llvm::cast_or_null<syntax::Statement>(
133      findChild(syntax::NodeRole::BodyStatement));
134}
135
136syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {
137  return llvm::cast_or_null<syntax::Leaf>(
138      findChild(syntax::NodeRole::IntroducerKeyword));
139}
140
141syntax::Statement *syntax::DefaultStatement::body() {
142  return llvm::cast_or_null<syntax::Statement>(
143      findChild(syntax::NodeRole::BodyStatement));
144}
145
146syntax::Leaf *syntax::IfStatement::ifKeyword() {
147  return llvm::cast_or_null<syntax::Leaf>(
148      findChild(syntax::NodeRole::IntroducerKeyword));
149}
150
151syntax::Statement *syntax::IfStatement::thenStatement() {
152  return llvm::cast_or_null<syntax::Statement>(
153      findChild(syntax::NodeRole::IfStatement_thenStatement));
154}
155
156syntax::Leaf *syntax::IfStatement::elseKeyword() {
157  return llvm::cast_or_null<syntax::Leaf>(
158      findChild(syntax::NodeRole::IfStatement_elseKeyword));
159}
160
161syntax::Statement *syntax::IfStatement::elseStatement() {
162  return llvm::cast_or_null<syntax::Statement>(
163      findChild(syntax::NodeRole::IfStatement_elseStatement));
164}
165
166syntax::Leaf *syntax::ForStatement::forKeyword() {
167  return llvm::cast_or_null<syntax::Leaf>(
168      findChild(syntax::NodeRole::IntroducerKeyword));
169}
170
171syntax::Statement *syntax::ForStatement::body() {
172  return llvm::cast_or_null<syntax::Statement>(
173      findChild(syntax::NodeRole::BodyStatement));
174}
175
176syntax::Leaf *syntax::WhileStatement::whileKeyword() {
177  return llvm::cast_or_null<syntax::Leaf>(
178      findChild(syntax::NodeRole::IntroducerKeyword));
179}
180
181syntax::Statement *syntax::WhileStatement::body() {
182  return llvm::cast_or_null<syntax::Statement>(
183      findChild(syntax::NodeRole::BodyStatement));
184}
185
186syntax::Leaf *syntax::ContinueStatement::continueKeyword() {
187  return llvm::cast_or_null<syntax::Leaf>(
188      findChild(syntax::NodeRole::IntroducerKeyword));
189}
190
191syntax::Leaf *syntax::BreakStatement::breakKeyword() {
192  return llvm::cast_or_null<syntax::Leaf>(
193      findChild(syntax::NodeRole::IntroducerKeyword));
194}
195
196syntax::Leaf *syntax::ReturnStatement::returnKeyword() {
197  return llvm::cast_or_null<syntax::Leaf>(
198      findChild(syntax::NodeRole::IntroducerKeyword));
199}
200
201syntax::Expression *syntax::ReturnStatement::value() {
202  return llvm::cast_or_null<syntax::Expression>(
203      findChild(syntax::NodeRole::ReturnStatement_value));
204}
205
206syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {
207  return llvm::cast_or_null<syntax::Leaf>(
208      findChild(syntax::NodeRole::IntroducerKeyword));
209}
210
211syntax::Statement *syntax::RangeBasedForStatement::body() {
212  return llvm::cast_or_null<syntax::Statement>(
213      findChild(syntax::NodeRole::BodyStatement));
214}
215
216syntax::Expression *syntax::ExpressionStatement::expression() {
217  return llvm::cast_or_null<syntax::Expression>(
218      findChild(syntax::NodeRole::ExpressionStatement_expression));
219}
220
221syntax::Leaf *syntax::CompoundStatement::lbrace() {
222  return llvm::cast_or_null<syntax::Leaf>(
223      findChild(syntax::NodeRole::OpenParen));
224}
225
226std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {
227  std::vector<syntax::Statement *> Children;
228  for (auto *C = firstChild(); C; C = C->nextSibling()) {
229    if (C->role() == syntax::NodeRole::CompoundStatement_statement)
230      Children.push_back(llvm::cast<syntax::Statement>(C));
231  }
232  return Children;
233}
234
235syntax::Leaf *syntax::CompoundStatement::rbrace() {
236  return llvm::cast_or_null<syntax::Leaf>(
237      findChild(syntax::NodeRole::CloseParen));
238}
239
240syntax::Expression *syntax::StaticAssertDeclaration::condition() {
241  return llvm::cast_or_null<syntax::Expression>(
242      findChild(syntax::NodeRole::StaticAssertDeclaration_condition));
243}
244
245syntax::Expression *syntax::StaticAssertDeclaration::message() {
246  return llvm::cast_or_null<syntax::Expression>(
247      findChild(syntax::NodeRole::StaticAssertDeclaration_message));
248}
249