RecursiveASTVisitor.h Source File (original) (raw)

62#define TRY_TO(CALL_EXPR) \

63 do { \

64 if (!getDerived().CALL_EXPR) \

65 return false; \

66 } while (false)

80 isSameMethod([[maybe_unused]] FirstMethodPtrTy FirstMethodPtr,

81 [[maybe_unused]] SecondMethodPtrTy SecondMethodPtr)

82 -> bool {

84 SecondMethodPtrTy>::value)

85 return FirstMethodPtr == SecondMethodPtr;

86 return false;

87}

157public:

158

159

160

161

162

165

166

167 Derived &getDerived() { return *static_cast<Derived *>(this); }

168

169

170

172

173

174

176

177

178

180

181

183

184

186

187

188

194

195

196

197

198

199

201

202

203

204

206

207

208

209

210

211

213

214

215

216

217

218

220

221

222

223

224

225

227

228

229

230

231

232

234

235

236

237

238

239

241

242

243

244

246

247

248

249

250

252

253

254

255

257

258

259

260

261

263

264

265

266

267

268

270

271

272

273

274

276

277

278

279

280

281

282

284

285

286

287

288

290

291

292

293

294

295

296

298

299

300

301

302

305

306

307

308

309

312

313

314

315

316

318

319

320

321

323

324

326

327

328

330

331

332#define ATTR_VISITOR_DECLS_ONLY

333#include "clang/AST/AttrVisitor.inc"

334#undef ATTR_VISITOR_DECLS_ONLY

335

336

337

339

340private:

341

342

343

344

345

346#define TRAVERSE_STMT_BASE(NAME, CLASS, VAR, QUEUE) \

347 (::clang::detail::has_same_member_pointer_type< \

348 decltype(&RecursiveASTVisitor::Traverse##NAME), \

349 decltype(&Derived::Traverse##NAME)>::value \

350 ? static_cast<std::conditional_t< \

351 ::clang::detail::has_same_member_pointer_type< \

352 decltype(&RecursiveASTVisitor::Traverse##NAME), \

353 decltype(&Derived::Traverse##NAME)>::value, \

354 Derived &, RecursiveASTVisitor &>>(*this) \

355 .Traverse##NAME(static_cast<CLASS *>(VAR), QUEUE) \

356 : getDerived().Traverse##NAME(static_cast<CLASS *>(VAR)))

357

358

359

360

361#define TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S) \

362 do { \

363 if (!TRAVERSE_STMT_BASE(Stmt, Stmt, S, Queue)) \

364 return false; \

365 } while (false)

366

367public:

368

369#define ABSTRACT_STMT(STMT)

370#define STMT(CLASS, PARENT) \

371 bool Traverse##CLASS(CLASS *S, DataRecursionQueue *Queue = nullptr);

372#include "clang/AST/StmtNodes.inc"

373

374

375

378#define STMT(CLASS, PARENT) \

379 bool WalkUpFrom##CLASS(CLASS *S) { \

380 TRY_TO(WalkUpFrom##PARENT(S)); \

381 TRY_TO(Visit##CLASS(S)); \

382 return true; \

383 } \

384 bool Visit##CLASS(CLASS *S) { return true; }

385#include "clang/AST/StmtNodes.inc"

386

387

388

389

390

391#define ABSTRACT_TYPE(CLASS, BASE)

392#define TYPE(CLASS, BASE) \

393 bool Traverse##CLASS##Type(CLASS##Type *T, bool TraverseQualifier);

394#include "clang/AST/TypeNodes.inc"

395

396

397

400#define TYPE(CLASS, BASE) \

401 bool WalkUpFrom##CLASS##Type(CLASS##Type *T) { \

402 TRY_TO(WalkUpFrom##BASE(T)); \

403 TRY_TO(Visit##CLASS##Type(T)); \

404 return true; \

405 } \

406 bool Visit##CLASS##Type(CLASS##Type *T) { return true; }

407#include "clang/AST/TypeNodes.inc"

408

409

410

411

412

413#define ABSTRACT_TYPELOC(CLASS, BASE)

414#define TYPELOC(CLASS, BASE) \

415 bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL, bool TraverseQualifier);

416#include "clang/AST/TypeLocNodes.def"

417

418

419

422

423

424

433

434

435#define TYPE(CLASS, BASE) \

436 bool WalkUpFrom##CLASS##TypeLoc(CLASS##TypeLoc TL) { \

437 TRY_TO(WalkUpFrom##BASE##Loc(TL)); \

438 TRY_TO(Visit##CLASS##TypeLoc(TL)); \

439 return true; \

440 } \

441 bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; }

442#include "clang/AST/TypeNodes.inc"

443

444

445

446

447#define ABSTRACT_DECL(DECL)

448#define DECL(CLASS, BASE) bool Traverse##CLASS##Decl(CLASS##Decl *D);

449#include "clang/AST/DeclNodes.inc"

450

451

452

455#define DECL(CLASS, BASE) \

456 bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D) { \

457 TRY_TO(WalkUpFrom##BASE(D)); \

458 TRY_TO(Visit##CLASS##Decl(D)); \

459 return true; \

460 } \

461 bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }

462#include "clang/AST/DeclNodes.inc"

463

465

466#define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND) \

467 bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);

471#undef DEF_TRAVERSE_TMPL_INST

472

474

479

481

482private:

483

485

486

487 template

488 bool TraverseDeclTemplateParameterLists(T *D);

489

490 bool TraverseTemplateTypeParamDeclConstraints(const TemplateTypeParmDecl *D);

491

493 unsigned Count);

494 bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL);

495 bool TraverseSubstPackTypeHelper(SubstPackType *T);

497 bool TraverseRecordHelper(RecordDecl *D);

500 bool TraverseDeclContextHelper(DeclContext *DC);

501 bool TraverseFunctionHelper(FunctionDecl *D);

502 bool TraverseVarHelper(VarDecl *D);

505 bool TraverseOMPClause(OMPClause *C);

506 bool TraverseTagType(TagType *T, bool TraverseQualifier);

507 bool TraverseTagTypeLoc(TagTypeLoc TL, bool TraverseQualifier);

508#define GEN_CLANG_CLAUSE_CLASS

509#define CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C);

510#include "llvm/Frontend/OpenMP/OMP.inc"

511

512 template bool VisitOMPClauseList(T *Node);

513

514 bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node);

515 bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node);

516

517 bool PostVisitStmt(Stmt *S);

519 bool

522 bool VisitOpenACCClause(const OpenACCClause *);

523};

530 return true;

531 }

532 if (Expr *IDC = C->getImmediatelyDeclaredConstraint()) {

534 } else {

535

536

537

538

540 }

541 return true;

542}

549 return getDerived().TraverseConceptTypeRequirement(

553 return getDerived().TraverseConceptExprRequirement(

556 return getDerived().TraverseConceptNestedRequirement(

558 }

559 llvm_unreachable("unexpected case");

560}

565

568 break;

569#define ABSTRACT_STMT(STMT)

570#define STMT(CLASS, PARENT) \

571 case Stmt::CLASS##Class: \

572 return TRAVERSE_STMT_BASE(CLASS, CLASS, S, Queue);

573#include "clang/AST/StmtNodes.inc"

574 }

575

576 return true;

577}

595 if (RetReq.isTypeConstraint()) {

597 TRY_TO(TraverseTemplateParameterListHelper(

598 RetReq.getTypeConstraintTemplateParameterList()));

599 } else {

600

602 }

603 }

604 return true;

605}

668 if (!S)

669 return true;

670

671 if (Queue) {

672 Queue->push_back({S, false});

673 return true;

674 }

675

677 LocalQueue.push_back({S, false});

678

679 while (!LocalQueue.empty()) {

680 auto &CurrSAndVisited = LocalQueue.back();

681 Stmt *CurrS = CurrSAndVisited.getPointer();

682 bool Visited = CurrSAndVisited.getInt();

683 if (Visited) {

684 LocalQueue.pop_back();

687 TRY_TO(PostVisitStmt(CurrS));

688 }

689 continue;

690 }

691

693 CurrSAndVisited.setInt(true);

694 size_t N = LocalQueue.size();

696

697 std::reverse(LocalQueue.begin() + N, LocalQueue.end());

698 } else {

699 LocalQueue.pop_back();

700 }

701 }

702

703 return true;

704}

708 bool TraverseQualifier) {

709 if (T.isNull())

710 return true;

711

712 switch (T->getTypeClass()) {

713#define ABSTRACT_TYPE(CLASS, BASE)

714#define TYPE(CLASS, BASE) \

715 case Type::CLASS: \

716 return getDerived().Traverse##CLASS##Type( \

717 static_cast<CLASS##Type *>(const_cast<Type *>(T.getTypePtr())), \

718 TraverseQualifier);

719#include "clang/AST/TypeNodes.inc"

720 }

721

722 return true;

723}

727 bool TraverseQualifier) {

729 return true;

730

732#define ABSTRACT_TYPELOC(CLASS, BASE)

733#define TYPELOC(CLASS, BASE) \

734 case TypeLoc::CLASS: \

735 return getDerived().Traverse##CLASS##TypeLoc(TL.castAs<CLASS##TypeLoc>(), \

736 TraverseQualifier);

