//===- 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;

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

  switch (K) {

  case NodeKind::Leaf:

    return OS << "Leaf";

  case NodeKind::TranslationUnit:

    return OS << "TranslationUnit";

  case NodeKind::UnknownExpression:

    return OS << "UnknownExpression";

  case NodeKind::UnknownStatement:

    return OS << "UnknownStatement";

  case NodeKind::DeclarationStatement:

    return OS << "DeclarationStatement";

  case NodeKind::EmptyStatement:

    return OS << "EmptyStatement";

  case NodeKind::SwitchStatement:

    return OS << "SwitchStatement";

  case NodeKind::CaseStatement:

    return OS << "CaseStatement";

  case NodeKind::DefaultStatement:

    return OS << "DefaultStatement";

  case NodeKind::IfStatement:

    return OS << "IfStatement";

  case NodeKind::ForStatement:

    return OS << "ForStatement";

  case NodeKind::WhileStatement:

    return OS << "WhileStatement";

  case NodeKind::ContinueStatement:

    return OS << "ContinueStatement";

  case NodeKind::BreakStatement:

    return OS << "BreakStatement";

  case NodeKind::ReturnStatement:

    return OS << "ReturnStatement";

  case NodeKind::RangeBasedForStatement:

    return OS << "RangeBasedForStatement";

  case NodeKind::ExpressionStatement:

    return OS << "ExpressionStatement";

  case NodeKind::CompoundStatement:

    return OS << "CompoundStatement";

  case NodeKind::UnknownDeclaration:

    return OS << "UnknownDeclaration";

  case NodeKind::EmptyDeclaration:

    return OS << "EmptyDeclaration";

  case NodeKind::StaticAssertDeclaration:

    return OS << "StaticAssertDeclaration";

  case NodeKind::LinkageSpecificationDeclaration:

    return OS << "LinkageSpecificationDeclaration";

  case NodeKind::SimpleDeclaration:

    return OS << "SimpleDeclaration";

  case NodeKind::NamespaceDefinition:

    return OS << "NamespaceDefinition";

  case NodeKind::NamespaceAliasDefinition:

    return OS << "NamespaceAliasDefinition";

  case NodeKind::UsingNamespaceDirective:

    return OS << "UsingNamespaceDirective";

  case NodeKind::UsingDeclaration:

    return OS << "UsingDeclaration";

  case NodeKind::TypeAliasDeclaration:

    return OS << "TypeAliasDeclaration";

  }

  llvm_unreachable("unknown node kind");

}

llvm::raw_ostream &syntax::operator<<(llvm::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::BodyStatement:

    return OS << "BodyStatement";

  case syntax::NodeRole::CaseStatement_value:

    return OS << "CaseStatement_value";

  case syntax::NodeRole::IfStatement_thenStatement:

    return OS << "IfStatement_thenStatement";

  case syntax::NodeRole::IfStatement_elseKeyword:

    return OS << "IfStatement_elseKeyword";

  case syntax::NodeRole::IfStatement_elseStatement:

    return OS << "IfStatement_elseStatement";

  case syntax::NodeRole::ReturnStatement_value:

    return OS << "ReturnStatement_value";

  case syntax::NodeRole::ExpressionStatement_expression:

    return OS << "ExpressionStatement_expression";

  case syntax::NodeRole::CompoundStatement_statement:

    return OS << "CompoundStatement_statement";

  case syntax::NodeRole::StaticAssertDeclaration_condition:

    return OS << "StaticAssertDeclaration_condition";

  case syntax::NodeRole::StaticAssertDeclaration_message:

    return OS << "StaticAssertDeclaration_message";

  }

  llvm_unreachable("invalid role");

}

syntax::Leaf *syntax::SwitchStatement::switchKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Statement *syntax::SwitchStatement::body() {

  return llvm::cast_or_null<syntax::Statement>(

      findChild(syntax::NodeRole::BodyStatement));

}

syntax::Leaf *syntax::CaseStatement::caseKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Expression *syntax::CaseStatement::value() {

  return llvm::cast_or_null<syntax::Expression>(

      findChild(syntax::NodeRole::CaseStatement_value));

}

syntax::Statement *syntax::CaseStatement::body() {

  return llvm::cast_or_null<syntax::Statement>(

      findChild(syntax::NodeRole::BodyStatement));

}

syntax::Leaf *syntax::DefaultStatement::defaultKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Statement *syntax::DefaultStatement::body() {

  return llvm::cast_or_null<syntax::Statement>(

      findChild(syntax::NodeRole::BodyStatement));

}

syntax::Leaf *syntax::IfStatement::ifKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Statement *syntax::IfStatement::thenStatement() {

  return llvm::cast_or_null<syntax::Statement>(

      findChild(syntax::NodeRole::IfStatement_thenStatement));

}

syntax::Leaf *syntax::IfStatement::elseKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IfStatement_elseKeyword));

}

syntax::Statement *syntax::IfStatement::elseStatement() {

  return llvm::cast_or_null<syntax::Statement>(

      findChild(syntax::NodeRole::IfStatement_elseStatement));

}

syntax::Leaf *syntax::ForStatement::forKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Statement *syntax::ForStatement::body() {

  return llvm::cast_or_null<syntax::Statement>(

      findChild(syntax::NodeRole::BodyStatement));

}

syntax::Leaf *syntax::WhileStatement::whileKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Statement *syntax::WhileStatement::body() {

  return llvm::cast_or_null<syntax::Statement>(

      findChild(syntax::NodeRole::BodyStatement));

}

syntax::Leaf *syntax::ContinueStatement::continueKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Leaf *syntax::BreakStatement::breakKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Leaf *syntax::ReturnStatement::returnKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Expression *syntax::ReturnStatement::value() {

  return llvm::cast_or_null<syntax::Expression>(

      findChild(syntax::NodeRole::ReturnStatement_value));

}

syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::IntroducerKeyword));

}

syntax::Statement *syntax::RangeBasedForStatement::body() {

  return llvm::cast_or_null<syntax::Statement>(

      findChild(syntax::NodeRole::BodyStatement));

}

syntax::Expression *syntax::ExpressionStatement::expression() {

  return llvm::cast_or_null<syntax::Expression>(

      findChild(syntax::NodeRole::ExpressionStatement_expression));

}

syntax::Leaf *syntax::CompoundStatement::lbrace() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::OpenParen));

}

std::vector<syntax::Statement *> syntax::CompoundStatement::statements() {

  std::vector<syntax::Statement *> Children;

  for (auto *C = firstChild(); C; C = C->nextSibling()) {

    if (C->role() == syntax::NodeRole::CompoundStatement_statement)

      Children.push_back(llvm::cast<syntax::Statement>(C));

  }

  return Children;

}

syntax::Leaf *syntax::CompoundStatement::rbrace() {

  return llvm::cast_or_null<syntax::Leaf>(

      findChild(syntax::NodeRole::CloseParen));

}

syntax::Expression *syntax::StaticAssertDeclaration::condition() {

  return llvm::cast_or_null<syntax::Expression>(

      findChild(syntax::NodeRole::StaticAssertDeclaration_condition));

}

syntax::Expression *syntax::StaticAssertDeclaration::message() {

  return llvm::cast_or_null<syntax::Expression>(

      findChild(syntax::NodeRole::StaticAssertDeclaration_message));

}