Nodes.cpp Source File (original) (raw)

9#include "llvm/Support/raw_ostream.h"

11using namespace clang;

14 switch (K) {

15#define CONCRETE_NODE(Kind, Parent) \

16 case NodeKind::Kind: \

17 return OS << #Kind;

18#include "clang/Tooling/Syntax/Nodes.inc"

19 }

20 llvm_unreachable("unknown node kind");

21}

24 switch (R) {

25 case syntax::NodeRole::Detached:

26 return OS << "Detached";

27 case syntax::NodeRole::Unknown:

28 return OS << "Unknown";

29 case syntax::NodeRole::OpenParen:

30 return OS << "OpenParen";

31 case syntax::NodeRole::CloseParen:

32 return OS << "CloseParen";

33 case syntax::NodeRole::IntroducerKeyword:

34 return OS << "IntroducerKeyword";

35 case syntax::NodeRole::LiteralToken:

36 return OS << "LiteralToken";

37 case syntax::NodeRole::ArrowToken:

38 return OS << "ArrowToken";

39 case syntax::NodeRole::ExternKeyword:

40 return OS << "ExternKeyword";

41 case syntax::NodeRole::TemplateKeyword:

42 return OS << "TemplateKeyword";

43 case syntax::NodeRole::BodyStatement:

44 return OS << "BodyStatement";

45 case syntax::NodeRole::ListElement:

46 return OS << "ListElement";

47 case syntax::NodeRole::ListDelimiter:

48 return OS << "ListDelimiter";

49 case syntax::NodeRole::CaseValue:

50 return OS << "CaseValue";

51 case syntax::NodeRole::ReturnValue:

52 return OS << "ReturnValue";

53 case syntax::NodeRole::ThenStatement:

54 return OS << "ThenStatement";

55 case syntax::NodeRole::ElseKeyword:

56 return OS << "ElseKeyword";

57 case syntax::NodeRole::ElseStatement:

58 return OS << "ElseStatement";

59 case syntax::NodeRole::OperatorToken:

60 return OS << "OperatorToken";

61 case syntax::NodeRole::Operand:

62 return OS << "Operand";

63 case syntax::NodeRole::LeftHandSide:

64 return OS << "LeftHandSide";

65 case syntax::NodeRole::RightHandSide:

66 return OS << "RightHandSide";

67 case syntax::NodeRole::Expression:

68 return OS << "Expression";

69 case syntax::NodeRole::Statement:

70 return OS << "Statement";

71 case syntax::NodeRole::Condition:

72 return OS << "Condition";

73 case syntax::NodeRole::Message:

74 return OS << "Message";

75 case syntax::NodeRole::Declarator:

76 return OS << "Declarator";

77 case syntax::NodeRole::Declaration:

78 return OS << "Declaration";

79 case syntax::NodeRole::Size:

80 return OS << "Size";

81 case syntax::NodeRole::Parameters:

82 return OS << "Parameters";

83 case syntax::NodeRole::TrailingReturn:

84 return OS << "TrailingReturn";

85 case syntax::NodeRole::UnqualifiedId:

86 return OS << "UnqualifiedId";

87 case syntax::NodeRole::Qualifier:

88 return OS << "Qualifier";

89 case syntax::NodeRole::SubExpression:

90 return OS << "SubExpression";

91 case syntax::NodeRole::Object:

92 return OS << "Object";

93 case syntax::NodeRole::AccessToken:

94 return OS << "AccessToken";

95 case syntax::NodeRole::Member:

96 return OS << "Member";

97 case syntax::NodeRole::Callee:

98 return OS << "Callee";

99 case syntax::NodeRole::Arguments:

100 return OS << "Arguments";

101 case syntax::NodeRole::Declarators:

102 return OS << "Declarators";

103 }

104 llvm_unreachable("invalid role");

105}

106

107

108

109std::vector<syntax::NameSpecifier *>

112 std::vector<syntax::NameSpecifier *> Children;

113 for (const auto &Element : SpecifiersAsNodes) {

114 Children.push_back(llvm::castsyntax::NameSpecifier(Element));

115 }

116 return Children;

117}

118

119std::vector<syntax::List::ElementAndDelimitersyntax::NameSpecifier>

121 auto SpecifiersAsNodesAndDoubleColons = getElementsAsNodesAndDelimiters();

122 std::vector<syntax::List::ElementAndDelimitersyntax::NameSpecifier>

123 Children;