737#include "clang/AST/TypeLocNodes.def"

738 }

739

740 return true;

741}

750 if (!D)

751 return true;

752

753

754

757

758

759

760 if (auto *TTPD = dyn_cast(D))

761 return TraverseTemplateTypeParamDeclConstraints(TTPD);

762 return true;

763 }

764

765

766

767

768

769

770

771

772 if (auto *FTD = dyn_cast(D))

773 if (llvm::isa_and_present(

774 FTD->getDeclName().getCXXDeductionGuideTemplate()))

775 return true;

776 }

777

779#define ABSTRACT_DECL(DECL)

780#define DECL(CLASS, BASE) \

781 case Decl::CLASS: \

782 if (!getDerived().Traverse##CLASS##Decl(static_cast<CLASS##Decl *>(D))) \

783 return false; \

784 break;

785#include "clang/AST/DeclNodes.inc"

786 }

787 return true;

788}

797 return true;

800 return true;

805 return true;

806 }

807 }

808 llvm_unreachable("unhandled kind");

809}

818 return true;

822 return true;

827 return true;

828 }

829 }

830

831 return true;

832}

843 break;

844

848 break;

849

857 break;

858 }

859

860 return true;

861}

868 Template.getAsQualifiedTemplateName()) {

869 if (QTN->getQualifier()) {

871 }

872 }

873

874 return true;

875}

886 return true;

887

890

893 return getDerived().TraverseTemplateName(

895

898

901 }

902

903 return true;

904}

912

919 return true;

920

922

924 return getDerived().TraverseTypeLoc(TSI->getTypeLoc());

925 else

927 }

928

934 return getDerived().TraverseTemplateName(

936

939

942 }

943

944 return true;

945}

952

953 return true;

954}

961

964

965 return true;

966}

973 if (LE->isInitCapture(C))

975 else

977 return true;

978}

983#define DEF_TRAVERSE_TYPE(TYPE, CODE) \

984 template \

985 bool RecursiveASTVisitor::Traverse##TYPE(TYPE *T, \

986 bool TraverseQualifier) { \

987 if (!getDerived().shouldTraversePostOrder()) \

988 TRY_TO(WalkUpFrom##TYPE(T)); \

989 { \

990 CODE; \

991 } \

992 if (getDerived().shouldTraversePostOrder()) \

993 TRY_TO(WalkUpFrom##TYPE(T)); \

994 return true; \

995 }

1089 for (const auto &A : T->param_types()) {

1090 TRY_TO(TraverseType(A));

1091 }

1093 for (const auto &E : T->exceptions()) {

1094 TRY_TO(TraverseType(E));

1095 }

1174 { TRY_TO(TraverseType(T->getUnderlyingType())); })

1175

1176template

1177bool RecursiveASTVisitor::TraverseTagType(TagType *T,

1178 bool TraverseQualifier) {

1179 if (TraverseQualifier)

1180 TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));

1181 return true;

1182}

1218

1220

1222

1224

1225

1226 if (T->getBaseType().getTypePtr() != T)

1227 TRY_TO(TraverseType(T->getBaseType()));

1228 for (auto typeArg : T->getTypeArgsAsWritten()) {

1229 TRY_TO(TraverseType(typeArg));

1230 }

1231})

1232

1234 { TRY_TO(TraverseType(T->getPointeeType())); })

1235

1237

1239

1242 { TRY_TO(TraverseStmt(T->getNumBitsExpr())); })

1243

1245

1247

1248

1249

1250

1251

1252

1253

1254

1256 template \

1257 bool RecursiveASTVisitor::Traverse##TYPE##Loc( \

1258 TYPE##Loc TL, bool TraverseQualifier) { \

1259 if (!getDerived().shouldTraversePostOrder()) { \

1260 TRY_TO(WalkUpFrom##TYPE##Loc(TL)); \

1261 if (getDerived().shouldWalkTypesOfTypeLocs()) \

1262 TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr()))); \

1263 } \

1264 { \

1265 CODE; \

1266 } \

1267 if (getDerived().shouldTraversePostOrder()) { \

1268 TRY_TO(WalkUpFrom##TYPE##Loc(TL)); \

1269 if (getDerived().shouldWalkTypesOfTypeLocs()) \

1270 TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr()))); \

1271 } \

1272 return true; \

1273 }

1274

1275template

1278 assert(TraverseQualifier &&

1279 "Qualifiers should never occur within NestedNameSpecifiers");

1280

1281

1282

1283

1284

1285

1286

1287

1288

1289

1290

1291

1292

1293

1294

1295 return TraverseTypeLoc(TL.getUnqualifiedLoc());

1296}

1297

1299

1300

1302 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));

1303})

1304

1306 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })

1307

1309 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })

1310

1312 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })

1313

1315 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })

1316

1317

1318

1320 if (NestedNameSpecifierLoc QL = TL.getQualifierLoc())

1322 else

1323 TRY_TO(TraverseNestedNameSpecifier(TL.getTypePtr()->getQualifier()));

1324 TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));

1325})

1326

1328 { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })

1329

1331 { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })

1332

1333template

1334bool RecursiveASTVisitor::TraverseArrayTypeLocHelper(ArrayTypeLoc TL) {

1335

1336 TRY_TO(TraverseStmt(TL.getSizeExpr()));

1337 return true;

1338}

1339

1341 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));

1342 TRY_TO(TraverseArrayTypeLocHelper(TL));

1343})

1344

1346 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));

1347 TRY_TO(TraverseArrayTypeLocHelper(TL));

1348})

1349

1351 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));

1352 TRY_TO(TraverseArrayTypeLocHelper(TL));

1353})

1354

1356 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));

1357 TRY_TO(TraverseArrayTypeLocHelper(TL));

1358})

1359

1361 TRY_TO(TraverseTypeLoc(TL.getElementLoc()));

1362 TRY_TO(TraverseArrayTypeLocHelper(TL));

1363})

1364

1366 TRY_TO(TraverseStmt(TL.getTypePtr()->getAddrSpaceExpr()));

1367 TRY_TO(TraverseType(TL.getTypePtr()->getPointeeType()));

1368})

1369

1370

1371

1373 if (TL.getTypePtr()->getSizeExpr())

1374 TRY_TO(TraverseStmt(TL.getTypePtr()->getSizeExpr()));

1375 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));

1376})

1377

1378

1380 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));

1381})

1382

1384 if (TL.getTypePtr()->getSizeExpr())

1385 TRY_TO(TraverseStmt(TL.getTypePtr()->getSizeExpr()));

1386 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));

1387})

1388

1389

1390

1392 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));

1393})

1394

1396 TRY_TO(TraverseStmt(TL.getAttrRowOperand()));

1397 TRY_TO(TraverseStmt(TL.getAttrColumnOperand()));

1398 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));

1399})

1400

1402 TRY_TO(TraverseStmt(TL.getAttrRowOperand()));

1403 TRY_TO(TraverseStmt(TL.getAttrColumnOperand()));

1404 TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));

1405})

1406

1408 { TRY_TO(TraverseTypeLoc(TL.getReturnLoc())); })

1409

1410

1412 TRY_TO(TraverseTypeLoc(TL.getReturnLoc()));

1413

1415

1416 for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {

1417 if (TL.getParam(I)) {

1418 TRY_TO(TraverseDecl(TL.getParam(I)));

1419 } else if (I < T->getNumParams()) {

1420 TRY_TO(TraverseType(T->getParamType(I)));

1421 }

1422 }

1423

1424 for (const auto &E : T->exceptions()) {

1425 TRY_TO(TraverseType(E));

1426 }

1427

1428 if (Expr *NE = T->getNoexceptExpr())

1429 TRY_TO(TraverseStmt(NE));

1430})

1431

1434 TraverseQualifier && QualifierLoc)

1436})

1438 if (NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();

1439 TraverseQualifier && QualifierLoc)

1441})

1444 TraverseQualifier && QualifierLoc)

1446})

1447

1449 { TRY_TO(TraverseStmt(TL.getUnderlyingExpr())); })

1450

1452 TRY_TO(TraverseTypeLoc(TL.getUnmodifiedTInfo()->getTypeLoc()));

1453})

1454

1455

1457 TRY_TO(TraverseStmt(TL.getTypePtr()->getUnderlyingExpr()));

1458})

1459

1461 TRY_TO(TraverseType(TL.getPattern()));

1462 TRY_TO(TraverseStmt(TL.getTypePtr()->getIndexExpr()));

1463})

1464

1466 TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));

1467})

1468

1470 TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));

1471 if (TL.isConstrained()) {

1472 TRY_TO(TraverseConceptReference(TL.getConceptReference()));

1473 }

1474})

1475

1478 TRY_TO(TraverseType(TL.getTypePtr()->getReplacementType()));

1479})

1480

1481template

1482bool RecursiveASTVisitor::TraverseSubstPackTypeLocHelper(

1484 TRY_TO(TraverseTemplateArgument(TL.getTypePtr()->getArgumentPack()));

1485 return true;

1486}

1487

1488template

1489bool RecursiveASTVisitor::TraverseSubstPackTypeHelper(

1490 SubstPackType *T) {

1491 TRY_TO(TraverseTemplateArgument(T->getArgumentPack()));

1492 return true;

1493}

