clang/lib/Tooling/Syntax/Nodes.cpp

   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 "llvm/Support/raw_ostream.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"