124 for (const auto &SpecifierAndDoubleColon : SpecifiersAsNodesAndDoubleColons) {

125 Children.push_back(

126 {llvm::castsyntax::NameSpecifier(SpecifierAndDoubleColon.element),

127 SpecifierAndDoubleColon.delimiter});

128 }

129 return Children;

130}

131

133 auto ArgumentsAsNodes = getElementsAsNodes();

134 std::vector<syntax::Expression *> Children;

135 for (const auto &ArgumentAsNode : ArgumentsAsNodes) {

136 Children.push_back(llvm::castsyntax::Expression(ArgumentAsNode));

137 }

138 return Children;

139}

140

141std::vector<syntax::List::ElementAndDelimitersyntax::Expression>

143 auto ArgumentsAsNodesAndCommas = getElementsAsNodesAndDelimiters();

144 std::vector<syntax::List::ElementAndDelimitersyntax::Expression> Children;

145 for (const auto &ArgumentAsNodeAndComma : ArgumentsAsNodesAndCommas) {

146 Children.push_back(

147 {llvm::castsyntax::Expression(ArgumentAsNodeAndComma.element),

148 ArgumentAsNodeAndComma.delimiter});

149 }

150 return Children;

151}

152

153std::vector<syntax::SimpleDeclaration *>

155 auto ParametersAsNodes = getElementsAsNodes();

156 std::vector<syntax::SimpleDeclaration *> Children;

157 for (const auto &ParameterAsNode : ParametersAsNodes) {

158 Children.push_back(llvm::castsyntax::SimpleDeclaration(ParameterAsNode));

159 }

160 return Children;

161}

162

163std::vector<syntax::List::ElementAndDelimitersyntax::SimpleDeclaration>

165 auto ParametersAsNodesAndCommas = getElementsAsNodesAndDelimiters();

166 std::vector<syntax::List::ElementAndDelimitersyntax::SimpleDeclaration>

167 Children;

168 for (const auto &ParameterAsNodeAndComma : ParametersAsNodesAndCommas) {

169 Children.push_back(

170 {llvm::castsyntax::SimpleDeclaration(ParameterAsNodeAndComma.element),

171 ParameterAsNodeAndComma.delimiter});

172 }

173 return Children;

174}

175

176std::vector<syntax::SimpleDeclarator *>

178 auto DeclaratorsAsNodes = getElementsAsNodes();

179 std::vector<syntax::SimpleDeclarator *> Children;

180 for (const auto &DeclaratorAsNode : DeclaratorsAsNodes) {

181 Children.push_back(llvm::castsyntax::SimpleDeclarator(DeclaratorAsNode));

182 }

183 return Children;

184}

185

186std::vector<syntax::List::ElementAndDelimitersyntax::SimpleDeclarator>

188 auto DeclaratorsAsNodesAndCommas = getElementsAsNodesAndDelimiters();

189 std::vector<syntax::List::ElementAndDelimitersyntax::SimpleDeclarator>

190 Children;

191 for (const auto &DeclaratorAsNodeAndComma : DeclaratorsAsNodesAndCommas) {

192 Children.push_back(

193 {llvm::castsyntax::SimpleDeclarator(DeclaratorAsNodeAndComma.element),

194 DeclaratorAsNodeAndComma.delimiter});

195 }

196 return Children;

197}

198

200 return cast_or_nullsyntax::Expression(

202}

203

206}

207

210}

211

214}

215

217 return cast_or_nullsyntax::Expression(

219}

220

222 return cast_or_nullsyntax::Leaf(

224}

225

227 return cast_or_nullsyntax::Statement(

229}

230

232 return cast_or_nullsyntax::Leaf(

234}

235

237 return cast_or_nullsyntax::Expression(

239}

240

242 return cast_or_nullsyntax::Statement(

244}

245

247 return cast_or_nullsyntax::Leaf(

249}

250

252 return cast_or_nullsyntax::Statement(

254}

255

257 return cast_or_nullsyntax::Leaf(

259}

260

262 return cast_or_nullsyntax::Statement(

264}

265

268}

269

271 return cast_or_nullsyntax::Statement(

273}

274

276 return cast_or_nullsyntax::Leaf(

278}

279

281 return cast_or_nullsyntax::Statement(

283}

284

286 return cast_or_nullsyntax::Leaf(

288}

289

291 return cast_or_nullsyntax::Statement(

293}

294

296 return cast_or_nullsyntax::Leaf(

298}

299