1494

1496 { TRY_TO(TraverseSubstPackTypeLocHelper(TL)); })

1497

1499 { TRY_TO(TraverseSubstPackTypeLocHelper(TL)); })

1500

1502

1504 { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); })

1505

1507 { TRY_TO(TraverseTypeLoc(TL.getModifiedLoc())); })

1508

1510 { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); })

1511

1513 { TRY_TO(TraverseTypeLoc(TL.getWrappedLoc())); })

1514

1516 { TRY_TO(TraverseTypeLoc(TL.getWrappedLoc())); })

1517

1519 { TRY_TO(TraverseType(TL.getType())); })

1520

1521template

1522bool RecursiveASTVisitor::TraverseTagTypeLoc(TagTypeLoc TL,

1523 bool TraverseQualifier) {

1524 if (NestedNameSpecifierLoc QualifierLoc = TL.getQualifierLoc();

1525 TraverseQualifier && QualifierLoc)

1527 return true;

1528}

1529

1531 { TRY_TO(TraverseTagTypeLoc(TL, TraverseQualifier)); })

1533 { TRY_TO(TraverseTagTypeLoc(TL, TraverseQualifier)); })

1535 { TRY_TO(TraverseTagTypeLoc(TL, TraverseQualifier)); })

1536

1538 if (TraverseQualifier)

1540})

1541

1543 if (TraverseQualifier)

1545

1546

1547 TRY_TO(TraverseTemplateName(

1548 TemplateName(TL.getTypePtr()->getTemplateName().getAsTemplateDecl(

1549 true))));

1550

1551 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {

1552 TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));

1553 }

1554})

1555

1557 if (TraverseQualifier)

1559

1560 const auto *T = TL.getTypePtr();

1561

1563 TraverseTemplateName(TemplateName(T->getTemplateName().getAsTemplateDecl(

1564 true))));

1565

1566 TRY_TO(TraverseType(T->getDeducedType()));

1567})

1568

1570 { TRY_TO(TraverseTypeLoc(TL.getPatternLoc())); })

1571

1573 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {

1574 ObjCProtocolLoc ProtocolLoc(TL.getProtocol(I), TL.getProtocolLoc(I));

1575 TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));

1576 }

1577})

1578

1580

1582

1583

1584 if (TL.getTypePtr()->getBaseType().getTypePtr() != TL.getTypePtr())

1585 TRY_TO(TraverseTypeLoc(TL.getBaseLoc()));

1586 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)

1587 TRY_TO(TraverseTypeLoc(TL.getTypeArgTInfo(i)->getTypeLoc()));

1588 for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {

1589 ObjCProtocolLoc ProtocolLoc(TL.getProtocol(I), TL.getProtocolLoc(I));

1590 TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));

1591 }

1592})

1593

1595 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })

1596

1598

1600

1603 TRY_TO(TraverseStmt(TL.getTypePtr()->getNumBitsExpr()));

1604})

1605

1607

1609

1610

1611

1612

1613

1614

1615

1616

1617template

1619 const Decl *Child) {

1620

1621

1623 return true;

1624

1625 if (const CXXRecordDecl* Cls = dyn_cast(Child))

1626 return Cls->isLambda();

1627 return false;

1628}

1629

1630template

1631bool RecursiveASTVisitor::TraverseDeclContextHelper(DeclContext *DC) {

1632 if (!DC)

1633 return true;

1634

1635 for (auto *Child : DC->decls()) {

1636 if (!canIgnoreChildDeclWhileTraversingDeclContext(Child))

1637 TRY_TO(TraverseDecl(Child));

1638 }

1639

1640 return true;

1641}

1642

1643

1644#define DEF_TRAVERSE_DECL(DECL, CODE) \

1645 template \

1646 bool RecursiveASTVisitor::Traverse##DECL(DECL *D) { \

1647 bool ShouldVisitChildren = true; \

1648 bool ReturnValue = true; \

1649 if (!getDerived().shouldTraversePostOrder()) \

1650 TRY_TO(WalkUpFrom##DECL(D)); \

1651 { CODE; } \

1652 if (ReturnValue && ShouldVisitChildren) \

1653 TRY_TO(TraverseDeclContextHelper(dyn_cast(D))); \

1654 if (ReturnValue) { \

1655 \

1656 for (auto *I : D->attrs()) \

1657 TRY_TO(getDerived().TraverseAttr(I)); \

1658 } \

1659 if (ReturnValue && getDerived().shouldTraversePostOrder()) \

1660 TRY_TO(WalkUpFrom##DECL(D)); \

1661 return ReturnValue; \

1662 }

1663

1665

1667 if (TypeSourceInfo *TInfo = D->getSignatureAsWritten())

1668 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));

1669 TRY_TO(TraverseStmt(D->getBody()));

1670 for (const auto &I : D->captures()) {

1671 if (I.hasCopyExpr()) {

1672 TRY_TO(TraverseStmt(I.getCopyExpr()));

1673 }

1674 }

1675 ShouldVisitChildren = false;

1676})

1677

1679 TRY_TO(TraverseStmt(D->getBody()));

1680 ShouldVisitChildren = false;

1681})

1682

1684 TRY_TO(TraverseStmt(D->getBody()));

1685 ShouldVisitChildren = false;

1686})

1687

1689

1691

1693

1695 TRY_TO(TraverseStmt(D->getTemporaryExpr()));

1696})

1697

1699 { TRY_TO(TraverseStmt(D->getAsmStringExpr())); })

1700

1702

1704

1706

1707 if (D->getFriendType()) {

1708 TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));

1709

1710

1711 if (auto *TT = D->getFriendType()->getType()->getAs();

1712 TT && TT->isTagOwned())

1713 TRY_TO(TraverseDecl(TT->getDecl()));

1714 } else {

1715 TRY_TO(TraverseDecl(D->getFriendDecl()));

1716 }

1717})

1718

1720 if (D->getFriendType())

1721 TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));

1722 else

1723 TRY_TO(TraverseDecl(D->getFriendDecl()));

1724 for (unsigned I = 0, E = D->getNumTemplateParameters(); I < E; ++I) {

1727 ITPL != ETPL; ++ITPL) {

1728 TRY_TO(TraverseDecl(*ITPL));

1729 }

1730 }

1731})

1732

1734

1736

1738 })

1739

1741 TRY_TO(TraverseStmt(D->getAssertExpr()));

1742 TRY_TO(TraverseStmt(D->getMessage()));

1743})

1744

1746

1747

1748

1749

1750

1751

1752 auto Scope = D->getASTContext().getTraversalScope();

1753 bool HasLimitedScope =

1755 if (HasLimitedScope) {

1756 ShouldVisitChildren = false;

1757 for (auto *Child : Scope) {

1758 if (!canIgnoreChildDeclWhileTraversingDeclContext(Child))

1759 TRY_TO(TraverseDecl(Child));

1760 }

1761 }

1762})

1763

1765

1767

1769

1772

1773

1774

1775 ShouldVisitChildren = false;

1776})

1777

1779 })

1780

1783 {

1784

1785

1786 })

1787

1789 })

1790

1793 for (auto typeParam : *typeParamList) {

1794 TRY_TO(TraverseObjCTypeParamDecl(typeParam));

1795 }

1796 }

1797 for (auto It : llvm::zip(D->protocols(), D->protocol_locs())) {

1798 ObjCProtocolLoc ProtocolLoc(std::get<0>(It), std::get<1>(It));

1799 TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));

1800 }

1801})

1802

1804 })

1805

1807 })

1808

1810 if (ObjCTypeParamList *typeParamList = D->getTypeParamListAsWritten()) {

1811 for (auto typeParam : *typeParamList) {

1812 TRY_TO(TraverseObjCTypeParamDecl(typeParam));

1813 }

1814 }

1815

1816 if (TypeSourceInfo *superTInfo = D->getSuperClassTInfo()) {

1817 TRY_TO(TraverseTypeLoc(superTInfo->getTypeLoc()));

1818 }

1819 if (D->isThisDeclarationADefinition()) {

1820 for (auto It : llvm::zip(D->protocols(), D->protocol_locs())) {

1821 ObjCProtocolLoc ProtocolLoc(std::get<0>(It), std::get<1>(It));

1822 TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));

1823 }

1824 }

1825})

1826

1828 if (D->isThisDeclarationADefinition()) {

1829 for (auto It : llvm::zip(D->protocols(), D->protocol_locs())) {

1830 ObjCProtocolLoc ProtocolLoc(std::get<0>(It), std::get<1>(It));

1831 TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));

1832 }

1833 }

1834})

1835

1837 if (D->getReturnTypeSourceInfo()) {

1838 TRY_TO(TraverseTypeLoc(D->getReturnTypeSourceInfo()->getTypeLoc()));

1839 }

1842 }

1843 if (D->isThisDeclarationADefinition()) {

1844 TRY_TO(TraverseStmt(D->getBody()));

1845 }

1846 ShouldVisitChildren = false;

1847})

1848

1850 if (D->hasExplicitBound()) {

1851 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));

1852

1853

1854

1855 }

1856})

1857

1859 if (D->getTypeSourceInfo())

1860 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));

1861 else

1862 TRY_TO(TraverseType(D->getType()));

