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