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 #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 23 raw_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 109 std::vector<syntax::NameSpecifier *> 110 syntax::NestedNameSpecifier::getSpecifiers() { 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 119 std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>> 120 syntax::NestedNameSpecifier::getSpecifiersAndDoubleColons() { 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 132 std::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 141 std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> 142 syntax::CallArguments::getArgumentsAndCommas() { 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 153 std::vector<syntax::SimpleDeclaration *> 154 syntax::ParameterDeclarationList::getParameterDeclarations() { 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 163 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>> 164 syntax::ParameterDeclarationList::getParametersAndCommas() { 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 176 std::vector<syntax::SimpleDeclarator *> 177 syntax::DeclaratorList::getDeclarators() { 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 186 std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclarator>> 187 syntax::DeclaratorList::getDeclaratorsAndCommas() { 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 199 syntax::Expression *syntax::BinaryOperatorExpression::getLhs() { 200 return cast_or_null<syntax::Expression>( 201 findChild(syntax::NodeRole::LeftHandSide)); 202 } 203 204 syntax::Leaf *syntax::UnaryOperatorExpression::getOperatorToken() { 205 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken)); 206 } 207 208 syntax::Expression *syntax::UnaryOperatorExpression::getOperand() { 209 return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Operand)); 210 } 211 212 syntax::Leaf *syntax::BinaryOperatorExpression::getOperatorToken() { 213 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken)); 214 } 215 216 syntax::Expression *syntax::BinaryOperatorExpression::getRhs() { 217 return cast_or_null<syntax::Expression>( 218 findChild(syntax::NodeRole::RightHandSide)); 219 } 220 221 syntax::Leaf *syntax::SwitchStatement::getSwitchKeyword() { 222 return cast_or_null<syntax::Leaf>( 223 findChild(syntax::NodeRole::IntroducerKeyword)); 224 } 225 226 syntax::Statement *syntax::SwitchStatement::getBody() { 227 return cast_or_null<syntax::Statement>( 228 findChild(syntax::NodeRole::BodyStatement)); 229 } 230 231 syntax::Leaf *syntax::CaseStatement::getCaseKeyword() { 232 return cast_or_null<syntax::Leaf>( 233 findChild(syntax::NodeRole::IntroducerKeyword)); 234 } 235 236 syntax::Expression *syntax::CaseStatement::getCaseValue() { 237 return cast_or_null<syntax::Expression>( 238 findChild(syntax::NodeRole::CaseValue)); 239 } 240 241 syntax::Statement *syntax::CaseStatement::getBody() { 242 return cast_or_null<syntax::Statement>( 243 findChild(syntax::NodeRole::BodyStatement)); 244 } 245 246 syntax::Leaf *syntax::DefaultStatement::getDefaultKeyword() { 247 return cast_or_null<syntax::Leaf>( 248 findChild(syntax::NodeRole::IntroducerKeyword)); 249 } 250 251 syntax::Statement *syntax::DefaultStatement::getBody() { 252 return cast_or_null<syntax::Statement>( 253 findChild(syntax::NodeRole::BodyStatement)); 254 } 255 256 syntax::Leaf *syntax::IfStatement::getIfKeyword() { 257 return cast_or_null<syntax::Leaf>( 258 findChild(syntax::NodeRole::IntroducerKeyword)); 259 } 260 261 syntax::Statement *syntax::IfStatement::getThenStatement() { 262 return cast_or_null<syntax::Statement>( 263 findChild(syntax::NodeRole::ThenStatement)); 264 } 265 266 syntax::Leaf *syntax::IfStatement::getElseKeyword() { 267 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ElseKeyword)); 268 } 269 270 syntax::Statement *syntax::IfStatement::getElseStatement() { 271 return cast_or_null<syntax::Statement>( 272 findChild(syntax::NodeRole::ElseStatement)); 273 } 274 275 syntax::Leaf *syntax::ForStatement::getForKeyword() { 276 return cast_or_null<syntax::Leaf>( 277 findChild(syntax::NodeRole::IntroducerKeyword)); 278 } 279 280 syntax::Statement *syntax::ForStatement::getBody() { 281 return cast_or_null<syntax::Statement>( 282 findChild(syntax::NodeRole::BodyStatement)); 283 } 284 285 syntax::Leaf *syntax::WhileStatement::getWhileKeyword() { 286 return cast_or_null<syntax::Leaf>( 287 findChild(syntax::NodeRole::IntroducerKeyword)); 288 } 289 290 syntax::Statement *syntax::WhileStatement::getBody() { 291 return cast_or_null<syntax::Statement>( 292 findChild(syntax::NodeRole::BodyStatement)); 293 } 294 295 syntax::Leaf *syntax::ContinueStatement::getContinueKeyword() { 296 return cast_or_null<syntax::Leaf>( 297 findChild(syntax::NodeRole::IntroducerKeyword)); 298 } 299 300 syntax::Leaf *syntax::BreakStatement::getBreakKeyword() { 301 return cast_or_null<syntax::Leaf>( 302 findChild(syntax::NodeRole::IntroducerKeyword)); 303 } 304 305 syntax::Leaf *syntax::ReturnStatement::getReturnKeyword() { 306 return cast_or_null<syntax::Leaf>( 307 findChild(syntax::NodeRole::IntroducerKeyword)); 308 } 309 310 syntax::Expression *syntax::ReturnStatement::getReturnValue() { 311 return cast_or_null<syntax::Expression>( 312 findChild(syntax::NodeRole::ReturnValue)); 313 } 314 315 syntax::Leaf *syntax::RangeBasedForStatement::getForKeyword() { 316 return cast_or_null<syntax::Leaf>( 317 findChild(syntax::NodeRole::IntroducerKeyword)); 318 } 319 320 syntax::Statement *syntax::RangeBasedForStatement::getBody() { 321 return cast_or_null<syntax::Statement>( 322 findChild(syntax::NodeRole::BodyStatement)); 323 } 324 325 syntax::Expression *syntax::ExpressionStatement::getExpression() { 326 return cast_or_null<syntax::Expression>( 327 findChild(syntax::NodeRole::Expression)); 328 } 329 330 syntax::Leaf *syntax::CompoundStatement::getLbrace() { 331 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen)); 332 } 333 334 std::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 343 syntax::Leaf *syntax::CompoundStatement::getRbrace() { 344 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen)); 345 } 346 347 syntax::Expression *syntax::StaticAssertDeclaration::getCondition() { 348 return cast_or_null<syntax::Expression>( 349 findChild(syntax::NodeRole::Condition)); 350 } 351 352 syntax::Expression *syntax::StaticAssertDeclaration::getMessage() { 353 return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message)); 354 } 355 356 std::vector<syntax::SimpleDeclarator *> 357 syntax::SimpleDeclaration::getDeclarators() { 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 366 syntax::Leaf *syntax::TemplateDeclaration::getTemplateKeyword() { 367 return cast_or_null<syntax::Leaf>( 368 findChild(syntax::NodeRole::IntroducerKeyword)); 369 } 370 371 syntax::Declaration *syntax::TemplateDeclaration::getDeclaration() { 372 return cast_or_null<syntax::Declaration>( 373 findChild(syntax::NodeRole::Declaration)); 374 } 375 376 syntax::Leaf *syntax::ExplicitTemplateInstantiation::getTemplateKeyword() { 377 return cast_or_null<syntax::Leaf>( 378 findChild(syntax::NodeRole::IntroducerKeyword)); 379 } 380 381 syntax::Leaf *syntax::ExplicitTemplateInstantiation::getExternKeyword() { 382 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword)); 383 } 384 385 syntax::Declaration *syntax::ExplicitTemplateInstantiation::getDeclaration() { 386 return cast_or_null<syntax::Declaration>( 387 findChild(syntax::NodeRole::Declaration)); 388 } 389 390 syntax::Leaf *syntax::ParenDeclarator::getLparen() { 391 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen)); 392 } 393 394 syntax::Leaf *syntax::ParenDeclarator::getRparen() { 395 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen)); 396 } 397 398 syntax::Leaf *syntax::ArraySubscript::getLbracket() { 399 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen)); 400 } 401 402 syntax::Expression *syntax::ArraySubscript::getSize() { 403 return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Size)); 404 } 405 406 syntax::Leaf *syntax::ArraySubscript::getRbracket() { 407 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen)); 408 } 409 410 syntax::Leaf *syntax::TrailingReturnType::getArrowToken() { 411 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken)); 412 } 413 414 syntax::SimpleDeclarator *syntax::TrailingReturnType::getDeclarator() { 415 return cast_or_null<syntax::SimpleDeclarator>( 416 findChild(syntax::NodeRole::Declarator)); 417 } 418 419 syntax::Leaf *syntax::ParametersAndQualifiers::getLparen() { 420 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen)); 421 } 422 423 syntax::ParameterDeclarationList * 424 syntax::ParametersAndQualifiers::getParameters() { 425 return cast_or_null<syntax::ParameterDeclarationList>( 426 findChild(syntax::NodeRole::Parameters)); 427 } 428 429 syntax::Leaf *syntax::ParametersAndQualifiers::getRparen() { 430 return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen)); 431 } 432 433 syntax::TrailingReturnType * 434 syntax::ParametersAndQualifiers::getTrailingReturn() { 435 return cast_or_null<syntax::TrailingReturnType>( 436 findChild(syntax::NodeRole::TrailingReturn)); 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" 442