1863 ShouldVisitChildren = false;

1864})

1865

1868 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));

1869})

1870

1872 { TRY_TO(TraverseTypeLoc(D->getEnumTypeLoc())); })

1873

1875

1878})

1879

1881

1883

1885 for (auto *I : D->varlist()) {

1886 TRY_TO(TraverseStmt(I));

1887 }

1888})

1889

1891 for (auto *I : D->varlist()) {

1892 TRY_TO(TraverseStmt(I));

1893 }

1894})

1895

1897 for (auto *C : D->clauselists()) {

1898 TRY_TO(TraverseOMPClause(C));

1899 }

1900})

1901

1903 TRY_TO(TraverseStmt(D->getCombiner()));

1904 if (auto *Initializer = D->getInitializer())

1906 TRY_TO(TraverseType(D->getType()));

1907 return true;

1908})

1909

1911 for (auto *C : D->clauselists())

1912 TRY_TO(TraverseOMPClause(C));

1913 TRY_TO(TraverseType(D->getType()));

1914 return true;

1915})

1916

1918

1920 for (auto *I : D->varlist())

1921 TRY_TO(TraverseStmt(I));

1922 for (auto *C : D->clauselists())

1923 TRY_TO(TraverseOMPClause(C));

1924})

1925

1927 { TRY_TO(VisitOpenACCClauseList(D->clauses())); })

1928

1930 TRY_TO(TraverseStmt(D->getFunctionReference()));

1931 TRY_TO(VisitOpenACCClauseList(D->clauses()));

1932})

1933

1934

1935template

1936bool RecursiveASTVisitor::TraverseTemplateParameterListHelper(

1938 if (TPL) {

1940 TRY_TO(TraverseDecl(D));

1941 }

1942 if (Expr *RequiresClause = TPL->getRequiresClause()) {

1943 TRY_TO(TraverseStmt(RequiresClause));

1944 }

1945 }

1946 return true;

1947}

1948

1949template

1950template

1951bool RecursiveASTVisitor::TraverseDeclTemplateParameterLists(T *D) {

1952 for (unsigned i = 0; i < D->getNumTemplateParameterLists(); i++) {

1954 TraverseTemplateParameterListHelper(TPL);

1955 }

1956 return true;

1957}

1958

1959template

1962 for (auto *SD : D->specializations()) {

1963 for (auto *RD : SD->redecls()) {

1965 switch (

1967

1970 TRY_TO(TraverseDecl(RD));

1971 break;

1972

1973

1974

1975

1979 break;

1980 }

1981 }

1982 }

1983

1984 return true;

1985}

1986

1987template

1990 for (auto *SD : D->specializations()) {

1991 for (auto *RD : SD->redecls()) {

1992 switch (

1996 TRY_TO(TraverseDecl(RD));

1997 break;

1998

2002 break;

2003 }

2004 }

2005 }

2006

2007 return true;

2008}

2009

2010

2011

2012template

2015 for (auto *FD : D->specializations()) {

2016 for (auto *RD : FD->redecls()) {

2017 switch (RD->getTemplateSpecializationKind()) {

2020

2021 TRY_TO(TraverseDecl(RD));

2022 break;

2023

2024

2025

2028 TRY_TO(TraverseDecl(RD));

2029 break;

2030

2032 break;

2033 }

2034 }

2035 }

2036

2037 return true;

2038}

2039

2040

2041

2042#define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND) \

2043 DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateDecl, { \

2044 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters())); \

2045 TRY_TO(TraverseDecl(D->getTemplatedDecl())); \

2046 \

2047

2048

2049

2050

2051

2052 \

2053 if (getDerived().shouldVisitTemplateInstantiations() && \

2054 D == D->getCanonicalDecl()) \

2055 TRY_TO(TraverseTemplateInstantiations(D)); \

2056 \

2057

2058

2059 \

2060 })

2061

2065

2067

2068

2069 TRY_TO(TraverseDecl(D->getTemplatedDecl()));

2070 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())

2071 TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument()));

2072 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));

2073})

2074

2076 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));

2077})

2078

2079template

2080bool RecursiveASTVisitor::TraverseTemplateTypeParamDeclConstraints(

2082 if (const auto *TC = D->getTypeConstraint())

2083 TRY_TO(TraverseTypeConstraint(TC));

2084 return true;

2085}

2086

2088

2089 if (D->getTypeForDecl())

2090 TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));

2091 TRY_TO(TraverseTemplateTypeParamDeclConstraints(D));

2092 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())

2093 TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument()));

2094})

2095

2097 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));

2098

2099

2100

2101})

2102

2104 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));

2105

2106

2107

2108})

2109

2111 TRY_TO(TraverseDecl(D->getTemplatedDecl()));

2112 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));

2113})

2114

2116 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));

2117 TRY_TO(TraverseStmt(D->getConstraintExpr()));

2118})

2119

2121

2122

2124

2125

2126

2127})

2128

2130

2132 TRY_TO(TraverseDeclTemplateParameterLists(D));

2133

2135 if (auto *TSI = D->getIntegerTypeSourceInfo())

2136 TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));

2137

2138

2139})

2140

2141

2142template

2143bool RecursiveASTVisitor::TraverseRecordHelper(RecordDecl *D) {

2144

2145

2146

2147 TRY_TO(TraverseDeclTemplateParameterLists(D));

2149 return true;

2150}

2151

2152template

2155 TRY_TO(TraverseTypeLoc(Base.getTypeSourceInfo()->getTypeLoc()));

2156 return true;

2157}

2158

2159template

2160bool RecursiveASTVisitor::TraverseCXXRecordHelper(CXXRecordDecl *D) {

2161 if (!TraverseRecordHelper(D))

2162 return false;

2163 if (D->isCompleteDefinition()) {

2164 for (const auto &I : D->bases()) {

2165 TRY_TO(TraverseCXXBaseSpecifier(I));

2166 }

2167

2168

2169 }

2170 return true;

2171}

2172

2174

2176

2177template

2178bool RecursiveASTVisitor::TraverseTemplateArgumentLocsHelper(

2180 for (unsigned I = 0; I < Count; ++I) {

2181 TRY_TO(TraverseTemplateArgumentLoc(TAL[I]));

2182 }

2183 return true;

2184}

2185

2186#define DEF_TRAVERSE_TMPL_SPEC_DECL(TMPLDECLKIND, DECLKIND) \

2187 DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateSpecializationDecl, { \

2188

2189

2190

2191

2192

2193

2194

2195 \

2196 if (const auto *ArgsWritten = D->getTemplateArgsAsWritten()) { \

2197 assert(D->getTemplateSpecializationKind() != TSK_ImplicitInstantiation); \

2198 \

2199 TRY_TO(TraverseTemplateArgumentLocsHelper( \

2200 ArgsWritten->getTemplateArgs(), ArgsWritten->NumTemplateArgs)); \

2201 } \

2202 \

2203 if (getDerived().shouldVisitTemplateInstantiations() || \

2204 D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) { \

2205 \

2206 TRY_TO(Traverse##DECLKIND##Helper(D)); \

2207 } else { \

2208 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); \

2209 \

2210

2211

2212

2213 \

2214 return true; \

2215 } \

2216 })

2217

2220

2221#define DEF_TRAVERSE_TMPL_PART_SPEC_DECL(TMPLDECLKIND, DECLKIND) \

2222 DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplatePartialSpecializationDecl, { \

2223 \

2224 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters())); \

2225 \

2226 TRY_TO(TraverseTemplateArgumentLocsHelper( \

2227 D->getTemplateArgsAsWritten()->getTemplateArgs(), \

2228 D->getTemplateArgsAsWritten()->NumTemplateArgs)); \

2229 \

2230

2231

2232 \

2233 TRY_TO(Traverse##DECLKIND##Helper(D)); \

2234 \

2235 \

2236 })

2237

2240

2242

2244

2245

2247 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));

2248})

2249

2251

2252template

2253bool RecursiveASTVisitor::TraverseDeclaratorHelper(DeclaratorDecl *D) {

2254 TRY_TO(TraverseDeclTemplateParameterLists(D));

2256 if (D->getTypeSourceInfo())

2257 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));

2258 else

2259 TRY_TO(TraverseType(D->getType()));

2260 return true;

2261}

2262

2264 TRY_TO(TraverseVarHelper(D));

2265 for (auto *Binding : D->bindings()) {

2266 TRY_TO(TraverseDecl(Binding));

2267 }

2268})

2269

2271 if (getDerived().shouldVisitImplicitCode()) {

2272 TRY_TO(TraverseStmt(D->getBinding()));

2273 if (const auto HoldingVar = D->getHoldingVar())

2274 TRY_TO(TraverseDecl(HoldingVar));

2275 }

2276})

2277

2279

2282

2284

2286 TRY_TO(TraverseDeclaratorHelper(D));

2287 if (D->isBitField())

2288 TRY_TO(TraverseStmt(D->getBitWidth()));

2289 if (D->hasInClassInitializer())

2290 TRY_TO(TraverseStmt(D->getInClassInitializer()));

2291})

2292

2294 TRY_TO(TraverseDeclaratorHelper(D));

2295 if (D->isBitField())

2296 TRY_TO(TraverseStmt(D->getBitWidth()));