301 return cast_or_nullsyntax::Leaf(

303}

304

306 return cast_or_nullsyntax::Leaf(

308}

309

311 return cast_or_nullsyntax::Expression(

313}

314

316 return cast_or_nullsyntax::Leaf(

318}

319

321 return cast_or_nullsyntax::Statement(

323}

324

326 return cast_or_nullsyntax::Expression(

328}

329

332}

333

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

336 for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {

338 Children.push_back(castsyntax::Statement(C));

339 }

340 return Children;

341}

342

345}

346

348 return cast_or_nullsyntax::Expression(

350}

351

354}

355

356std::vector<syntax::SimpleDeclarator *>

358 std::vector<syntax::SimpleDeclarator *> Children;

359 for (auto *C = getFirstChild(); C; C = C->getNextSibling()) {

361 Children.push_back(castsyntax::SimpleDeclarator(C));

362 }

363 return Children;

364}

365

367 return cast_or_nullsyntax::Leaf(

369}

370

372 return cast_or_nullsyntax::Declaration(

374}

375

377 return cast_or_nullsyntax::Leaf(

379}

380

383}

384

386 return cast_or_nullsyntax::Declaration(

388}

389

392}

393

396}

397

400}

401

404}

405

408}

409

412}

413

415 return cast_or_nullsyntax::SimpleDeclarator(

417}

418

421}

422

425 return cast_or_nullsyntax::ParameterDeclarationList(

427}

428

431}

432

435 return cast_or_nullsyntax::TrailingReturnType(

437}

438

439#define NODE(Kind, Parent) \

440 static_assert(sizeof(syntax::Kind) > 0, "Missing Node subclass definition");

441#include "clang/Tooling/Syntax/Nodes.inc"

Leaf * getOperatorToken()

std::vector< List::ElementAndDelimiter< Expression > > getArgumentsAndCommas()

std::vector< Expression * > getArguments()

Expression * getCaseValue()

std::vector< Statement * > getStatements()

FIXME: use custom iterator instead of 'vector'.

Leaf * getContinueKeyword()

A declaration that can appear at the top-level.

std::vector< SimpleDeclarator * > getDeclarators()

std::vector< List::ElementAndDelimiter< syntax::SimpleDeclarator > > getDeclaratorsAndCommas()

Leaf * getDefaultKeyword()

Leaf * getExternKeyword()

Leaf * getTemplateKeyword()

Declaration * getDeclaration()

Expression * getExpression()

Statement * getThenStatement()

Statement * getElseStatement()

A leaf node points to a single token.

std::vector< Node * > getElementsAsNodes()

Returns the elements of the list.

std::vector< NameSpecifier * > getSpecifiers()

std::vector< List::ElementAndDelimiter< syntax::NameSpecifier > > getSpecifiersAndDoubleColons()

Models a parameter-declaration-list which appears within parameters-and-qualifiers.

std::vector< List::ElementAndDelimiter< syntax::SimpleDeclaration > > getParametersAndCommas()

std::vector< SimpleDeclaration * > getParameterDeclarations()

ParameterDeclarationList * getParameters()

TrailingReturnType * getTrailingReturn()

Leaf * getReturnKeyword()

Expression * getReturnValue()

std::vector< SimpleDeclarator * > getDeclarators()

FIXME: use custom iterator instead of 'vector'.

A top-level declarator without parentheses.

An abstract node for C++ statements, e.g.

Expression * getMessage()

Expression * getCondition()

Leaf * getSwitchKeyword()

Leaf * getTemplateKeyword()

Declaration * getDeclaration()

Trailing return type after the parameter list, including the arrow token.

SimpleDeclarator * getDeclarator()

Expression * getOperand()

Leaf * getOperatorToken()

NodeRole

A relation between a parent and child node, e.g.

@ CloseParen

A closing parenthesis in argument lists and blocks, e.g. '}', ')', etc.

@ IntroducerKeyword

A keywords that introduces some grammar construct, e.g. 'if', 'try', etc.

@ BodyStatement

An inner statement for those that have only a single child of kind statement, e.g.

@ OpenParen

An opening parenthesis in argument lists and blocks, e.g. '{', '(', etc.

@ ArrowToken

Tokens or Keywords.

NodeKind

A kind of a syntax node, used for implementing casts.

raw_ostream & operator<<(raw_ostream &OS, NodeKind K)

For debugging purposes.

The JSON file list parser is used to communicate input to InstallAPI.