You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
442 lines
15 KiB
442 lines
15 KiB
//===- Nodes.cpp ----------------------------------------------*- C++ -*-=====//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#include "clang/Tooling/Syntax/Nodes.h"
|
|
#include "clang/Basic/TokenKinds.h"
|
|
|
|
using namespace clang;
|
|
|
|
raw_ostream &syntax::operator<<(raw_ostream &OS, NodeKind K) {
|
|
switch (K) {
|
|
#define CONCRETE_NODE(Kind, Parent) \
|
|
case NodeKind::Kind: \
|
|
return OS << #Kind;
|
|
#include "clang/Tooling/Syntax/Nodes.inc"
|
|
}
|
|
llvm_unreachable("unknown node kind");
|
|
}
|
|
|
|
raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) {
|
|
switch (R) {
|
|
case syntax::NodeRole::Detached:
|
|
return OS << "Detached";
|
|
case syntax::NodeRole::Unknown:
|
|
return OS << "Unknown";
|
|
case syntax::NodeRole::OpenParen:
|
|
return OS << "OpenParen";
|
|
case syntax::NodeRole::CloseParen:
|
|
return OS << "CloseParen";
|
|
case syntax::NodeRole::IntroducerKeyword:
|
|
return OS << "IntroducerKeyword";
|
|
case syntax::NodeRole::LiteralToken:
|
|
return OS << "LiteralToken";
|
|
case syntax::NodeRole::ArrowToken:
|
|
return OS << "ArrowToken";
|
|
case syntax::NodeRole::ExternKeyword:
|
|
return OS << "ExternKeyword";
|
|
case syntax::NodeRole::TemplateKeyword:
|
|
return OS << "TemplateKeyword";
|
|
case syntax::NodeRole::BodyStatement:
|
|
return OS << "BodyStatement";
|
|
case syntax::NodeRole::ListElement:
|
|
return OS << "ListElement";
|
|
case syntax::NodeRole::ListDelimiter:
|
|
return OS << "ListDelimiter";
|
|
case syntax::NodeRole::CaseValue:
|
|
return OS << "CaseValue";
|
|
case syntax::NodeRole::ReturnValue:
|
|
return OS << "ReturnValue";
|
|
case syntax::NodeRole::ThenStatement:
|
|
return OS << "ThenStatement";
|
|
case syntax::NodeRole::ElseKeyword:
|
|
return OS << "ElseKeyword";
|
|
case syntax::NodeRole::ElseStatement:
|
|
return OS << "ElseStatement";
|
|
case syntax::NodeRole::OperatorToken:
|
|
return OS << "OperatorToken";
|
|
case syntax::NodeRole::Operand:
|
|
return OS << "Operand";
|
|
case syntax::NodeRole::LeftHandSide:
|
|
return OS << "LeftHandSide";
|
|
case syntax::NodeRole::RightHandSide:
|
|
return OS << "RightHandSide";
|
|
case syntax::NodeRole::Expression:
|
|
return OS << "Expression";
|
|
case syntax::NodeRole::Statement:
|
|
return OS << "Statement";
|
|
case syntax::NodeRole::Condition:
|
|
return OS << "Condition";
|
|
case syntax::NodeRole::Message:
|
|
return OS << "Message";
|
|
case syntax::NodeRole::Declarator:
|
|
return OS << "Declarator";
|
|
case syntax::NodeRole::Declaration:
|
|
return OS << "Declaration";
|
|
case syntax::NodeRole::Size:
|
|
return OS << "Size";
|
|
case syntax::NodeRole::Parameters:
|
|
return OS << "Parameters";
|
|
case syntax::NodeRole::TrailingReturn:
|
|
return OS << "TrailingReturn";
|
|
case syntax::NodeRole::UnqualifiedId:
|
|
return OS << "UnqualifiedId";
|
|
case syntax::NodeRole::Qualifier:
|
|
return OS << "Qualifier";
|
|
case syntax::NodeRole::SubExpression:
|
|
return OS << "SubExpression";
|
|
case syntax::NodeRole::Object:
|
|
return OS << "Object";
|
|
case syntax::NodeRole::AccessToken:
|
|
return OS << "AccessToken";
|
|
case syntax::NodeRole::Member:
|
|
return OS << "Member";
|
|
case syntax::NodeRole::Callee:
|
|
return OS << "Callee";
|
|
case syntax::NodeRole::Arguments:
|
|
return OS << "Arguments";
|
|
case syntax::NodeRole::Declarators:
|
|
return OS << "Declarators";
|
|
}
|
|
llvm_unreachable("invalid role");
|
|
}
|
|
|
|
// We could have an interator in list to not pay memory costs of temporary
|
|
// vector
|
|
std::vector<syntax::NameSpecifier *>
|
|
syntax::NestedNameSpecifier::getSpecifiers() {
|
|
auto SpecifiersAsNodes = getElementsAsNodes();
|
|
std::vector<syntax::NameSpecifier *> Children;
|
|
for (const auto &Element : SpecifiersAsNodes) {
|
|
Children.push_back(llvm::cast<syntax::NameSpecifier>(Element));
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
|
|
syntax::NestedNameSpecifier::getSpecifiersAndDoubleColons() {
|
|
auto SpecifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();
|
|
std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
|
|
Children;
|
|
for (const auto &SpecifierAndDoubleColon : SpecifiersAsNodesAndDoubleColons) {
|
|
Children.push_back(
|
|
{llvm::cast<syntax::NameSpecifier>(SpecifierAndDoubleColon.element),
|
|
SpecifierAndDoubleColon.delimiter});
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
std::vector<syntax::Expression *> syntax::CallArguments::getArguments() {
|
|
auto ArgumentsAsNodes = getElementsAsNodes();
|
|
std::vector<syntax::Expression *> Children;
|
|
for (const auto &ArgumentAsNode : ArgumentsAsNodes) {
|
|
Children.push_back(llvm::cast<syntax::Expression>(ArgumentAsNode));
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
|
|
syntax::CallArguments::getArgumentsAndCommas() {
|
|
auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
|
|
std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>> Children;
|
|
for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {
|
|
Children.push_back(
|
|
{llvm::cast<syntax::Expression>(ArgumentAsNodeAndComma.element),
|
|
ArgumentAsNodeAndComma.delimiter});
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
std::vector<syntax::SimpleDeclaration *>
|
|
syntax::ParameterDeclarationList::getParameterDeclarations() {
|
|
auto ParametersAsNodes = getElementsAsNodes();
|
|
std::vector<syntax::SimpleDeclaration *> Children;
|
|
for (const auto &ParameterAsNode : ParametersAsNodes) {
|
|
Children.push_back(llvm::cast<syntax::SimpleDeclaration>(ParameterAsNode));
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
|
|
syntax::ParameterDeclarationList::getParametersAndCommas() {
|
|
auto ParametersAsNodesAndCommas = getElementsAsNodesAndDelimiters();
|
|
std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
|
|
Children;
|
|
for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {
|
|
Children.push_back(
|
|
{llvm::cast<syntax::SimpleDeclaration>(ParameterAsNodeAndComma.element),
|
|
ParameterAsNodeAndComma.delimiter});
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
std::vector<syntax::SimpleDeclarator *>
|
|
syntax::DeclaratorList::getDeclarators() {
|
|
auto DeclaratorsAsNodes = getElementsAsNodes();
|
|
std::vector<syntax::SimpleDeclarator *> Children;
|
|
for (const auto &DeclaratorAsNode : DeclaratorsAsNodes) {
|
|
Children.push_back(llvm::cast<syntax::SimpleDeclarator>(DeclaratorAsNode));
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclarator>>
|
|
syntax::DeclaratorList::getDeclaratorsAndCommas() {
|
|
auto DeclaratorsAsNodesAndCommas = getElementsAsNodesAndDelimiters();
|
|
std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclarator>>
|
|
Children;
|
|
for (const auto &DeclaratorAsNodeAndComma : DeclaratorsAsNodesAndCommas) {
|
|
Children.push_back(
|
|
{llvm::cast<syntax::SimpleDeclarator>(DeclaratorAsNodeAndComma.element),
|
|
DeclaratorAsNodeAndComma.delimiter});
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
syntax::Expression *syntax::BinaryOperatorExpression::getLhs() {
|
|
return cast_or_null<syntax::Expression>(
|
|
findChild(syntax::NodeRole::LeftHandSide));
|
|
}
|
|
|
|
syntax::Leaf *syntax::UnaryOperatorExpression::getOperatorToken() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
|
|
}
|
|
|
|
syntax::Expression *syntax::UnaryOperatorExpression::getOperand() {
|
|
return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Operand));
|
|
}
|
|
|
|
syntax::Leaf *syntax::BinaryOperatorExpression::getOperatorToken() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OperatorToken));
|
|
}
|
|
|
|
syntax::Expression *syntax::BinaryOperatorExpression::getRhs() {
|
|
return cast_or_null<syntax::Expression>(
|
|
findChild(syntax::NodeRole::RightHandSide));
|
|
}
|
|
|
|
syntax::Leaf *syntax::SwitchStatement::getSwitchKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Statement *syntax::SwitchStatement::getBody() {
|
|
return cast_or_null<syntax::Statement>(
|
|
findChild(syntax::NodeRole::BodyStatement));
|
|
}
|
|
|
|
syntax::Leaf *syntax::CaseStatement::getCaseKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Expression *syntax::CaseStatement::getCaseValue() {
|
|
return cast_or_null<syntax::Expression>(
|
|
findChild(syntax::NodeRole::CaseValue));
|
|
}
|
|
|
|
syntax::Statement *syntax::CaseStatement::getBody() {
|
|
return cast_or_null<syntax::Statement>(
|
|
findChild(syntax::NodeRole::BodyStatement));
|
|
}
|
|
|
|
syntax::Leaf *syntax::DefaultStatement::getDefaultKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Statement *syntax::DefaultStatement::getBody() {
|
|
return cast_or_null<syntax::Statement>(
|
|
findChild(syntax::NodeRole::BodyStatement));
|
|
}
|
|
|
|
syntax::Leaf *syntax::IfStatement::getIfKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Statement *syntax::IfStatement::getThenStatement() {
|
|
return cast_or_null<syntax::Statement>(
|
|
findChild(syntax::NodeRole::ThenStatement));
|
|
}
|
|
|
|
syntax::Leaf *syntax::IfStatement::getElseKeyword() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ElseKeyword));
|
|
}
|
|
|
|
syntax::Statement *syntax::IfStatement::getElseStatement() {
|
|
return cast_or_null<syntax::Statement>(
|
|
findChild(syntax::NodeRole::ElseStatement));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ForStatement::getForKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Statement *syntax::ForStatement::getBody() {
|
|
return cast_or_null<syntax::Statement>(
|
|
findChild(syntax::NodeRole::BodyStatement));
|
|
}
|
|
|
|
syntax::Leaf *syntax::WhileStatement::getWhileKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Statement *syntax::WhileStatement::getBody() {
|
|
return cast_or_null<syntax::Statement>(
|
|
findChild(syntax::NodeRole::BodyStatement));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ContinueStatement::getContinueKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Leaf *syntax::BreakStatement::getBreakKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ReturnStatement::getReturnKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Expression *syntax::ReturnStatement::getReturnValue() {
|
|
return cast_or_null<syntax::Expression>(
|
|
findChild(syntax::NodeRole::ReturnValue));
|
|
}
|
|
|
|
syntax::Leaf *syntax::RangeBasedForStatement::getForKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Statement *syntax::RangeBasedForStatement::getBody() {
|
|
return cast_or_null<syntax::Statement>(
|
|
findChild(syntax::NodeRole::BodyStatement));
|
|
}
|
|
|
|
syntax::Expression *syntax::ExpressionStatement::getExpression() {
|
|
return cast_or_null<syntax::Expression>(
|
|
findChild(syntax::NodeRole::Expression));
|
|
}
|
|
|
|
syntax::Leaf *syntax::CompoundStatement::getLbrace() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
|
|
}
|
|
|
|
std::vector<syntax::Statement *> syntax::CompoundStatement::getStatements() {
|
|
std::vector<syntax::Statement *> Children;
|
|
for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
|
|
assert(C->getRole() == syntax::NodeRole::Statement);
|
|
Children.push_back(cast<syntax::Statement>(C));
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
syntax::Leaf *syntax::CompoundStatement::getRbrace() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
|
|
}
|
|
|
|
syntax::Expression *syntax::StaticAssertDeclaration::getCondition() {
|
|
return cast_or_null<syntax::Expression>(
|
|
findChild(syntax::NodeRole::Condition));
|
|
}
|
|
|
|
syntax::Expression *syntax::StaticAssertDeclaration::getMessage() {
|
|
return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Message));
|
|
}
|
|
|
|
std::vector<syntax::SimpleDeclarator *>
|
|
syntax::SimpleDeclaration::getDeclarators() {
|
|
std::vector<syntax::SimpleDeclarator *> Children;
|
|
for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {
|
|
if (C->getRole() == syntax::NodeRole::Declarator)
|
|
Children.push_back(cast<syntax::SimpleDeclarator>(C));
|
|
}
|
|
return Children;
|
|
}
|
|
|
|
syntax::Leaf *syntax::TemplateDeclaration::getTemplateKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Declaration *syntax::TemplateDeclaration::getDeclaration() {
|
|
return cast_or_null<syntax::Declaration>(
|
|
findChild(syntax::NodeRole::Declaration));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ExplicitTemplateInstantiation::getTemplateKeyword() {
|
|
return cast_or_null<syntax::Leaf>(
|
|
findChild(syntax::NodeRole::IntroducerKeyword));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ExplicitTemplateInstantiation::getExternKeyword() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ExternKeyword));
|
|
}
|
|
|
|
syntax::Declaration *syntax::ExplicitTemplateInstantiation::getDeclaration() {
|
|
return cast_or_null<syntax::Declaration>(
|
|
findChild(syntax::NodeRole::Declaration));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ParenDeclarator::getLparen() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ParenDeclarator::getRparen() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ArraySubscript::getLbracket() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
|
|
}
|
|
|
|
syntax::Expression *syntax::ArraySubscript::getSize() {
|
|
return cast_or_null<syntax::Expression>(findChild(syntax::NodeRole::Size));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ArraySubscript::getRbracket() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
|
|
}
|
|
|
|
syntax::Leaf *syntax::TrailingReturnType::getArrowToken() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::ArrowToken));
|
|
}
|
|
|
|
syntax::SimpleDeclarator *syntax::TrailingReturnType::getDeclarator() {
|
|
return cast_or_null<syntax::SimpleDeclarator>(
|
|
findChild(syntax::NodeRole::Declarator));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ParametersAndQualifiers::getLparen() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::OpenParen));
|
|
}
|
|
|
|
syntax::ParameterDeclarationList *
|
|
syntax::ParametersAndQualifiers::getParameters() {
|
|
return cast_or_null<syntax::ParameterDeclarationList>(
|
|
findChild(syntax::NodeRole::Parameters));
|
|
}
|
|
|
|
syntax::Leaf *syntax::ParametersAndQualifiers::getRparen() {
|
|
return cast_or_null<syntax::Leaf>(findChild(syntax::NodeRole::CloseParen));
|
|
}
|
|
|
|
syntax::TrailingReturnType *
|
|
syntax::ParametersAndQualifiers::getTrailingReturn() {
|
|
return cast_or_null<syntax::TrailingReturnType>(
|
|
findChild(syntax::NodeRole::TrailingReturn));
|
|
}
|
|
|
|
#define NODE(Kind, Parent) \
|
|
static_assert(sizeof(syntax::Kind) > 0, "Missing Node subclass definition");
|
|
#include "clang/Tooling/Syntax/Nodes.inc"
|