2297

2298})

2299

2301 TRY_TO(TraverseDeclaratorHelper(D));

2302 if (D->isBitField())

2303 TRY_TO(TraverseStmt(D->getBitWidth()));

2304

2305})

2306

2307template

2308bool RecursiveASTVisitor::TraverseFunctionHelper(FunctionDecl *D) {

2309 TRY_TO(TraverseDeclTemplateParameterLists(D));

2311 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));

2312

2313

2314

2315

2316

2317

2319 D->getTemplateSpecializationInfo()) {

2320 if (FTSI->getTemplateSpecializationKind() != TSK_Undeclared &&

2322

2323

2325 FTSI->TemplateArgumentsAsWritten) {

2326 TRY_TO(TraverseTemplateArgumentLocsHelper(TALI->getTemplateArgs(),

2327 TALI->NumTemplateArgs));

2328 }

2329 }

2331 D->getDependentSpecializationInfo()) {

2333 DFSI->TemplateArgumentsAsWritten) {

2334 TRY_TO(TraverseTemplateArgumentLocsHelper(TALI->getTemplateArgs(),

2335 TALI->NumTemplateArgs));

2336 }

2337 }

2338

2339

2340

2341

2342

2344 TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));

2345 } else if (getDerived().shouldVisitImplicitCode()) {

2346

2347

2348

2349

2352 }

2353 }

2354

2355

2357 D->getTrailingRequiresClause()) {

2358 TRY_TO(TraverseStmt(

2359 const_cast<Expr *>(TrailingRequiresClause.ConstraintExpr)));

2360 }

2361

2363

2364 for (auto *I : Ctor->inits()) {

2365 if (I->isWritten() || getDerived().shouldVisitImplicitCode())

2366 TRY_TO(TraverseConstructorInitializer(I));

2367 }

2368 }

2369

2370 bool VisitBody =

2371 D->isThisDeclarationADefinition() &&

2372

2373

2374 (!D->isDefaulted() || getDerived().shouldVisitImplicitCode());

2375

2376 if (const auto *MD = dyn_cast(D)) {

2378 if (RD->isLambda() &&

2380 VisitBody = VisitBody && getDerived().shouldVisitLambdaBody();

2381 }

2382 }

2383 }

2384

2385 if (VisitBody) {

2386 TRY_TO(TraverseStmt(D->getBody()));

2387

2388

2389 for (auto *Child : D->decls()) {

2391 TRY_TO(TraverseDecl(Child));

2392 }

2393 }

2394 return true;

2395}

2396

2398

2399

2400 ShouldVisitChildren = false;

2401 ReturnValue = TraverseFunctionHelper(D);

2402})

2403

2405

2406

2407 ShouldVisitChildren = false;

2408 ReturnValue = TraverseFunctionHelper(D);

2409})

2410

2412

2413

2414 ShouldVisitChildren = false;

2415 ReturnValue = TraverseFunctionHelper(D);

2416})

2417

2419

2420

2421 ShouldVisitChildren = false;

2422 ReturnValue = TraverseFunctionHelper(D);

2423})

2424

2425

2426

2428

2429

2430 ShouldVisitChildren = false;

2431 ReturnValue = TraverseFunctionHelper(D);

2432})

2433

2435

2436

2437 ShouldVisitChildren = false;

2438 ReturnValue = TraverseFunctionHelper(D);

2439})

2440

2441template

2442bool RecursiveASTVisitor::TraverseVarHelper(VarDecl *D) {

2443 TRY_TO(TraverseDeclaratorHelper(D));

2444

2446 (!D->isCXXForRangeDecl() || getDerived().shouldVisitImplicitCode()))

2447 TRY_TO(TraverseStmt(D->getInit()));

2448 return true;

2449}

2450

2452

2454

2456

2457 TRY_TO(TraverseDeclaratorHelper(D));

2458 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())

2459 TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument()));

2460})

2461

2463 TRY_TO(TraverseVarHelper(D));

2464

2465 if (D->hasDefaultArg() && D->hasUninstantiatedDefaultArg() &&

2466 !D->hasUnparsedDefaultArg())

2467 TRY_TO(TraverseStmt(D->getUninstantiatedDefaultArg()));

2468

2469 if (D->hasDefaultArg() && !D->hasUninstantiatedDefaultArg() &&

2470 !D->hasUnparsedDefaultArg())

2471 TRY_TO(TraverseStmt(D->getDefaultArg()));

2472})

2473

2475

2477 TRY_TO(TraverseTemplateArguments(D->getTemplateArguments()));

2478})

2479

2481

2482

2483

2484

2485

2486

2487

2488

2489

2490

2491

2493 template \

2495 STMT *S, DataRecursionQueue *Queue) { \

2496 bool ShouldVisitChildren = true; \

2498 if (!getDerived().shouldTraversePostOrder()) \

2499 TRY_TO(WalkUpFrom##STMT(S)); \

2500 { CODE; } \

2501 if (ShouldVisitChildren) { \

2502 for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { \

2503 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(SubStmt); \

2504 } \

2505 } \

2506

2507

2508

2509 \

2510 if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { \

2511 TRY_TO(WalkUpFrom##STMT(S)); \

2512 } \

2514 }

2515

2518 for (unsigned I = 0, E = S->getNumInputs(); I < E; ++I) {

2520 }

2521 for (unsigned I = 0, E = S->getNumOutputs(); I < E; ++I) {

2523 }

2524 for (unsigned I = 0, E = S->getNumClobbers(); I < E; ++I) {

2526 }

2527

2528})

2529

2532 {

2533

2534 })

2535

2537 TRY_TO(TraverseDecl(S->getExceptionDecl()));

2538

2539})

2540

2542 for (auto *I : S->decls()) {

2543 TRY_TO(TraverseDecl(I));

2544 }

2545

2546

2547

2548

2549

2550 ShouldVisitChildren = false;

2551})

2552

2553

2554

2577

2579 if (!getDerived().shouldVisitImplicitCode()) {

2580 if (S->getInit())

2585

2586 ShouldVisitChildren = false;

2587 }

2588})

2589

2592 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));

2593})

2594

2598

2600

2603 TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo()));

2604 if (S->hasExplicitTemplateArgs()) {

2605 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),

2606 S->getNumTemplateArgs()));

2607 }

2608})

2609

2612 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));

2613 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),

2614 S->getNumTemplateArgs()));

2615})

2616

2619 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));

2620 if (S->hasExplicitTemplateArgs()) {

2621 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),

2622 S->getNumTemplateArgs()));

2623 }

2624})

2625

2628 TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo()));

2629 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),

2630 S->getNumTemplateArgs()));

2631})

2632

2635 {

2636

2637 })

2638

2640 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2641})

2642

2644 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2645})

2646

2648 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2649})

2650

2652 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2653})

2654

2656 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2657})

2658

2660 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2661})

2662

2664 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2665})

2666

2668 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2669})

2670

2671template

2673 InitListExpr *S, DataRecursionQueue *Queue) {

2674 if (S) {

2675

2676

2677 if (!getDerived().shouldTraversePostOrder())

2678 TRY_TO(WalkUpFromInitListExpr(S));

2679

2680

2683 }

2684

2685 if (!Queue && getDerived().shouldTraversePostOrder())

2686 TRY_TO(WalkUpFromInitListExpr(S));

2687 }

2688 return true;

2689}

2690

2691template

2694 return true;

2695}

2696

2697template

2700 if (!getDerived().shouldTraversePostOrder())

2701 TRY_TO(VisitConceptReference(CR));

2703 TRY_TO(TraverseDeclarationNameInfo(CR->getConceptNameInfo()));

2704 if (CR->hasExplicitTemplateArgs())

2705 TRY_TO(TraverseTemplateArgumentLocsHelper(

2706 CR->getTemplateArgsAsWritten()->getTemplateArgs(),

2707 CR->getTemplateArgsAsWritten()->NumTemplateArgs));

2708 if (getDerived().shouldTraversePostOrder())

2709 TRY_TO(VisitConceptReference(CR));

2710 return true;

2711}

2712

2713

2714

2715

2716

2717

2718

2719

2720

2721template

2723 InitListExpr *S, DataRecursionQueue *Queue) {

2724 if (S->isSemanticForm() && S->isSyntacticForm()) {

2725

2726 TRY_TO(TraverseSynOrSemInitListExpr(S, Queue));

2727 return true;

2728 }

2729 TRY_TO(TraverseSynOrSemInitListExpr(

2730 S->isSemanticForm() ? S->getSyntacticForm() : S, Queue));

2731 if (getDerived().shouldVisitImplicitCode()) {

2732

2733

2734 TRY_TO(TraverseSynOrSemInitListExpr(

2735 S->isSemanticForm() ? S : S->getSemanticForm(), Queue));

2736 }

2737 return true;

2738}

2739

2740

2741

2742

2744 if (S->isExprPredicate())

2745 TRY_TO(TraverseStmt(S->getControllingExpr()));

2746 else

2747 TRY_TO(TraverseTypeLoc(S->getControllingType()->getTypeLoc()));

2748

2750 if (TypeSourceInfo *TSI = Assoc.getTypeSourceInfo())

2751 TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));

2753 }

2754 ShouldVisitChildren = false;

2755})

