llvm/clang/lib/Tooling/Syntax/Nodes.cpp

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

usingnamespaceclang;

raw_ostream &syntax::operator<<(raw_ostream &OS, NodeKind K) { … }

raw_ostream &syntax::operator<<(raw_ostream &OS, NodeRole R) { … }

// We could have an interator in list to not pay memory costs of temporary
// vector
std::vector<syntax::NameSpecifier *>
syntax::NestedNameSpecifier::getSpecifiers() { … }

std::vector<syntax::List::ElementAndDelimiter<syntax::NameSpecifier>>
syntax::NestedNameSpecifier::getSpecifiersAndDoubleColons() { … }

std::vector<syntax::Expression *> syntax::CallArguments::getArguments() { … }

std::vector<syntax::List::ElementAndDelimiter<syntax::Expression>>
syntax::CallArguments::getArgumentsAndCommas() { … }

std::vector<syntax::SimpleDeclaration *>
syntax::ParameterDeclarationList::getParameterDeclarations() { … }

std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclaration>>
syntax::ParameterDeclarationList::getParametersAndCommas() { … }

std::vector<syntax::SimpleDeclarator *>
syntax::DeclaratorList::getDeclarators() { … }

std::vector<syntax::List::ElementAndDelimiter<syntax::SimpleDeclarator>>
syntax::DeclaratorList::getDeclaratorsAndCommas() { … }

syntax::Expression *syntax::BinaryOperatorExpression::getLhs() { … }

syntax::Leaf *syntax::UnaryOperatorExpression::getOperatorToken() { … }

syntax::Expression *syntax::UnaryOperatorExpression::getOperand() { … }

syntax::Leaf *syntax::BinaryOperatorExpression::getOperatorToken() { … }

syntax::Expression *syntax::BinaryOperatorExpression::getRhs() { … }

syntax::Leaf *syntax::SwitchStatement::getSwitchKeyword() { … }

syntax::Statement *syntax::SwitchStatement::getBody() { … }

syntax::Leaf *syntax::CaseStatement::getCaseKeyword() { … }

syntax::Expression *syntax::CaseStatement::getCaseValue() { … }

syntax::Statement *syntax::CaseStatement::getBody() { … }

syntax::Leaf *syntax::DefaultStatement::getDefaultKeyword() { … }

syntax::Statement *syntax::DefaultStatement::getBody() { … }

syntax::Leaf *syntax::IfStatement::getIfKeyword() { … }

syntax::Statement *syntax::IfStatement::getThenStatement() { … }

syntax::Leaf *syntax::IfStatement::getElseKeyword() { … }

syntax::Statement *syntax::IfStatement::getElseStatement() { … }

syntax::Leaf *syntax::ForStatement::getForKeyword() { … }

syntax::Statement *syntax::ForStatement::getBody() { … }

syntax::Leaf *syntax::WhileStatement::getWhileKeyword() { … }

syntax::Statement *syntax::WhileStatement::getBody() { … }

syntax::Leaf *syntax::ContinueStatement::getContinueKeyword() { … }

syntax::Leaf *syntax::BreakStatement::getBreakKeyword() { … }

syntax::Leaf *syntax::ReturnStatement::getReturnKeyword() { … }

syntax::Expression *syntax::ReturnStatement::getReturnValue() { … }

syntax::Leaf *syntax::RangeBasedForStatement::getForKeyword() { … }

syntax::Statement *syntax::RangeBasedForStatement::getBody() { … }

syntax::Expression *syntax::ExpressionStatement::getExpression() { … }

syntax::Leaf *syntax::CompoundStatement::getLbrace() { … }

std::vector<syntax::Statement *> syntax::CompoundStatement::getStatements() { … }

syntax::Leaf *syntax::CompoundStatement::getRbrace() { … }

syntax::Expression *syntax::StaticAssertDeclaration::getCondition() { … }

syntax::Expression *syntax::StaticAssertDeclaration::getMessage() { … }

std::vector<syntax::SimpleDeclarator *>
syntax::SimpleDeclaration::getDeclarators() { … }

syntax::Leaf *syntax::TemplateDeclaration::getTemplateKeyword() { … }

syntax::Declaration *syntax::TemplateDeclaration::getDeclaration() { … }

syntax::Leaf *syntax::ExplicitTemplateInstantiation::getTemplateKeyword() { … }

syntax::Leaf *syntax::ExplicitTemplateInstantiation::getExternKeyword() { … }

syntax::Declaration *syntax::ExplicitTemplateInstantiation::getDeclaration() { … }

syntax::Leaf *syntax::ParenDeclarator::getLparen() { … }

syntax::Leaf *syntax::ParenDeclarator::getRparen() { … }

syntax::Leaf *syntax::ArraySubscript::getLbracket() { … }

syntax::Expression *syntax::ArraySubscript::getSize() { … }

syntax::Leaf *syntax::ArraySubscript::getRbracket() { … }

syntax::Leaf *syntax::TrailingReturnType::getArrowToken() { … }

syntax::SimpleDeclarator *syntax::TrailingReturnType::getDeclarator() { … }

syntax::Leaf *syntax::ParametersAndQualifiers::getLparen() { … }

syntax::ParameterDeclarationList *
syntax::ParametersAndQualifiers::getParameters() { … }

syntax::Leaf *syntax::ParametersAndQualifiers::getRparen() { … }

syntax::TrailingReturnType *
syntax::ParametersAndQualifiers::getTrailingReturn() { … }

#define NODE …
#include "clang/Tooling/Syntax/Nodes.inc"