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 llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeKind K) { 14 switch (K) { 15 case NodeKind::Leaf: 16 return OS << "Leaf"; 17 case NodeKind::TranslationUnit: 18 return OS << "TranslationUnit"; 19 case NodeKind::UnknownExpression: 20 return OS << "UnknownExpression"; 21 case NodeKind::UnknownStatement: 22 return OS << "UnknownStatement"; 23 case NodeKind::DeclarationStatement: 24 return OS << "DeclarationStatement"; 25 case NodeKind::EmptyStatement: 26 return OS << "EmptyStatement"; 27 case NodeKind::SwitchStatement: 28 return OS << "SwitchStatement"; 29 case NodeKind::CaseStatement: 30 return OS << "CaseStatement"; 31 case NodeKind::DefaultStatement: 32 return OS << "DefaultStatement"; 33 case NodeKind::IfStatement: 34 return OS << "IfStatement"; 35 case NodeKind::ForStatement: 36 return OS << "ForStatement"; 37 case NodeKind::WhileStatement: 38 return OS << "WhileStatement"; 39 case NodeKind::ContinueStatement: 40 return OS << "ContinueStatement"; 41 case NodeKind::BreakStatement: 42 return OS << "BreakStatement"; 43 case NodeKind::ReturnStatement: 44 return OS << "ReturnStatement"; 45 case NodeKind::RangeBasedForStatement: 46 return OS << "RangeBasedForStatement"; 47 case NodeKind::ExpressionStatement: 48 return OS << "ExpressionStatement"; 49 case NodeKind::CompoundStatement: 50 return OS << "CompoundStatement"; 51 case NodeKind::UnknownDeclaration: 52 return OS << "UnknownDeclaration"; 53 case NodeKind::SimpleDeclaration: 54 return OS << "SimpleDeclaration"; 55 } 56 llvm_unreachable("unknown node kind"); 57 } 58 59 llvm::raw_ostream &syntax::operator<<(llvm::raw_ostream &OS, NodeRole R) { 60 switch (R) { 61 case syntax::NodeRole::Detached: 62 return OS << "Detached"; 63 case syntax::NodeRole::Unknown: 64 return OS << "Unknown"; 65 case syntax::NodeRole::OpenParen: 66 return OS << "OpenParen"; 67 case syntax::NodeRole::CloseParen: 68 return OS << "CloseParen"; 69 case syntax::NodeRole::IntroducerKeyword: 70 return OS << "IntroducerKeyword"; 71 case syntax::NodeRole::BodyStatement: 72 return OS << "BodyStatement"; 73 case syntax::NodeRole::CaseStatement_value: 74 return OS << "CaseStatement_value"; 75 case syntax::NodeRole::IfStatement_thenStatement: 76 return OS << "IfStatement_thenStatement"; 77 case syntax::NodeRole::IfStatement_elseKeyword: 78 return OS << "IfStatement_elseKeyword"; 79 case syntax::NodeRole::IfStatement_elseStatement: 80 return OS << "IfStatement_elseStatement"; 81 case syntax::NodeRole::ReturnStatement_value: 82 return OS << "ReturnStatement_value"; 83 case syntax::NodeRole::ExpressionStatement_expression: 84 return OS << "ExpressionStatement_expression"; 85 case syntax::NodeRole::CompoundStatement_statement: 86 return OS << "CompoundStatement_statement"; 87 } 88 llvm_unreachable("invalid role"); 89 } 90 91 syntax::Leaf *syntax::SwitchStatement::switchKeyword() { 92 return llvm::cast_or_null<syntax::Leaf>( 93 findChild(syntax::NodeRole::IntroducerKeyword)); 94 } 95 96 syntax::Statement *syntax::SwitchStatement::body() { 97 return llvm::cast_or_null<syntax::Statement>( 98 findChild(syntax::NodeRole::BodyStatement)); 99 } 100 101 syntax::Leaf *syntax::CaseStatement::caseKeyword() { 102 return llvm::cast_or_null<syntax::Leaf>( 103 findChild(syntax::NodeRole::IntroducerKeyword)); 104 } 105 106 syntax::Expression *syntax::CaseStatement::value() { 107 return llvm::cast_or_null<syntax::Expression>( 108 findChild(syntax::NodeRole::CaseStatement_value)); 109 } 110 111 syntax::Statement *syntax::CaseStatement::body() { 112 return llvm::cast_or_null<syntax::Statement>( 113 findChild(syntax::NodeRole::BodyStatement)); 114 } 115 116 syntax::Leaf *syntax::DefaultStatement::defaultKeyword() { 117 return llvm::cast_or_null<syntax::Leaf>( 118 findChild(syntax::NodeRole::IntroducerKeyword)); 119 } 120 121 syntax::Statement *syntax::DefaultStatement::body() { 122 return llvm::cast_or_null<syntax::Statement>( 123 findChild(syntax::NodeRole::BodyStatement)); 124 } 125 126 syntax::Leaf *syntax::IfStatement::ifKeyword() { 127 return llvm::cast_or_null<syntax::Leaf>( 128 findChild(syntax::NodeRole::IntroducerKeyword)); 129 } 130 131 syntax::Statement *syntax::IfStatement::thenStatement() { 132 return llvm::cast_or_null<syntax::Statement>( 133 findChild(syntax::NodeRole::IfStatement_thenStatement)); 134 } 135 136 syntax::Leaf *syntax::IfStatement::elseKeyword() { 137 return llvm::cast_or_null<syntax::Leaf>( 138 findChild(syntax::NodeRole::IfStatement_elseKeyword)); 139 } 140 141 syntax::Statement *syntax::IfStatement::elseStatement() { 142 return llvm::cast_or_null<syntax::Statement>( 143 findChild(syntax::NodeRole::IfStatement_elseStatement)); 144 } 145 146 syntax::Leaf *syntax::ForStatement::forKeyword() { 147 return llvm::cast_or_null<syntax::Leaf>( 148 findChild(syntax::NodeRole::IntroducerKeyword)); 149 } 150 151 syntax::Statement *syntax::ForStatement::body() { 152 return llvm::cast_or_null<syntax::Statement>( 153 findChild(syntax::NodeRole::BodyStatement)); 154 } 155 156 syntax::Leaf *syntax::WhileStatement::whileKeyword() { 157 return llvm::cast_or_null<syntax::Leaf>( 158 findChild(syntax::NodeRole::IntroducerKeyword)); 159 } 160 161 syntax::Statement *syntax::WhileStatement::body() { 162 return llvm::cast_or_null<syntax::Statement>( 163 findChild(syntax::NodeRole::BodyStatement)); 164 } 165 166 syntax::Leaf *syntax::ContinueStatement::continueKeyword() { 167 return llvm::cast_or_null<syntax::Leaf>( 168 findChild(syntax::NodeRole::IntroducerKeyword)); 169 } 170 171 syntax::Leaf *syntax::BreakStatement::breakKeyword() { 172 return llvm::cast_or_null<syntax::Leaf>( 173 findChild(syntax::NodeRole::IntroducerKeyword)); 174 } 175 176 syntax::Leaf *syntax::ReturnStatement::returnKeyword() { 177 return llvm::cast_or_null<syntax::Leaf>( 178 findChild(syntax::NodeRole::IntroducerKeyword)); 179 } 180 181 syntax::Expression *syntax::ReturnStatement::value() { 182 return llvm::cast_or_null<syntax::Expression>( 183 findChild(syntax::NodeRole::ReturnStatement_value)); 184 } 185 186 syntax::Leaf *syntax::RangeBasedForStatement::forKeyword() { 187 return llvm::cast_or_null<syntax::Leaf>( 188 findChild(syntax::NodeRole::IntroducerKeyword)); 189 } 190 191 syntax::Statement *syntax::RangeBasedForStatement::body() { 192 return llvm::cast_or_null<syntax::Statement>( 193 findChild(syntax::NodeRole::BodyStatement)); 194 } 195 196 syntax::Expression *syntax::ExpressionStatement::expression() { 197 return llvm::cast_or_null<syntax::Expression>( 198 findChild(syntax::NodeRole::ExpressionStatement_expression)); 199 } 200 201 syntax::Leaf *syntax::CompoundStatement::lbrace() { 202 return llvm::cast_or_null<syntax::Leaf>( 203 findChild(syntax::NodeRole::OpenParen)); 204 } 205 206 std::vector<syntax::Statement *> syntax::CompoundStatement::statements() { 207 std::vector<syntax::Statement *> Children; 208 for (auto *C = firstChild(); C; C = C->nextSibling()) { 209 if (C->role() == syntax::NodeRole::CompoundStatement_statement) 210 Children.push_back(llvm::cast<syntax::Statement>(C)); 211 } 212 return Children; 213 } 214 215 syntax::Leaf *syntax::CompoundStatement::rbrace() { 216 return llvm::cast_or_null<syntax::Leaf>( 217 findChild(syntax::NodeRole::CloseParen)); 218 } 219