2756

2757

2758

2762 e = S->semantics_end();

2763 i != e; ++i) {

2764 Expr *sub = *i;

2765 if (OpaqueValueExpr *OVE = dyn_cast(sub))

2766 sub = OVE->getSourceExpr();

2768 }

2769 ShouldVisitChildren = false;

2770})

2771

2773

2774

2775 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));

2776})

2777

2779

2780 TRY_TO(TraverseTypeLoc(S->getAllocatedTypeSourceInfo()->getTypeLoc()));

2781})

2782

2784

2785

2786

2787

2788 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));

2789})

2790

2792

2793

2794 if (S->isArgumentType())

2795 TRY_TO(TraverseTypeLoc(S->getArgumentTypeInfo()->getTypeLoc()));

2796})

2797

2799

2800

2801 if (S->isTypeOperand())

2802 TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc()));

2803})

2804

2807})

2808

2810

2812

2813

2814 if (S->isTypeOperand())

2815 TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc()));

2816})

2817

2819 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)

2820 TRY_TO(TraverseTypeLoc(S->getArg(I)->getTypeLoc()));

2821})

2822

2824 TRY_TO(TraverseTypeLoc(S->getQueriedTypeSourceInfo()->getTypeLoc()));

2825})

2826

2829

2831

2832 TRY_TO(TraverseTypeLoc(S->getWrittenTypeInfo()->getTypeLoc()));

2833})

2834

2836

2837 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));

2838})

2839

2840

2842

2843 for (unsigned I = 0, N = S->capture_size(); I != N; ++I) {

2845 if (C->isExplicit() || getDerived().shouldVisitImplicitCode()) {

2846 TRY_TO(TraverseLambdaCapture(S, C, S->capture_init_begin()[I]));

2847 }

2848 }

2849

2850 if (getDerived().shouldVisitImplicitCode()) {

2851

2852 TRY_TO(TraverseDecl(S->getLambdaClass()));

2853 } else {

2854

2855 TypeLoc TL = S->getCallOperator()->getTypeSourceInfo()->getTypeLoc();

2857

2858 TRY_TO(TraverseTemplateParameterListHelper(S->getTemplateParameterList()));

2859 if (S->hasExplicitParameters()) {

2860

2861 for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I)

2862 TRY_TO(TraverseDecl(Proto.getParam(I)));

2863 }

2864

2865 auto *T = Proto.getTypePtr();

2866 for (const auto &E : T->exceptions())

2867 TRY_TO(TraverseType(E));

2868

2869 if (Expr *NE = T->getNoexceptExpr())

2871

2872 if (S->hasExplicitResultType())

2873 TRY_TO(TraverseTypeLoc(Proto.getReturnLoc()));

2875 const_cast<Expr *>(S->getTrailingRequiresClause().ConstraintExpr));

2876

2878 }

2879 ShouldVisitChildren = false;

2880})

2881

2883

2884 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));

2885})

2886

2887

2888

2892

2893

2894

2901

2903 TRY_TO(TraverseDecl(S->getBlockDecl()));

2904 return true;

2905})

2906

2909 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));

2910})

2913

2915 if (getDerived().shouldVisitImplicitCode())

2916 TRY_TO(TraverseStmt(S->getExpr()));

2917})

2918

2920 if (getDerived().shouldVisitImplicitCode())

2921 TRY_TO(TraverseStmt(S->getExpr()));

2922})

2923

2929

2932 if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo())

2933 TRY_TO(TraverseTypeLoc(ScopeInfo->getTypeLoc()));

2934 if (TypeSourceInfo *DestroyedTypeInfo = S->getDestroyedTypeInfo())

2935 TRY_TO(TraverseTypeLoc(DestroyedTypeInfo->getTypeLoc()));

2936})

2937

2948

2949

2952})

2955

2957 if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo())

2958 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));

2959})

2960

2963

2965 if (TypeSourceInfo *TInfo = S->getClassReceiverTypeInfo())

2966 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));

2967})

2968

2970 if (S->isClassReceiver()) {

2972 QualType Type = IDecl->getASTContext().getObjCInterfaceType(IDecl);

2974 Data.NameLoc = S->getReceiverLocation();

2975 Data.NameEndLoc = Data.NameLoc;

2977 }

2978})

2983

2985 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));

2986})

2987

2992 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));

2993})

3001 for (IntegerLiteral *IL : S->underlying_data_elements()) {

3003 }

3004})

3005

3008 if (S->hasExplicitTemplateArgs()) {

3009 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),

3010 S->getNumTemplateArgs()));

3011 }

3012})

3013

3016 if (S->hasExplicitTemplateArgs()) {

3017 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),

3018 S->getNumTemplateArgs()));

3019 }

3020})

3021

3027

3029 if (getDerived().shouldVisitImplicitCode()) {

3030 TRY_TO(TraverseStmt(S->getOriginalStmt()));

3031 TRY_TO(TraverseDecl(S->getOutlinedFunctionDecl()));

3032 ShouldVisitChildren = false;

3033 }

3034})

3035

3038 if (!getDerived().shouldVisitImplicitCode()) {

3040 S->getDecomposedForm();

3041 TRY_TO(TraverseStmt(const_cast<Expr*>(Decomposed.LHS)));

3042 TRY_TO(TraverseStmt(const_cast<Expr*>(Decomposed.RHS)));

3043 ShouldVisitChildren = false;

3044 }

3045})

3049

3050

3051

3067

3069 if (S->getLifetimeExtendedTemporaryDecl()) {

3070 TRY_TO(TraverseLifetimeExtendedTemporaryDecl(

3071 S->getLifetimeExtendedTemporaryDecl()));

3072 ShouldVisitChildren = false;

3073 }

3074})

3075

3076

3077

3079 if (!getDerived().shouldVisitImplicitCode()) {

3081 ShouldVisitChildren = false;

3082 }

3083})

3085 if (!getDerived().shouldVisitImplicitCode()) {

3087 ShouldVisitChildren = false;

3088 }

3089})

3091 if (!getDerived().shouldVisitImplicitCode()) {

3093 ShouldVisitChildren = false;

3094 }

3095})

3097 if (!getDerived().shouldVisitImplicitCode()) {

3099 ShouldVisitChildren = false;

3100 }

3101})

3103 if (!getDerived().shouldVisitImplicitCode()) {

3105 ShouldVisitChildren = false;

3106 }

3107})

3108

3110 TRY_TO(TraverseConceptReference(S->getConceptReference()));

3111})

3112

3114 TRY_TO(TraverseDecl(S->getBody()));

3115 for (ParmVarDecl *Parm : S->getLocalParameters())

3116 TRY_TO(TraverseDecl(Parm));

3118 TRY_TO(TraverseConceptRequirement(Req));

3119})

3120

3121

3132

3133

3135

3136

3137template

3138bool RecursiveASTVisitor::TraverseOMPExecutableDirective(

3139 OMPExecutableDirective *S) {

3140 for (auto *C : S->clauses()) {

3141 TRY_TO(TraverseOMPClause(C));

3142 }

3143 return true;

3144}

3145

3147 if (!getDerived().shouldVisitImplicitCode()) {

3148

3149 TRY_TO(TraverseStmt(S->getLoopStmt()));

3150 ShouldVisitChildren = false;

3151 }

3152})

3153

3154template

3155bool

3156RecursiveASTVisitor::TraverseOMPLoopDirective(OMPLoopDirective *S) {

3157 return TraverseOMPExecutableDirective(S);

3158}

3159

3161 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3162

3164 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3165

3167 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3168

3170 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3171

3173 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3174

3176 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3177

3179 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3180

3182 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3183

3185 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3186

3188 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3189

3191 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3192

3194 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3195

3197 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3198

3200 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3201

3203 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3204

3206 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3207

3209 TRY_TO(TraverseDeclarationNameInfo(S->getDirectiveName()));

3210 TRY_TO(TraverseOMPExecutableDirective(S));

3211})

3212

3214 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3215

3217 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3218

3220 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3221

3223 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3224

3226 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3227

3229 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3230

3232 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3233

3235 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3236

3238 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3239

3241 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3242

3244 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3245

3247 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3248

3250 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3251

3253 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3254

3256 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3257

3259 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3260

3262 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3263

3265 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3266

3268 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3269

3271 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3272

3274 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3275

3277 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3278

3280 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3281

3283 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3284

3286 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3287

3289 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3290

3292 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3293

3295 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3296

3298 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3299

3301 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3302

3304 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3305

3307 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3308

3310 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3311

3313 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3314

3316 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3317

3319 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3320

3322 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3323

3325 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3326

3328 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3329

3331 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3332

3334 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3335

3337 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3338

3340 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3341

3343 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3344

3346 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3347

3349 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3350

3352 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3353

3355 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3356

3357DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeParallelForSimdDirective,

3358 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3359

3361 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3362

3364 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3365

3367 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3368

3370 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3371

3373 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3374

3376 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3377

3379 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3380

3382 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3383

3385 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3386

3388 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3389

3391 { TRY_TO(TraverseOMPExecutableDirective(S)); })

3392

3393

3394template

3395bool RecursiveASTVisitor::TraverseOMPClause(OMPClause *C) {

3396 if ()

3397 return true;

3398 switch (C->getClauseKind()) {

3399#define GEN_CLANG_CLAUSE_CLASS

3400#define CLAUSE_CLASS(Enum, Str, Class) \

3401 case llvm::omp::Clause::Enum: \

3402 TRY_TO(Visit##Class(static_cast<Class *>(C))); \

3403 break;

3404#define CLAUSE_NO_CLASS(Enum, Str) \

3405 case llvm::omp::Clause::Enum: \

3406 break;

3407#include "llvm/Frontend/OpenMP/OMP.inc"

3408 }

3409 return true;

3410}

3411

3412template

3413bool RecursiveASTVisitor::VisitOMPClauseWithPreInit(

3415 TRY_TO(TraverseStmt(Node->getPreInitStmt()));

3416 return true;

3417}

3418

3419template

3420bool RecursiveASTVisitor::VisitOMPClauseWithPostUpdate(

3422 TRY_TO(VisitOMPClauseWithPreInit(Node));

3423 TRY_TO(TraverseStmt(Node->getPostUpdateExpr()));

3424 return true;

3425}

3426

3427template

3430 TRY_TO(TraverseStmt(C->getAllocator()));

3431 return true;

3432}

3433

3434template

3436 TRY_TO(TraverseStmt(C->getAllocator()));

3437 TRY_TO(VisitOMPClauseList(C));

3438 return true;

3439}

3440

3441template

3443 TRY_TO(VisitOMPClauseWithPreInit(C));

3444 TRY_TO(TraverseStmt(C->getCondition()));

3445 return true;

3446}

3447

3448template

3450 TRY_TO(VisitOMPClauseWithPreInit(C));

3451 TRY_TO(TraverseStmt(C->getCondition()));

3452 return true;

3453}

3454

3455template

3456bool

3458 TRY_TO(VisitOMPClauseWithPreInit(C));

3459 TRY_TO(TraverseStmt(C->getNumThreads()));

3460 return true;

3461}

3462

3463template

3465 TRY_TO(TraverseStmt(C->getAlignment()));

3466 return true;

3467}

3468

3469template

3471 TRY_TO(TraverseStmt(C->getSafelen()));

3472 return true;

3473}

3474

3475template

3477 TRY_TO(TraverseStmt(C->getSimdlen()));

3478 return true;

3479}

3480

3481template

3483 for (Expr *E : C->getSizesRefs())

3484 TRY_TO(TraverseStmt(E));

3485 return true;

3486}

3487

3488template

3491 for (Expr *E : C->getArgsRefs())

3492 TRY_TO(TraverseStmt(E));

3493 return true;

3494}

3495

3496template

3498 return true;

3499}

3500

3501template

3504 TRY_TO(TraverseStmt(C->getFirst()));

3505 TRY_TO(TraverseStmt(C->getCount()));

3506 return true;

3507}

3508

3509template

3511 TRY_TO(TraverseStmt(C->getFactor()));

3512 return true;

3513}

3514

3515template

3516bool

3518 TRY_TO(TraverseStmt(C->getNumForLoops()));

3519 return true;

3520}

3521

3522template

3524 return true;

3525}

3526

3527template

3530 return true;

3531}

3532

3533template

3535 return true;

3536}

3537

3538template

3541 return true;

3542}

3543

3544template

3547 return true;

3548}

3549

3550template

3553 return true;

3554}

3555

3556template

3559 return true;

3560}

3561

3562template

3565 return true;

3566}

3567

3568template

3570 return true;

3571}

3572

3573template

3575 return true;

3576}

3577

3578template

3580 return true;

3581}

3582

3583template

3585 TRY_TO(TraverseStmt(C->getMessageString()));

3586 return true;

3587}

3588

3589template

3590bool

3592 TRY_TO(VisitOMPClauseWithPreInit(C));

3593 TRY_TO(TraverseStmt(C->getChunkSize()));

3594 return true;

3595}

3596

3597template

3599 TRY_TO(TraverseStmt(C->getNumForLoops()));

3600 return true;

3601}

3602

3603template

3605 TRY_TO(TraverseStmt(C->getCondition()));

3606 return true;

3607}

3608

3609template

3611 return true;

3612}

3613

3614template

3615bool

3617 return true;

3618}

3619

3620template

3622 return true;

3623}

3624

3625template

3627 return true;

3628}

3629

3630template

3632 return true;

3633}

3634

3635template

3637 return true;

3638}

3639

3640template

3642 return true;

3643}

3644

3645template

3647 return true;

3648}

3649

3650template

3652 return true;

3653}

3654

3655template

3657 return true;

3658}

3659

3660template

3662 return true;

3663}

3664

3665template

3667 return true;

3668}

3669

3670template

3672 return true;

3673}

3674

3675template

3677 return true;

3678}

3679

3680template

3683 return true;

3684}

3685

3686template

3689 return true;

3690}

3691

3692template

3695 return true;

3696}

3697

3698template

3700 return true;

3701}

3702

3703template

3705 return true;

3706}

3707

3708template

3710 return true;

3711}

3712

3713template

3715 return true;

3716}

3717

3718template

3720 return true;

3721}

3722

3723template

3725 return true;

3726}

3727

3728template

3730 return true;

3731}

3732

3733template

3735 TRY_TO(VisitOMPClauseList(C));

3736 return true;

3737}

3738

3739template

3741 TRY_TO(TraverseStmt(C->getInteropVar()));

3742 return true;

3743}

3744

3745template

3747 TRY_TO(TraverseStmt(C->getInteropVar()));

3748 return true;

3749}

3750

3751template

3754 TRY_TO(VisitOMPClauseWithPreInit(C));

3755 TRY_TO(TraverseStmt(C->getCondition()));

3756 return true;

3757}

3758

3759template

3762 TRY_TO(VisitOMPClauseWithPreInit(C));

3763 TRY_TO(TraverseStmt(C->getCondition()));

3764 return true;

3765}

3766

3767template

3768template

3769bool RecursiveASTVisitor::VisitOMPClauseList(T *Node) {

3770 for (auto *E : Node->varlist()) {

3771 TRY_TO(TraverseStmt(E));

3772 }

3773 return true;

3774}

3775

3776template

3779 TRY_TO(VisitOMPClauseList(C));

3780 return true;

3781}

3782

3783template

3786 TRY_TO(VisitOMPClauseList(C));

3787 return true;

3788}

3789

3790template

3792 TRY_TO(VisitOMPClauseList(C));

3793 for (auto *E : C->private_copies()) {

3794 TRY_TO(TraverseStmt(E));

3795 }

3796 return true;

3797}

3798

3799template

3802 TRY_TO(VisitOMPClauseList(C));

3803 TRY_TO(VisitOMPClauseWithPreInit(C));

3804 for (auto *E : C->private_copies()) {

3805 TRY_TO(TraverseStmt(E));

3806 }

3807 for (auto *E : C->inits()) {

3808 TRY_TO(TraverseStmt(E));

3809 }

3810 return true;

3811}

3812

3813template

3816 TRY_TO(VisitOMPClauseList(C));

3817 TRY_TO(VisitOMPClauseWithPostUpdate(C));

3818 for (auto *E : C->private_copies()) {

3819 TRY_TO(TraverseStmt(E));

3820 }

3821 for (auto *E : C->source_exprs()) {

3822 TRY_TO(TraverseStmt(E));

3823 }

3824 for (auto *E : C->destination_exprs()) {

3825 TRY_TO(TraverseStmt(E));

3826 }

3827 for (auto *E : C->assignment_ops()) {

3828 TRY_TO(TraverseStmt(E));

3829 }

3830 return true;

3831}

3832

3833template

3835 TRY_TO(VisitOMPClauseList(C));

3836 return true;

3837}

3838

3839template

3841 TRY_TO(TraverseStmt(C->getStep()));

3842 TRY_TO(TraverseStmt(C->getCalcStep()));

3843 TRY_TO(VisitOMPClauseList(C));

3844 TRY_TO(VisitOMPClauseWithPostUpdate(C));

3845 for (auto *E : C->privates()) {

3846 TRY_TO(TraverseStmt(E));

3847 }

3848 for (auto *E : C->inits()) {

3849 TRY_TO(TraverseStmt(E));

3850 }

3851 for (auto *E : C->updates()) {

3852 TRY_TO(TraverseStmt(E));

3853 }

3854 for (auto *E : C->finals()) {

3855 TRY_TO(TraverseStmt(E));

3856 }

3857 return true;

3858}

3859

3860template

3862 TRY_TO(TraverseStmt(C->getAlignment()));

3863 TRY_TO(VisitOMPClauseList(C));

3864 return true;

3865}

3866

3867template

3869 TRY_TO(VisitOMPClauseList(C));

3870 for (auto *E : C->source_exprs()) {

3871 TRY_TO(TraverseStmt(E));

3872 }

3873 for (auto *E : C->destination_exprs()) {

3874 TRY_TO(TraverseStmt(E));

3875 }

3876 for (auto *E : C->assignment_ops()) {

3877 TRY_TO(TraverseStmt(E));

3878 }

3879 return true;

3880}

3881

3882template

3885 TRY_TO(VisitOMPClauseList(C));

3886 for (auto *E : C->source_exprs()) {

3887 TRY_TO(TraverseStmt(E));

3888 }

3889 for (auto *E : C->destination_exprs()) {

3890 TRY_TO(TraverseStmt(E));

3891 }

3892 for (auto *E : C->assignment_ops()) {

3893 TRY_TO(TraverseStmt(E));

3894 }

3895 return true;

3896}

3897

3898template

3899bool

3902 TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));

3903 TRY_TO(VisitOMPClauseList(C));

3904 TRY_TO(VisitOMPClauseWithPostUpdate(C));

3905 for (auto *E : C->privates()) {

3906 TRY_TO(TraverseStmt(E));

3907 }

3908 for (auto *E : C->lhs_exprs()) {

3909 TRY_TO(TraverseStmt(E));

3910 }

3911 for (auto *E : C->rhs_exprs()) {

3912 TRY_TO(TraverseStmt(E));

3913 }

3914 for (auto *E : C->reduction_ops()) {

3915 TRY_TO(TraverseStmt(E));

3916 }

3917 if (C->getModifier() == OMPC_REDUCTION_inscan) {

3918 for (auto *E : C->copy_ops()) {

3919 TRY_TO(TraverseStmt(E));

3920 }

3921 for (auto *E : C->copy_array_temps()) {

3922 TRY_TO(TraverseStmt(E));

3923 }

3924 for (auto *E : C->copy_array_elems()) {

3925 TRY_TO(TraverseStmt(E));

3926 }

3927 }

3928 return true;

3929}

3930

3931template

3935 TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));

3936 TRY_TO(VisitOMPClauseList(C));

3937 TRY_TO(VisitOMPClauseWithPostUpdate(C));

3938 for (auto *E : C->privates()) {

3939 TRY_TO(TraverseStmt(E));

3940 }

3941 for (auto *E : C->lhs_exprs()) {

3942 TRY_TO(TraverseStmt(E));

3943 }

3944 for (auto *E : C->rhs_exprs()) {

3945 TRY_TO(TraverseStmt(E));

3946 }

3947 for (auto *E : C->reduction_ops()) {

3948 TRY_TO(TraverseStmt(E));

3949 }

3950 return true;

3951}

3952

3953template

3957 TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));

3958 TRY_TO(VisitOMPClauseList(C));

3959 TRY_TO(VisitOMPClauseWithPostUpdate(C));

3960 for (auto *E : C->privates()) {

3961 TRY_TO(TraverseStmt(E));

3962 }

3963 for (auto *E : C->lhs_exprs()) {

3964 TRY_TO(TraverseStmt(E));

3965 }

3966 for (auto *E : C->rhs_exprs()) {

3967 TRY_TO(TraverseStmt(E));

3968 }

3969 for (auto *E : C->reduction_ops()) {

3970 TRY_TO(TraverseStmt(E));

3971 }

3972 for (auto *E : C->taskgroup_descriptors())

3973 TRY_TO(TraverseStmt(E));

3974 return true;

3975}

3976

3977template

3979 TRY_TO(VisitOMPClauseList(C));

3980 return true;

3981}

3982

3983template

3985 TRY_TO(TraverseStmt(C->getDepobj()));

3986 return true;

3987}

3988

3989template

3991 TRY_TO(VisitOMPClauseList(C));

3992 return true;

3993}

3994

3995template

3997 TRY_TO(VisitOMPClauseWithPreInit(C));

3998 TRY_TO(TraverseStmt(C->getDevice()));

3999 return true;

4000}

4001

4002template

4004 TRY_TO(VisitOMPClauseList(C));

4005 return true;

4006}

4007

4008template

4011 TRY_TO(VisitOMPClauseList(C));

4012 TRY_TO(VisitOMPClauseWithPreInit(C));

4013 return true;

4014}

4015

4016template

4019 TRY_TO(VisitOMPClauseList(C));

4020 TRY_TO(VisitOMPClauseWithPreInit(C));

4021 return true;

4022}

4023

4024template

4027 TRY_TO(VisitOMPClauseWithPreInit(C));

4028 TRY_TO(TraverseStmt(C->getPriority()));

4029 return true;

4030}

4031

4032template

4035 TRY_TO(VisitOMPClauseWithPreInit(C));

4036 TRY_TO(TraverseStmt(C->getGrainsize()));

4037 return true;

4038}

4039

4040template

4043 TRY_TO(VisitOMPClauseWithPreInit(C));

4044 TRY_TO(TraverseStmt(C->getNumTasks()));

4045 return true;

4046}

4047

4048template

4050 TRY_TO(TraverseStmt(C->getHint()));

4051 return true;

4052}

4053

4054template

4057 TRY_TO(VisitOMPClauseWithPreInit(C));

4058 TRY_TO(TraverseStmt(C->getChunkSize()));

4059 return true;

4060}

4061

4062template

4063bool

4065 return true;

4066}

4067

4068template

4070 TRY_TO(VisitOMPClauseList(C));

4071 return true;

4072}

4073

4074template

4076 TRY_TO(VisitOMPClauseList(C));

4077 return true;

4078}

4079

4080template

4083 TRY_TO(VisitOMPClauseList(C));

4084 return true;

4085}

4086

4087template

4090 TRY_TO(VisitOMPClauseList(C));

4091 return true;

4092}

4093

4094template

4097 TRY_TO(VisitOMPClauseList(C));

4098 return true;

4099}

4100

4101template

4104 TRY_TO(VisitOMPClauseList(C));

4105 return true;

4106}

4107

4108template

4111 TRY_TO(VisitOMPClauseList(C));

4112 for (auto *E : C->private_refs()) {

4113 TRY_TO(TraverseStmt(E));

4114 }

4115 return true;

4116}

4117

4118template

4120 return true;

4121}

4122

4123template

4125 TRY_TO(TraverseStmt(C->getEventHandler()));

4126 return true;

4127}

4128

4129template

4132 for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {

4134 TRY_TO(TraverseStmt(Data.Allocator));

4135 TRY_TO(TraverseStmt(Data.AllocatorTraits));

4136 }

4137 return true;

4138}

4139

4140template

4143 TRY_TO(TraverseStmt(C->getModifier()));

4144 for (Expr *E : C->varlist())

4145 TRY_TO(TraverseStmt(E));

4146 return true;

4147}

4148

4149template

4151 TRY_TO(VisitOMPClauseWithPreInit(C));

4152 TRY_TO(TraverseStmt(C->getThreadID()));

4153 return true;

4154}

4155

4156template

4158 return true;

4159}

4160

4161template

4164 TRY_TO(VisitOMPClauseWithPreInit(C));

4165 TRY_TO(TraverseStmt(C->getSize()));

4166 return true;

4167}

4168

4169template

4172 TRY_TO(VisitOMPClauseWithPreInit(C));

4173 TRY_TO(TraverseStmt(C->getSize()));

4174 return true;

4175}

4176

4177template

4180 TRY_TO(VisitOMPClauseList(C));

4181 return true;

4182}

4183

4184template

4187 return true;

4188}

4189

4190template

4192 return true;

4193}

4194

4195template

4196bool RecursiveASTVisitor::TraverseOpenACCConstructStmt(

4198 TRY_TO(VisitOpenACCClauseList(C->clauses()));

4199 return true;

4200}

4201

4202template

4203bool RecursiveASTVisitor::TraverseOpenACCAssociatedStmtConstruct(

4205 TRY_TO(TraverseOpenACCConstructStmt(S));

4206 TRY_TO(TraverseStmt(S->getAssociatedStmt()));

4207 return true;

4208}

4209

4210template

4211bool RecursiveASTVisitor::VisitOpenACCClause(const OpenACCClause *C) {

4212 for (const Stmt *Child : C->children())

4213 TRY_TO(TraverseStmt(const_cast<Stmt *>(Child)));

4214 return true;

4215}

4216

4217template

4218bool RecursiveASTVisitor::VisitOpenACCClauseList(

4220

4221 for (const auto *C : Clauses)

4222 TRY_TO(VisitOpenACCClause(C));

4223 return true;

4224}

4225

4227 { TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })

4229 { TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })

4231 { TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })

4233 { TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })

4235 { TRY_TO(VisitOpenACCClauseList(S->clauses())); })

4237 { TRY_TO(VisitOpenACCClauseList(S->clauses())); })

4239 { TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })

4241 if (S->hasDevNumExpr())

4242 TRY_TO(TraverseStmt(S->getDevNumExpr()));

4243 for (auto *E : S->getQueueIdExprs())

4244 TRY_TO(TraverseStmt(E));

4245 TRY_TO(VisitOpenACCClauseList(S->clauses()));

4246})

4248 { TRY_TO(VisitOpenACCClauseList(S->clauses())); })

4250 { TRY_TO(VisitOpenACCClauseList(S->clauses())); })

4252 { TRY_TO(VisitOpenACCClauseList(S->clauses())); })

4254 { TRY_TO(VisitOpenACCClauseList(S->clauses())); })

4256 { TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })

4258 for (auto *E : S->getVarList())

4259 TRY_TO(TraverseStmt(E));

4260})

4261

4262

4264

4265

4266

4267

4268

4269

4270

4271

4272

4273

4274

4275

4276

4277

4278

4279

4280

4281

4283#undef TRAVERSE_STMT

4285

4287

4288}

4289

4290#endif