StmtPrinter.cpp Source File (original) (raw)

47#include "llvm/ADT/ArrayRef.h"

48#include "llvm/ADT/SmallVector.h"

49#include "llvm/ADT/StringExtras.h"

50#include "llvm/ADT/StringRef.h"

51#include "llvm/Support/Compiler.h"

52#include "llvm/Support/ErrorHandling.h"

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

54#include

55#include

56#include

58using namespace clang;

64namespace {

66 class StmtPrinter : public StmtVisitor {

67 raw_ostream &OS;

68 unsigned IndentLevel;

71 std::string NL;

74 public:

75 StmtPrinter(raw_ostream &os, PrinterHelper *helper,

76 const PrintingPolicy &Policy, unsigned Indentation = 0,

77 StringRef NL = "\n", const ASTContext *Context = nullptr)

78 : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy),

79 NL(NL), Context(Context) {}

81 void PrintStmt(Stmt *S) { PrintStmt(S, Policy.Indentation); }

83 void PrintStmt(Stmt *S, int SubIndent) {

84 IndentLevel += SubIndent;

85 if (isa_and_nonnull(S)) {

87 Indent();

89 OS << ";" << NL;

90 } else if (S) {

92 } else {

93 Indent() << "<<>>" << NL;

94 }

95 IndentLevel -= SubIndent;

96 }

98 void PrintInitStmt(Stmt *S, unsigned PrefixWidth) {

100 IndentLevel += (PrefixWidth + 1) / 2;

101 if (auto *DS = dyn_cast(S))

102 PrintRawDeclStmt(DS);

103 else

104 PrintExpr(cast(S));

105 OS << "; ";

106 IndentLevel -= (PrefixWidth + 1) / 2;

107 }

108

109 void PrintControlledStmt(Stmt *S) {

110 if (auto *CS = dyn_cast(S)) {

111 OS << " ";

112 PrintRawCompoundStmt(CS);

113 OS << NL;

114 } else {

115 OS << NL;

116 PrintStmt(S);

117 }

118 }

119

121 void PrintRawDecl(Decl *D);

122 void PrintRawDeclStmt(const DeclStmt *S);

123 void PrintRawIfStmt(IfStmt *If);

124 void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);

129 bool ForceNoStmt = false);

133

134 void PrintExpr(Expr *E) {

135 if (E)

137 else

138 OS << "";

139 }

140

141 raw_ostream &Indent(int Delta = 0) {

142 for (int i = 0, e = IndentLevel+Delta; i < e; ++i)

143 OS << " ";

144 return OS;

145 }

146

149 return;

151 }

152

153 void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {

154 Indent() << "<>" << NL;

155 }

156

157 void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {

158 OS << "<>";

159 }

160

162

163#define ABSTRACT_STMT(CLASS)

164#define STMT(CLASS, PARENT) \

165 void Visit##CLASS(CLASS *Node);

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

167 };

168

169}

170

171

172

173

174

175

176

178 assert(Node && "Compound statement cannot be null");

179 OS << "{" << NL;

180 PrintFPPragmas(Node);

181 for (auto *I : Node->body())

182 PrintStmt(I);

183

184 Indent() << "}";

185}

186

187void StmtPrinter::PrintFPPragmas(CompoundStmt *S) {

188 if (!S->hasStoredFPFeatures())

189 return;

191 bool FEnvAccess = false;

192 if (FPO.hasAllowFEnvAccessOverride()) {

193 FEnvAccess = FPO.getAllowFEnvAccessOverride();

194 Indent() << "#pragma STDC FENV_ACCESS " << (FEnvAccess ? "ON" : "OFF")

195 << NL;

196 }

197 if (FPO.hasSpecifiedExceptionModeOverride()) {

199 FPO.getSpecifiedExceptionModeOverride();

200 if (!FEnvAccess || EM != LangOptions::FPE_Strict) {

201 Indent() << "#pragma clang fp exceptions(";

202 switch (FPO.getSpecifiedExceptionModeOverride()) {

203 default:

204 break;

205 case LangOptions::FPE_Ignore:

206 OS << "ignore";

207 break;

208 case LangOptions::FPE_MayTrap:

209 OS << "maytrap";

210 break;

211 case LangOptions::FPE_Strict:

212 OS << "strict";

213 break;

214 }

215 OS << ")\n";

216 }

217 }

218 if (FPO.hasConstRoundingModeOverride()) {

220 Indent() << "#pragma STDC FENV_ROUND ";

221 switch (RM) {

222 case llvm::RoundingMode::TowardZero:

223 OS << "FE_TOWARDZERO";

224 break;

225 case llvm::RoundingMode::NearestTiesToEven:

226 OS << "FE_TONEAREST";

227 break;

228 case llvm::RoundingMode::TowardPositive:

229 OS << "FE_UPWARD";

230 break;

231 case llvm::RoundingMode::TowardNegative:

232 OS << "FE_DOWNWARD";

233 break;

234 case llvm::RoundingMode::NearestTiesToAway:

235 OS << "FE_TONEARESTFROMZERO";

236 break;

237 case llvm::RoundingMode::Dynamic:

238 OS << "FE_DYNAMIC";

239 break;

240 default:

241 llvm_unreachable("Invalid rounding mode");

242 }

243 OS << NL;

244 }

245}

246

247void StmtPrinter::PrintRawDecl(Decl *D) {

248 D->print(OS, Policy, IndentLevel);

249}

250

251void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) {

253 Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel);

254}

255

256void StmtPrinter::VisitNullStmt(NullStmt *Node) {

257 Indent() << ";" << NL;

258}

259

260void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {

261 Indent();

262 PrintRawDeclStmt(Node);

263 OS << ";" << NL;

264}

265

267 Indent();

268 PrintRawCompoundStmt(Node);

269 OS << "" << NL;

270}

271

272void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {

273 Indent(-1) << "case ";

274 PrintExpr(Node->getLHS());

275 if (Node->getRHS()) {

276 OS << " ... ";

277 PrintExpr(Node->getRHS());

278 }

279 OS << ":" << NL;

280

281 PrintStmt(Node->getSubStmt(), 0);

282}

283

285 Indent(-1) << "default:" << NL;

286 PrintStmt(Node->getSubStmt(), 0);

287}

288

289void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {

290 Indent(-1) << Node->getName() << ":" << NL;

291 PrintStmt(Node->getSubStmt(), 0);

292}

293

296 for (const auto *Attr : Attrs) {

298 if (Attr != Attrs.back())

299 OS << ' ';

300 }

301

302 PrintStmt(Node->getSubStmt(), 0);

303}

304

305void StmtPrinter::PrintRawIfStmt(IfStmt *If) {

306 if (If->isConsteval()) {

307 OS << "if ";

308 if (If->isNegatedConsteval())

309 OS << "!";

310 OS << "consteval";

311 OS << NL;

312 PrintStmt(If->getThen());

313 if (Stmt *Else = If->getElse()) {

314 Indent();

315 OS << "else";

316 PrintStmt(Else);

317 OS << NL;

318 }

319 return;

320 }

321

322 OS << "if (";

323 if (If->getInit())

324 PrintInitStmt(If->getInit(), 4);

325 if (const DeclStmt *DS = If->getConditionVariableDeclStmt())

326 PrintRawDeclStmt(DS);

327 else

328 PrintExpr(If->getCond());

329 OS << ')';

330

331 if (auto *CS = dyn_cast(If->getThen())) {

332 OS << ' ';

333 PrintRawCompoundStmt(CS);

334 OS << (If->getElse() ? " " : NL);

335 } else {

336 OS << NL;

337 PrintStmt(If->getThen());

338 if (If->getElse()) Indent();

339 }

340

341 if (Stmt *Else = If->getElse()) {

342 OS << "else";

343

344 if (auto *CS = dyn_cast(Else)) {

345 OS << ' ';

346 PrintRawCompoundStmt(CS);

347 OS << NL;

348 } else if (auto *ElseIf = dyn_cast(Else)) {

349 OS << ' ';

350 PrintRawIfStmt(ElseIf);

351 } else {

352 OS << NL;

353 PrintStmt(If->getElse());

354 }

355 }

356}

357

358void StmtPrinter::VisitIfStmt(IfStmt *If) {

359 Indent();

360 PrintRawIfStmt(If);

361}

362

364 Indent() << "switch (";

365 if (Node->getInit())

366 PrintInitStmt(Node->getInit(), 8);

367 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())

368 PrintRawDeclStmt(DS);

369 else

370 PrintExpr(Node->getCond());

371 OS << ")";

372 PrintControlledStmt(Node->getBody());

373}

374

375void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {

376 Indent() << "while (";

377 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())

378 PrintRawDeclStmt(DS);

379 else

380 PrintExpr(Node->getCond());

381 OS << ")" << NL;

382 PrintStmt(Node->getBody());

383}

384

385void StmtPrinter::VisitDoStmt(DoStmt *Node) {

386 Indent() << "do ";

387 if (auto *CS = dyn_cast(Node->getBody())) {

388 PrintRawCompoundStmt(CS);

389 OS << " ";

390 } else {

391 OS << NL;

392 PrintStmt(Node->getBody());

393 Indent();

394 }

395

396 OS << "while (";

397 PrintExpr(Node->getCond());

398 OS << ");" << NL;

399}

400

401void StmtPrinter::VisitForStmt(ForStmt *Node) {

402 Indent() << "for (";

403 if (Node->getInit())

404 PrintInitStmt(Node->getInit(), 5);

405 else

406 OS << (Node->getCond() ? "; " : ";");

407 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())

408 PrintRawDeclStmt(DS);

409 else if (Node->getCond())

410 PrintExpr(Node->getCond());

411 OS << ";";

412 if (Node->getInc()) {

413 OS << " ";

414 PrintExpr(Node->getInc());

415 }

416 OS << ")";

417 PrintControlledStmt(Node->getBody());

418}

419

421 Indent() << "for (";

422 if (auto *DS = dyn_cast(Node->getElement()))

423 PrintRawDeclStmt(DS);

424 else

425 PrintExpr(cast(Node->getElement()));

426 OS << " in ";

427 PrintExpr(Node->getCollection());

428 OS << ")";

429 PrintControlledStmt(Node->getBody());

430}

431

433 Indent() << "for (";

434 if (Node->getInit())

435 PrintInitStmt(Node->getInit(), 5);

437 SubPolicy.SuppressInitializers = true;

438 Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel);

439 OS << " : ";

440 PrintExpr(Node->getRangeInit());

441 OS << ")";

442 PrintControlledStmt(Node->getBody());

443}

444

446 Indent();

447 if (Node->isIfExists())

448 OS << "__if_exists (";

449 else

450 OS << "__if_not_exists (";

451

453 = Node->getQualifierLoc().getNestedNameSpecifier())

455

456 OS << Node->getNameInfo() << ") ";

457

458 PrintRawCompoundStmt(Node->getSubStmt());

459}

460

461void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {

462 Indent() << "goto " << Node->getLabel()->getName() << ";";

464}

465

467 Indent() << "goto *";

468 PrintExpr(Node->getTarget());

469 OS << ";";

471}

472

474 Indent() << "continue;";

476}

477

478void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {

479 Indent() << "break;";

481}

482

484 Indent() << "return";

485 if (Node->getRetValue()) {

486 OS << " ";

487 PrintExpr(Node->getRetValue());

488 }

489 OS << ";";

491}

492

494 Indent() << "asm ";

495

496 if (Node->isVolatile())

497 OS << "volatile ";

498

499 if (Node->isAsmGoto())

500 OS << "goto ";

501

502 OS << "(";

503 VisitStringLiteral(Node->getAsmString());

504

505

506 if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||

507 Node->getNumClobbers() != 0 || Node->getNumLabels() != 0)

508 OS << " : ";

509

510 for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {

511 if (i != 0)

512 OS << ", ";

513

514 if ( Node ->getOutputName(i).empty()) {

515 OS << '[';

516 OS << Node->getOutputName(i);

517 OS << "] ";

518 }

519

520 VisitStringLiteral(Node->getOutputConstraintLiteral(i));

521 OS << " (";

522 Visit(Node->getOutputExpr(i));

523 OS << ")";

524 }

525

526

527 if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0 ||

528 Node->getNumLabels() != 0)

529 OS << " : ";

530

531 for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {

532 if (i != 0)

533 OS << ", ";

534

535 if ( Node ->getInputName(i).empty()) {

536 OS << '[';

537 OS << Node->getInputName(i);

538 OS << "] ";

539 }

540

541 VisitStringLiteral(Node->getInputConstraintLiteral(i));

542 OS << " (";

543 Visit(Node->getInputExpr(i));

544 OS << ")";

545 }

546

547

548 if (Node->getNumClobbers() != 0 || Node->getNumLabels())

549 OS << " : ";

550

551 for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {

552 if (i != 0)

553 OS << ", ";

554

555 VisitStringLiteral(Node->getClobberStringLiteral(i));

556 }

557

558

559 if (Node->getNumLabels() != 0)

560 OS << " : ";

561

562 for (unsigned i = 0, e = Node->getNumLabels(); i != e; ++i) {

563 if (i != 0)

564 OS << ", ";

565 OS << Node->getLabelName(i);

566 }

567

568 OS << ");";

570}

571

572void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {

573

574 Indent() << "__asm ";

575 if (Node->hasBraces())

576 OS << "{" << NL;

577 OS << Node->getAsmString() << NL;

578 if (Node->hasBraces())

579 Indent() << "}" << NL;

580}

581

583 PrintStmt(Node->getCapturedDecl()->getBody());

584}

585

587 PrintStmt(Node->getOutlinedFunctionDecl()->getBody());

588}

589

591 Indent() << "@try";

592 if (auto *TS = dyn_cast(Node->getTryBody())) {

593 PrintRawCompoundStmt(TS);

594 OS << NL;

595 }

596

598 Indent() << "@catch(";

599 if (Decl *DS = catchStmt->getCatchParamDecl())

600 PrintRawDecl(DS);

601 OS << ")";

602 if (auto *CS = dyn_cast(catchStmt->getCatchBody())) {

603 PrintRawCompoundStmt(CS);

604 OS << NL;

605 }

606 }

607

609 Indent() << "@finally";

610 if (auto *CS = dyn_cast(FS->getFinallyBody())) {

611 PrintRawCompoundStmt(CS);

612 OS << NL;

613 }

614 }

615}

616

618}

619

621 Indent() << "@catch (...) { /* todo */ } " << NL;

622}

623

625 Indent() << "@throw";

626 if (Node->getThrowExpr()) {

627 OS << " ";

628 PrintExpr(Node->getThrowExpr());

629 }

630 OS << ";" << NL;

631}

632

633void StmtPrinter::VisitObjCAvailabilityCheckExpr(

635 OS << "@available(...)";

636}

637

639 Indent() << "@synchronized (";

640 PrintExpr(Node->getSynchExpr());

641 OS << ")";

642 PrintRawCompoundStmt(Node->getSynchBody());

643 OS << NL;

644}

645

647 Indent() << "@autoreleasepool";

648 PrintRawCompoundStmt(cast(Node->getSubStmt()));

649 OS << NL;

650}

651

653 OS << "catch (";

654 if (Decl *ExDecl = Node->getExceptionDecl())

655 PrintRawDecl(ExDecl);

656 else

657 OS << "...";

658 OS << ") ";

659 PrintRawCompoundStmt(cast(Node->getHandlerBlock()));

660}

661

663 Indent();

664 PrintRawCXXCatchStmt(Node);

665 OS << NL;

666}

667

669 Indent() << "try ";

670 PrintRawCompoundStmt(Node->getTryBlock());

671 for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {

672 OS << " ";

673 PrintRawCXXCatchStmt(Node->getHandler(i));

674 }

675 OS << NL;

676}

677

679 Indent() << (Node->getIsCXXTry() ? "try " : "__try ");

680 PrintRawCompoundStmt(Node->getTryBlock());

683 if(E)

684 PrintRawSEHExceptHandler(E);

685 else {

686 assert(F && "Must have a finally block...");

687 PrintRawSEHFinallyStmt(F);

688 }

689 OS << NL;

690}

691

693 OS << "__finally ";

694 PrintRawCompoundStmt(Node->getBlock());

695 OS << NL;

696}

697

699 OS << "__except (";

700 VisitExpr(Node->getFilterExpr());

701 OS << ")" << NL;

702 PrintRawCompoundStmt(Node->getBlock());

703 OS << NL;

704}

705

707 Indent();

708 PrintRawSEHExceptHandler(Node);

709 OS << NL;

710}

711

713 Indent();

714 PrintRawSEHFinallyStmt(Node);

715 OS << NL;

716}

717

719 Indent() << "__leave;";

721}

722

723

724

725

726

728 PrintStmt(Node->getLoopStmt());

729}

730

732 bool ForceNoStmt) {

735 for (auto *Clause : Clauses)

736 if (Clause && !Clause->isImplicit()) {

737 OS << ' ';

738 Printer.Visit(Clause);

739 }

740 OS << NL;

741 if (!ForceNoStmt && S->hasAssociatedStmt())

742 PrintStmt(S->getRawStmt());

743}

744

746 Indent() << "#pragma omp metadirective";

747 PrintOMPExecutableDirective(Node);

748}

749

751 Indent() << "#pragma omp parallel";

752 PrintOMPExecutableDirective(Node);

753}

754

756 Indent() << "#pragma omp simd";

757 PrintOMPExecutableDirective(Node);

758}

759

761 Indent() << "#pragma omp tile";

762 PrintOMPExecutableDirective(Node);

763}

764

766 Indent() << "#pragma omp unroll";

767 PrintOMPExecutableDirective(Node);

768}

769

771 Indent() << "#pragma omp reverse";

772 PrintOMPExecutableDirective(Node);

773}

774

776 Indent() << "#pragma omp interchange";

777 PrintOMPExecutableDirective(Node);

778}

779

781 Indent() << "#pragma omp for";

782 PrintOMPExecutableDirective(Node);

783}

784

786 Indent() << "#pragma omp for simd";

787 PrintOMPExecutableDirective(Node);

788}

789

791 Indent() << "#pragma omp sections";

792 PrintOMPExecutableDirective(Node);

793}

794

796 Indent() << "#pragma omp section";

797 PrintOMPExecutableDirective(Node);

798}

799

801 Indent() << "#pragma omp scope";

802 PrintOMPExecutableDirective(Node);

803}

804

806 Indent() << "#pragma omp single";

807 PrintOMPExecutableDirective(Node);

808}

809

811 Indent() << "#pragma omp master";

812 PrintOMPExecutableDirective(Node);

813}

814

816 Indent() << "#pragma omp critical";

817 if (Node->getDirectiveName().getName()) {

818 OS << " (";

819 Node->getDirectiveName().printName(OS, Policy);

820 OS << ")";

821 }

822 PrintOMPExecutableDirective(Node);

823}

824

826 Indent() << "#pragma omp parallel for";

827 PrintOMPExecutableDirective(Node);

828}

829

830void StmtPrinter::VisitOMPParallelForSimdDirective(

832 Indent() << "#pragma omp parallel for simd";

833 PrintOMPExecutableDirective(Node);

834}

835

836void StmtPrinter::VisitOMPParallelMasterDirective(

838 Indent() << "#pragma omp parallel master";

839 PrintOMPExecutableDirective(Node);

840}

841

842void StmtPrinter::VisitOMPParallelMaskedDirective(

844 Indent() << "#pragma omp parallel masked";

845 PrintOMPExecutableDirective(Node);

846}

847

848void StmtPrinter::VisitOMPParallelSectionsDirective(

850 Indent() << "#pragma omp parallel sections";

851 PrintOMPExecutableDirective(Node);

852}

853

855 Indent() << "#pragma omp task";

856 PrintOMPExecutableDirective(Node);

857}

858

860 Indent() << "#pragma omp taskyield";

861 PrintOMPExecutableDirective(Node);

862}

863

865 Indent() << "#pragma omp barrier";

866 PrintOMPExecutableDirective(Node);

867}

868

870 Indent() << "#pragma omp taskwait";

871 PrintOMPExecutableDirective(Node);

872}

873

875 Indent() << "#pragma omp assume";

876 PrintOMPExecutableDirective(Node);

877}

878

880 Indent() << "#pragma omp error";

881 PrintOMPExecutableDirective(Node);

882}

883

885 Indent() << "#pragma omp taskgroup";

886 PrintOMPExecutableDirective(Node);

887}

888

890 Indent() << "#pragma omp flush";

891 PrintOMPExecutableDirective(Node);

892}

893

895 Indent() << "#pragma omp depobj";

896 PrintOMPExecutableDirective(Node);

897}

898

900 Indent() << "#pragma omp scan";

901 PrintOMPExecutableDirective(Node);

902}

903

905 Indent() << "#pragma omp ordered";

907}

908

910 Indent() << "#pragma omp atomic";

911 PrintOMPExecutableDirective(Node);

912}

913

915 Indent() << "#pragma omp target";

916 PrintOMPExecutableDirective(Node);

917}

918

920 Indent() << "#pragma omp target data";

921 PrintOMPExecutableDirective(Node);

922}

923

924void StmtPrinter::VisitOMPTargetEnterDataDirective(

926 Indent() << "#pragma omp target enter data";

927 PrintOMPExecutableDirective(Node, true);

928}

929

930void StmtPrinter::VisitOMPTargetExitDataDirective(

932 Indent() << "#pragma omp target exit data";

933 PrintOMPExecutableDirective(Node, true);

934}

935

936void StmtPrinter::VisitOMPTargetParallelDirective(

938 Indent() << "#pragma omp target parallel";

939 PrintOMPExecutableDirective(Node);

940}

941

942void StmtPrinter::VisitOMPTargetParallelForDirective(

944 Indent() << "#pragma omp target parallel for";

945 PrintOMPExecutableDirective(Node);

946}

947

949 Indent() << "#pragma omp teams";

950 PrintOMPExecutableDirective(Node);

951}

952

953void StmtPrinter::VisitOMPCancellationPointDirective(

955 Indent() << "#pragma omp cancellation point "

956 << getOpenMPDirectiveName(Node->getCancelRegion());

957 PrintOMPExecutableDirective(Node);

958}

959

961 Indent() << "#pragma omp cancel "

962 << getOpenMPDirectiveName(Node->getCancelRegion());

963 PrintOMPExecutableDirective(Node);

964}

965

967 Indent() << "#pragma omp taskloop";

968 PrintOMPExecutableDirective(Node);

969}

970

971void StmtPrinter::VisitOMPTaskLoopSimdDirective(

973 Indent() << "#pragma omp taskloop simd";

974 PrintOMPExecutableDirective(Node);

975}

976

977void StmtPrinter::VisitOMPMasterTaskLoopDirective(

979 Indent() << "#pragma omp master taskloop";

980 PrintOMPExecutableDirective(Node);

981}

982

983void StmtPrinter::VisitOMPMaskedTaskLoopDirective(

985 Indent() << "#pragma omp masked taskloop";

986 PrintOMPExecutableDirective(Node);

987}

988

989void StmtPrinter::VisitOMPMasterTaskLoopSimdDirective(

991 Indent() << "#pragma omp master taskloop simd";

992 PrintOMPExecutableDirective(Node);

993}

994

995void StmtPrinter::VisitOMPMaskedTaskLoopSimdDirective(

997 Indent() << "#pragma omp masked taskloop simd";

998 PrintOMPExecutableDirective(Node);

999}

1000

1001void StmtPrinter::VisitOMPParallelMasterTaskLoopDirective(

1003 Indent() << "#pragma omp parallel master taskloop";

1004 PrintOMPExecutableDirective(Node);

1005}

1006

1007void StmtPrinter::VisitOMPParallelMaskedTaskLoopDirective(

1009 Indent() << "#pragma omp parallel masked taskloop";

1010 PrintOMPExecutableDirective(Node);

1011}

1012

1013void StmtPrinter::VisitOMPParallelMasterTaskLoopSimdDirective(

1015 Indent() << "#pragma omp parallel master taskloop simd";

1016 PrintOMPExecutableDirective(Node);

1017}

1018

1019void StmtPrinter::VisitOMPParallelMaskedTaskLoopSimdDirective(

1021 Indent() << "#pragma omp parallel masked taskloop simd";

1022 PrintOMPExecutableDirective(Node);

1023}

1024

1026 Indent() << "#pragma omp distribute";

1027 PrintOMPExecutableDirective(Node);

1028}

1029

1030void StmtPrinter::VisitOMPTargetUpdateDirective(

1032 Indent() << "#pragma omp target update";

1033 PrintOMPExecutableDirective(Node, true);

1034}

1035

1036void StmtPrinter::VisitOMPDistributeParallelForDirective(

1038 Indent() << "#pragma omp distribute parallel for";

1039 PrintOMPExecutableDirective(Node);

1040}

1041

1042void StmtPrinter::VisitOMPDistributeParallelForSimdDirective(

1044 Indent() << "#pragma omp distribute parallel for simd";

1045 PrintOMPExecutableDirective(Node);

1046}

1047

1048void StmtPrinter::VisitOMPDistributeSimdDirective(

1050 Indent() << "#pragma omp distribute simd";

1051 PrintOMPExecutableDirective(Node);

1052}

1053

1054void StmtPrinter::VisitOMPTargetParallelForSimdDirective(

1056 Indent() << "#pragma omp target parallel for simd";

1057 PrintOMPExecutableDirective(Node);

1058}

1059

1061 Indent() << "#pragma omp target simd";

1062 PrintOMPExecutableDirective(Node);

1063}

1064

1065void StmtPrinter::VisitOMPTeamsDistributeDirective(

1067 Indent() << "#pragma omp teams distribute";

1068 PrintOMPExecutableDirective(Node);

1069}

1070

1071void StmtPrinter::VisitOMPTeamsDistributeSimdDirective(

1073 Indent() << "#pragma omp teams distribute simd";

1074 PrintOMPExecutableDirective(Node);

1075}

1076

1077void StmtPrinter::VisitOMPTeamsDistributeParallelForSimdDirective(

1079 Indent() << "#pragma omp teams distribute parallel for simd";

1080 PrintOMPExecutableDirective(Node);

1081}

1082

1083void StmtPrinter::VisitOMPTeamsDistributeParallelForDirective(

1085 Indent() << "#pragma omp teams distribute parallel for";

1086 PrintOMPExecutableDirective(Node);

1087}

1088

1090 Indent() << "#pragma omp target teams";

1091 PrintOMPExecutableDirective(Node);

1092}

1093

1094void StmtPrinter::VisitOMPTargetTeamsDistributeDirective(

1096 Indent() << "#pragma omp target teams distribute";

1097 PrintOMPExecutableDirective(Node);

1098}

1099

1100void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForDirective(

1102 Indent() << "#pragma omp target teams distribute parallel for";

1103 PrintOMPExecutableDirective(Node);

1104}

1105

1106void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(

1108 Indent() << "#pragma omp target teams distribute parallel for simd";

1109 PrintOMPExecutableDirective(Node);

1110}

1111

1112void StmtPrinter::VisitOMPTargetTeamsDistributeSimdDirective(

1114 Indent() << "#pragma omp target teams distribute simd";

1115 PrintOMPExecutableDirective(Node);

1116}

1117

1119 Indent() << "#pragma omp interop";

1120 PrintOMPExecutableDirective(Node);

1121}

1122

1124 Indent() << "#pragma omp dispatch";

1125 PrintOMPExecutableDirective(Node);

1126}

1127

1129 Indent() << "#pragma omp masked";

1130 PrintOMPExecutableDirective(Node);

1131}

1132

1134 Indent() << "#pragma omp loop";

1135 PrintOMPExecutableDirective(Node);

1136}

1137

1138void StmtPrinter::VisitOMPTeamsGenericLoopDirective(

1140 Indent() << "#pragma omp teams loop";

1141 PrintOMPExecutableDirective(Node);

1142}

1143

1144void StmtPrinter::VisitOMPTargetTeamsGenericLoopDirective(

1146 Indent() << "#pragma omp target teams loop";

1147 PrintOMPExecutableDirective(Node);

1148}

1149

1150void StmtPrinter::VisitOMPParallelGenericLoopDirective(

1152 Indent() << "#pragma omp parallel loop";

1153 PrintOMPExecutableDirective(Node);

1154}

1155

1156void StmtPrinter::VisitOMPTargetParallelGenericLoopDirective(

1158 Indent() << "#pragma omp target parallel loop";

1159 PrintOMPExecutableDirective(Node);

1160}

1161

1162

1163

1164

1166 if (!S->clauses().empty()) {

1167 OS << ' ';

1169 Printer.VisitClauseList(S->clauses());

1170 }

1171}

1173 Indent() << "#pragma acc " << S->getDirectiveKind();

1174 PrintOpenACCClauseList(S);

1175 OS << '\n';

1176}

1178 PrintOpenACCConstruct(S);

1179 PrintStmt(S->getStructuredBlock());

1180}

1181

1183 PrintOpenACCConstruct(S);

1184 PrintStmt(S->getLoop());

1185}

1186

1188 PrintOpenACCConstruct(S);

1189 PrintStmt(S->getLoop());

1190}

1191

1193 PrintOpenACCConstruct(S);

1194 PrintStmt(S->getStructuredBlock());

1195}

1197 PrintOpenACCConstruct(S);

1198 PrintStmt(S->getStructuredBlock());

1199}

1201 PrintOpenACCConstruct(S);

1202}

1204 PrintOpenACCConstruct(S);

1205}

1207 PrintOpenACCConstruct(S);

1208}

1210 PrintOpenACCConstruct(S);

1211}

1213 PrintOpenACCConstruct(S);

1214}

1216 PrintOpenACCConstruct(S);

1217}

1218

1220 Indent() << "#pragma acc wait";

1221 if (!S->getLParenLoc().isInvalid()) {

1222 OS << "(";

1223 if (S->hasDevNumExpr()) {

1224 OS << "devnum: ";

1225 S->getDevNumExpr()->printPretty(OS, nullptr, Policy);

1226 OS << " : ";

1227 }

1228

1229 if (S->hasQueuesTag())

1230 OS << "queues: ";

1231

1232 llvm::interleaveComma(S->getQueueIdExprs(), OS, [&](const Expr *E) {

1233 E->printPretty(OS, nullptr, Policy);

1234 });

1235

1236 OS << ")";

1237 }

1238

1239 PrintOpenACCClauseList(S);

1240 OS << '\n';

1241}

1242

1243

1244

1245

1246

1248 OS << Node->getBuiltinStr() << "()";

1249}

1250

1251void StmtPrinter::VisitEmbedExpr(EmbedExpr *Node) {

1252 llvm::report_fatal_error("Not implemented");

1253}

1254

1256 PrintExpr(Node->getSubExpr());

1257}

1258

1260 if (const auto *OCED = dyn_cast(Node->getDecl())) {

1261 OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy);

1262 return;

1263 }

1264 if (const auto *TPOD = dyn_cast(Node->getDecl())) {

1265 TPOD->printAsExpr(OS, Policy);

1266 return;

1267 }

1270 if (Node->hasTemplateKeyword())

1271 OS << "template ";

1273 isa<ParmVarDecl, NonTypeTemplateParmDecl>(Node->getDecl()) &&

1274 Node->getDecl()->getIdentifier())

1275 OS << Node->getDecl()->getIdentifier()->deuglifiedName();

1276 else

1277 Node->getNameInfo().printName(OS, Policy);

1278 if (Node->hasExplicitTemplateArgs()) {

1280 if ( Node ->hadMultipleCandidates())

1281 if (auto *TD = dyn_cast(Node->getDecl()))

1282 TPL = TD->getTemplateParameters();

1284 }

1285}

1286

1287void StmtPrinter::VisitDependentScopeDeclRefExpr(

1291 if (Node->hasTemplateKeyword())

1292 OS << "template ";

1293 OS << Node->getNameInfo();

1294 if (Node->hasExplicitTemplateArgs())

1296}

1297

1299 if (Node->getQualifier())

1300 Node->getQualifier()->print(OS, Policy);

1301 if (Node->hasTemplateKeyword())

1302 OS << "template ";

1303 OS << Node->getNameInfo();

1304 if (Node->hasExplicitTemplateArgs())

1306}

1307

1309 if (const auto *DRE = dyn_cast(E)) {

1310 if (const auto *PD = dyn_cast(DRE->getDecl())) {

1311 if (PD->getParameterKind() == ImplicitParamKind::ObjCSelf &&

1312 DRE->getBeginLoc().isInvalid())

1313 return true;

1314 }

1315 }

1316 return false;

1317}

1318

1320 if (Node->getBase()) {

1323 PrintExpr(Node->getBase());

1324 OS << (Node->isArrow() ? "->" : ".");

1325 }

1326 }

1327 OS << *Node->getDecl();

1328}

1329

1331 if (Node->isSuperReceiver())

1332 OS << "super.";

1333 else if (Node->isObjectReceiver() && Node->getBase()) {

1334 PrintExpr(Node->getBase());

1335 OS << ".";

1336 } else if (Node->isClassReceiver() && Node->getClassReceiver()) {

1337 OS << Node->getClassReceiver()->getName() << ".";

1338 }

1339

1340 if (Node->isImplicitProperty()) {

1341 if (const auto *Getter = Node->getImplicitPropertyGetter())

1342 Getter->getSelector().print(OS);

1343 else

1345 Node->getImplicitPropertySetter()->getSelector());

1346 } else

1347 OS << Node->getExplicitProperty()->getName();

1348}

1349

1351 PrintExpr(Node->getBaseExpr());

1352 OS << "[";

1353 PrintExpr(Node->getKeyExpr());

1354 OS << "]";

1355}

1356

1357void StmtPrinter::VisitSYCLUniqueStableNameExpr(

1359 OS << "__builtin_sycl_unique_stable_name(";

1360 Node->getTypeSourceInfo()->getType().print(OS, Policy);

1361 OS << ")";

1362}

1363

1366}

1367

1369 OS << '*';

1370}

1371

1374}

1375

1376

1377

1380 if (!Context)

1381 return false;

1387 OS << Source;

1388 return true;

1389 }

1390 return false;

1391}

1392

1395 return;

1396 bool isSigned = Node->getType()->isSignedIntegerType();

1397 OS << toString(Node->getValue(), 10, isSigned);

1398

1399 if (isa(Node->getType())) {

1400 OS << (isSigned ? "wb" : "uwb");

1401 return;

1402 }

1403

1404

1406 default: llvm_unreachable("Unexpected type for integer literal!");

1407 case BuiltinType::Char_S:

1408 case BuiltinType::Char_U: OS << "i8"; break;

1409 case BuiltinType::UChar: OS << "Ui8"; break;

1410 case BuiltinType::SChar: OS << "i8"; break;

1411 case BuiltinType::Short: OS << "i16"; break;

1412 case BuiltinType::UShort: OS << "Ui16"; break;

1413 case BuiltinType::Int: break;

1414 case BuiltinType::UInt: OS << 'U'; break;

1415 case BuiltinType::Long: OS << 'L'; break;

1416 case BuiltinType::ULong: OS << "UL"; break;

1417 case BuiltinType::LongLong: OS << "LL"; break;

1418 case BuiltinType::ULongLong: OS << "ULL"; break;

1419 case BuiltinType::Int128:

1420 break;

1421 case BuiltinType::UInt128:

1422 break;

1423 case BuiltinType::WChar_S:

1424 case BuiltinType::WChar_U:

1425 break;

1426 }

1427}

1428

1431 return;

1432 OS << Node->getValueAsString(10);

1433

1435 default: llvm_unreachable("Unexpected type for fixed point literal!");

1436 case BuiltinType::ShortFract: OS << "hr"; break;

1437 case BuiltinType::ShortAccum: OS << "hk"; break;

1438 case BuiltinType::UShortFract: OS << "uhr"; break;

1439 case BuiltinType::UShortAccum: OS << "uhk"; break;

1440 case BuiltinType::Fract: OS << "r"; break;

1441 case BuiltinType::Accum: OS << "k"; break;

1442 case BuiltinType::UFract: OS << "ur"; break;

1443 case BuiltinType::UAccum: OS << "uk"; break;

1444 case BuiltinType::LongFract: OS << "lr"; break;

1445 case BuiltinType::LongAccum: OS << "lk"; break;

1446 case BuiltinType::ULongFract: OS << "ulr"; break;

1447 case BuiltinType::ULongAccum: OS << "ulk"; break;

1448 }

1449}

1450

1452 bool PrintSuffix) {

1454 Node->getValue().toString(Str);

1455 OS << Str;

1456 if (Str.find_first_not_of("-0123456789") == StringRef::npos)

1457 OS << '.';

1458

1459 if (!PrintSuffix)

1460 return;

1461

1462

1464 default: llvm_unreachable("Unexpected type for float literal!");

1465 case BuiltinType::Half: break;

1466 case BuiltinType::Ibm128: break;

1467 case BuiltinType::Double: break;

1468 case BuiltinType::Float16: OS << "F16"; break;

1469 case BuiltinType::Float: OS << 'F'; break;

1470 case BuiltinType::LongDouble: OS << 'L'; break;

1471 case BuiltinType::Float128: OS << 'Q'; break;

1472 }

1473}

1474

1477 return;

1479}

1480

1482 PrintExpr(Node->getSubExpr());

1483 OS << "i";

1484}

1485

1486void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {

1488}

1489

1490void StmtPrinter::VisitParenExpr(ParenExpr *Node) {

1491 OS << "(";

1492 PrintExpr(Node->getSubExpr());

1493 OS << ")";

1494}

1495

1497 if ( Node ->isPostfix()) {

1499

1500

1501

1502 switch (Node->getOpcode()) {

1503 default: break;

1504 case UO_Real:

1505 case UO_Imag:

1506 case UO_Extension:

1507 OS << ' ';

1508 break;

1509 case UO_Plus:

1510 case UO_Minus:

1511 if (isa(Node->getSubExpr()))

1512 OS << ' ';

1513 break;

1514 }

1515 }

1516 PrintExpr(Node->getSubExpr());

1517

1518 if (Node->isPostfix())

1520}

1521

1523 OS << "__builtin_offsetof(";

1524 Node->getTypeSourceInfo()->getType().print(OS, Policy);

1525 OS << ", ";

1526 bool PrintedSomething = false;

1527 for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {

1530

1531 OS << "[";

1533 OS << "]";

1534 PrintedSomething = true;

1535 continue;

1536 }

1537

1538

1540 continue;

1541

1542

1544 if ()

1545 continue;

1546

1547 if (PrintedSomething)

1548 OS << ".";

1549 else

1550 PrintedSomething = true;

1551 OS << Id->getName();

1552 }

1553 OS << ")";

1554}

1555

1556void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(

1559 if (Node->getKind() == UETT_AlignOf) {

1561 Spelling = "alignof";

1563 Spelling = "_Alignof";

1564 else

1565 Spelling = "__alignof";

1566 }

1567

1568 OS << Spelling;

1569

1570 if (Node->isArgumentType()) {

1571 OS << '(';

1572 Node->getArgumentType().print(OS, Policy);

1573 OS << ')';

1574 } else {

1575 OS << " ";

1576 PrintExpr(Node->getArgumentExpr());

1577 }

1578}

1579

1581 OS << "_Generic(";

1582 if (Node->isExprPredicate())

1583 PrintExpr(Node->getControllingExpr());

1584 else

1585 Node->getControllingType()->getType().print(OS, Policy);

1586

1588 OS << ", ";

1590 if (T.isNull())

1591 OS << "default";

1592 else

1593 T.print(OS, Policy);

1594 OS << ": ";

1595 PrintExpr(Assoc.getAssociationExpr());

1596 }

1597 OS << ")";

1598}

1599

1601 PrintExpr(Node->getLHS());

1602 OS << "[";

1603 PrintExpr(Node->getRHS());

1604 OS << "]";

1605}

1606

1608 PrintExpr(Node->getBase());

1609 OS << "[";

1610 PrintExpr(Node->getRowIdx());

1611 OS << "]";

1612 OS << "[";

1613 PrintExpr(Node->getColumnIdx());

1614 OS << "]";

1615}

1616

1618 PrintExpr(Node->getBase());

1619 OS << "[";

1620 if (Node->getLowerBound())

1621 PrintExpr(Node->getLowerBound());

1622 if (Node->getColonLocFirst().isValid()) {

1623 OS << ":";

1624 if (Node->getLength())

1625 PrintExpr(Node->getLength());

1626 }

1627 if (Node->isOMPArraySection() && Node->getColonLocSecond().isValid()) {

1628 OS << ":";

1629 if (Node->getStride())

1630 PrintExpr(Node->getStride());

1631 }

1632 OS << "]";

1633}

1634

1636 OS << "(";

1637 for (Expr *E : Node->getDimensions()) {

1638 OS << "[";

1639 PrintExpr(E);

1640 OS << "]";

1641 }

1642 OS << ")";

1643 PrintExpr(Node->getBase());

1644}

1645

1647 OS << "iterator(";

1648 for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) {

1649 auto *VD = cast(Node->getIteratorDecl(I));

1650 VD->getType().print(OS, Policy);

1652 OS << " " << VD->getName() << " = ";

1653 PrintExpr(Range.Begin);

1654 OS << ":";

1655 PrintExpr(Range.End);

1656 if (Range.Step) {

1657 OS << ":";

1658 PrintExpr(Range.Step);

1659 }

1660 if (I < E - 1)

1661 OS << ", ";

1662 }

1663 OS << ")";

1664}

1665

1666void StmtPrinter::PrintCallArgs(CallExpr *Call) {

1667 for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {

1668 if (isa(Call->getArg(i))) {

1669

1670 break;

1671 }

1672

1673 if (i) OS << ", ";

1674 PrintExpr(Call->getArg(i));

1675 }

1676}

1677

1678void StmtPrinter::VisitCallExpr(CallExpr *Call) {

1679 PrintExpr(Call->getCallee());

1680 OS << "(";

1681 PrintCallArgs(Call);

1682 OS << ")";

1683}

1684

1686 if (const auto *TE = dyn_cast(E))

1687 return TE->isImplicit();

1688 return false;

1689}

1690

1691void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {

1693 PrintExpr(Node->getBase());

1694

1695 auto *ParentMember = dyn_cast(Node->getBase());

1697 ParentMember ? dyn_cast(ParentMember->getMemberDecl())

1698 : nullptr;

1699

1701 OS << (Node->isArrow() ? "->" : ".");

1702 }

1703

1704 if (auto *FD = dyn_cast(Node->getMemberDecl()))

1705 if (FD->isAnonymousStructOrUnion())

1706 return;

1707

1710 if (Node->hasTemplateKeyword())

1711 OS << "template ";

1712 OS << Node->getMemberNameInfo();

1714 if (auto *FD = dyn_cast(Node->getMemberDecl())) {

1715 if ( Node ->hadMultipleCandidates())

1716 if (auto *FTD = FD->getPrimaryTemplate())

1717 TPL = FTD->getTemplateParameters();

1718 } else if (auto *VTSD =

1719 dyn_cast(Node->getMemberDecl()))

1720 TPL = VTSD->getSpecializedTemplate()->getTemplateParameters();

1721 if (Node->hasExplicitTemplateArgs())

1723}

1724

1726 PrintExpr(Node->getBase());

1727 OS << (Node->isArrow() ? "->isa" : ".isa");

1728}

1729

1731 PrintExpr(Node->getBase());

1732 OS << ".";

1733 OS << Node->getAccessor().getName();

1734}

1735

1737 OS << '(';

1738 Node->getTypeAsWritten().print(OS, Policy);

1739 OS << ')';

1740 PrintExpr(Node->getSubExpr());

1741}

1742

1744 OS << '(';

1745 Node->getType().print(OS, Policy);

1746 OS << ')';

1747 PrintExpr(Node->getInitializer());

1748}

1749

1751

1752 PrintExpr(Node->getSubExpr());

1753}

1754

1756 PrintExpr(Node->getLHS());

1758 PrintExpr(Node->getRHS());

1759}

1760

1762 PrintExpr(Node->getLHS());

1764 PrintExpr(Node->getRHS());

1765}

1766

1768 PrintExpr(Node->getCond());

1769 OS << " ? ";

1770 PrintExpr(Node->getLHS());

1771 OS << " : ";

1772 PrintExpr(Node->getRHS());

1773}

1774

1775

1776

1777void

1779 PrintExpr(Node->getCommon());

1780 OS << " ?: ";

1781 PrintExpr(Node->getFalseExpr());

1782}

1783

1785 OS << "&&" << Node->getLabel()->getName();

1786}

1787

1788void StmtPrinter::VisitStmtExpr(StmtExpr *E) {

1789 OS << "(";

1790 PrintRawCompoundStmt(E->getSubStmt());

1791 OS << ")";

1792}

1793

1794void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {

1795 OS << "__builtin_choose_expr(";

1796 PrintExpr(Node->getCond());

1797 OS << ", ";

1798 PrintExpr(Node->getLHS());

1799 OS << ", ";

1800 PrintExpr(Node->getRHS());

1801 OS << ")";

1802}

1803

1804void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {

1805 OS << "__null";

1806}

1807

1809 OS << "__builtin_shufflevector(";

1810 for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {

1811 if (i) OS << ", ";

1812 PrintExpr(Node->getExpr(i));

1813 }

1814 OS << ")";

1815}

1816

1818 OS << "__builtin_convertvector(";

1819 PrintExpr(Node->getSrcExpr());

1820 OS << ", ";

1821 Node->getType().print(OS, Policy);

1822 OS << ")";

1823}

1824

1826 if (Node->getSyntacticForm()) {

1827 Visit(Node->getSyntacticForm());

1828 return;

1829 }

1830

1831 OS << "{";

1832 for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {

1833 if (i) OS << ", ";

1834 if (Node->getInit(i))

1835 PrintExpr(Node->getInit(i));

1836 else

1837 OS << "{}";

1838 }

1839 OS << "}";

1840}

1841

1843

1844

1845 OS << "{";

1846 PrintExpr(Node->getSubExpr());

1847 OS << "}";

1848}

1849

1851 OS << "*";

1852}

1853

1855 OS << "(";

1856 for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {

1857 if (i) OS << ", ";

1858 PrintExpr(Node->getExpr(i));

1859 }

1860 OS << ")";

1861}

1862

1864 bool NeedsEquals = true;

1866 if (D.isFieldDesignator()) {

1867 if (D.getDotLoc().isInvalid()) {

1869 OS << II->getName() << ":";

1870 NeedsEquals = false;

1871 }

1872 } else {

1873 OS << "." << D.getFieldName()->getName();

1874 }

1875 } else {

1876 OS << "[";

1877 if (D.isArrayDesignator()) {

1878 PrintExpr(Node->getArrayIndex(D));

1879 } else {

1880 PrintExpr(Node->getArrayRangeStart(D));

1881 OS << " ... ";

1882 PrintExpr(Node->getArrayRangeEnd(D));

1883 }

1884 OS << "]";

1885 }

1886 }

1887

1888 if (NeedsEquals)

1889 OS << " = ";

1890 else

1891 OS << " ";

1892 PrintExpr(Node->getInit());

1893}

1894

1895void StmtPrinter::VisitDesignatedInitUpdateExpr(

1897 OS << "{";

1898 OS << "/*base*/";

1899 PrintExpr(Node->getBase());

1900 OS << ", ";

1901

1902 OS << "/*updater*/";

1903 PrintExpr(Node->getUpdater());

1904 OS << "}";

1905}

1906

1907void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) {

1908 OS << "/*no init*/";

1909}

1910

1912 if (Node->getType()->getAsCXXRecordDecl()) {

1913 OS << "/*implicit*/";

1914 Node->getType().print(OS, Policy);

1915 OS << "()";

1916 } else {

1917 OS << "/*implicit*/(";

1918 Node->getType().print(OS, Policy);

1919 OS << ')';

1920 if (Node->getType()->isRecordType())

1921 OS << "{}";

1922 else

1923 OS << 0;

1924 }

1925}

1926

1927void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {

1928 OS << "__builtin_va_arg(";

1929 PrintExpr(Node->getSubExpr());

1930 OS << ", ";

1931 Node->getType().print(OS, Policy);

1932 OS << ")";

1933}

1934

1936 PrintExpr(Node->getSyntacticForm());

1937}

1938

1939void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {

1940 const char *Name = nullptr;

1941 switch (Node->getOp()) {

1942#define BUILTIN(ID, TYPE, ATTRS)

1943#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \

1944 case AtomicExpr::AO ## ID: \

1945 Name = #ID "("; \

1946 break;

1947#include "clang/Basic/Builtins.inc"

1948 }

1949 OS << Name;

1950

1951

1952 PrintExpr(Node->getPtr());

1953 if (Node->getOp() != AtomicExpr::AO__c11_atomic_load &&

1954 Node->getOp() != AtomicExpr::AO__atomic_load_n &&

1955 Node->getOp() != AtomicExpr::AO__scoped_atomic_load_n &&

1956 Node->getOp() != AtomicExpr::AO__opencl_atomic_load &&

1957 Node->getOp() != AtomicExpr::AO__hip_atomic_load) {

1958 OS << ", ";

1959 PrintExpr(Node->getVal1());

1960 }

1961 if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||

1962 Node->isCmpXChg()) {

1963 OS << ", ";

1964 PrintExpr(Node->getVal2());

1965 }

1966 if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange ||

1967 Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) {

1968 OS << ", ";

1969 PrintExpr(Node->getWeak());

1970 }

1971 if (Node->getOp() != AtomicExpr::AO__c11_atomic_init &&

1972 Node->getOp() != AtomicExpr::AO__opencl_atomic_init) {

1973 OS << ", ";

1974 PrintExpr(Node->getOrder());

1975 }

1976 if (Node->isCmpXChg()) {

1977 OS << ", ";

1978 PrintExpr(Node->getOrderFail());

1979 }

1980 OS << ")";

1981}

1982

1983

1986 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {

1987 if (Node->getNumArgs() == 1) {

1989 PrintExpr(Node->getArg(0));

1990 } else {

1991 PrintExpr(Node->getArg(0));

1993 }

1994 } else if (Kind == OO_Arrow) {

1995 PrintExpr(Node->getArg(0));

1996 } else if (Kind == OO_Call || Kind == OO_Subscript) {

1997 PrintExpr(Node->getArg(0));

1998 OS << (Kind == OO_Call ? '(' : '[');

1999 for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {

2000 if (ArgIdx > 1)

2001 OS << ", ";

2002 if (!isa(Node->getArg(ArgIdx)))

2003 PrintExpr(Node->getArg(ArgIdx));

2004 }

2005 OS << (Kind == OO_Call ? ')' : ']');

2006 } else if (Node->getNumArgs() == 1) {

2008 PrintExpr(Node->getArg(0));

2009 } else if (Node->getNumArgs() == 2) {

2010 PrintExpr(Node->getArg(0));

2012 PrintExpr(Node->getArg(1));

2013 } else {

2014 llvm_unreachable("unknown overloaded operator");

2015 }

2016}

2017

2019

2021 if (isa_and_nonnull(MD)) {

2022 PrintExpr(Node->getImplicitObjectArgument());

2023 return;

2024 }

2025 VisitCallExpr(cast(Node));

2026}

2027

2029 PrintExpr(Node->getCallee());

2030 OS << "<<<";

2031 PrintCallArgs(Node->getConfig());

2032 OS << ">>>(";

2033 PrintCallArgs(Node);

2034 OS << ")";

2035}

2036

2037void StmtPrinter::VisitCXXRewrittenBinaryOperator(

2040 Node->getDecomposedForm();

2041 PrintExpr(const_cast<Expr*>(Decomposed.LHS));

2043 PrintExpr(const_cast<Expr*>(Decomposed.RHS));

2044}

2045

2047 OS << Node->getCastName() << '<';

2048 Node->getTypeAsWritten().print(OS, Policy);

2049 OS << ">(";

2050 PrintExpr(Node->getSubExpr());

2051 OS << ")";

2052}

2053

2055 VisitCXXNamedCastExpr(Node);

2056}

2057

2059 VisitCXXNamedCastExpr(Node);

2060}

2061

2063 VisitCXXNamedCastExpr(Node);

2064}

2065

2067 VisitCXXNamedCastExpr(Node);

2068}

2069

2071 OS << "__builtin_bit_cast(";

2072 Node->getTypeInfoAsWritten()->getType().print(OS, Policy);

2073 OS << ", ";

2074 PrintExpr(Node->getSubExpr());

2075 OS << ")";

2076}

2077

2079 VisitCXXNamedCastExpr(Node);

2080}

2081

2083 OS << "typeid(";

2084 if (Node->isTypeOperand()) {

2085 Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);

2086 } else {

2087 PrintExpr(Node->getExprOperand());

2088 }

2089 OS << ")";

2090}

2091

2093 OS << "__uuidof(";

2094 if (Node->isTypeOperand()) {

2095 Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);

2096 } else {

2097 PrintExpr(Node->getExprOperand());

2098 }

2099 OS << ")";

2100}

2101

2103 PrintExpr(Node->getBaseExpr());

2104 if (Node->isArrow())

2105 OS << "->";

2106 else

2107 OS << ".";

2109 Node->getQualifierLoc().getNestedNameSpecifier())

2111 OS << Node->getPropertyDecl()->getDeclName();

2112}

2113

2115 PrintExpr(Node->getBase());

2116 OS << "[";

2117 PrintExpr(Node->getIdx());

2118 OS << "]";

2119}

2120

2122 switch (Node->getLiteralOperatorKind()) {

2124 OS << cast(Node->getArg(0)->IgnoreImpCasts())->getString();

2125 break;

2127 const auto *DRE = cast(Node->getCallee()->IgnoreImpCasts());

2129 cast(DRE->getDecl())->getTemplateSpecializationArgs();

2130 assert(Args);

2131

2134 if (!DRE->hadMultipleCandidates())

2135 if (const auto *TD = dyn_cast(DRE->getDecl()))

2136 TPL = TD->getTemplateParameters();

2137 OS << "operator\"\"" << Node->getUDSuffix()->getName();

2139 OS << "()";

2140 return;

2141 }

2142

2145 char C = (char)P.getAsIntegral().getZExtValue();

2146 OS << C;

2147 }

2148 break;

2149 }

2151

2152 const auto *Int = cast(Node->getCookedLiteral());

2153 OS << toString(Int->getValue(), 10, false);

2154 break;

2155 }

2157

2158 auto *Float = cast(Node->getCookedLiteral());

2160 break;

2161 }

2164 PrintExpr(Node->getCookedLiteral());

2165 break;

2166 }

2167 OS << Node->getUDSuffix()->getName();

2168}

2169

2171 OS << (Node->getValue() ? "true" : "false");

2172}

2173

2175 OS << "nullptr";

2176}

2177

2179 OS << "this";

2180}

2181

2183 if ( Node ->getSubExpr())

2184 OS << "throw";

2185 else {

2186 OS << "throw ";

2187 PrintExpr(Node->getSubExpr());

2188 }

2189}

2190

2192

2193}

2194

2196

2197}

2198

2200 auto TargetType = Node->getType();

2201 auto *Auto = TargetType->getContainedDeducedType();

2202 bool Bare = Auto && Auto->isDeduced();

2203

2204

2205 if (Bare)

2206 OS << '(';

2207 TargetType.print(OS, Policy);

2208 if (Bare)

2209 OS << ')';

2210

2211

2212 if ( Node ->isListInitialization())

2213 OS << '(';

2214 PrintExpr(Node->getSubExpr());

2215 if ( Node ->isListInitialization())

2216 OS << ')';

2217}

2218

2220 PrintExpr(Node->getSubExpr());

2221}

2222

2224 Node->getType().print(OS, Policy);

2225 if (Node->isStdInitListInitialization())

2226 ;

2227 else if (Node->isListInitialization())

2228 OS << "{";

2229 else

2230 OS << "(";

2232 ArgEnd = Node->arg_end();

2233 Arg != ArgEnd; ++Arg) {

2234 if ((*Arg)->isDefaultArgument())

2235 break;

2236 if (Arg != Node->arg_begin())

2237 OS << ", ";

2238 PrintExpr(*Arg);

2239 }

2240 if (Node->isStdInitListInitialization())

2241 ;

2242 else if (Node->isListInitialization())

2243 OS << "}";

2244 else

2245 OS << ")";

2246}

2247

2248void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) {

2249 OS << '[';

2250 bool NeedComma = false;

2251 switch (Node->getCaptureDefault()) {

2253 break;

2254

2256 OS << '=';

2257 NeedComma = true;

2258 break;

2259

2261 OS << '&';

2262 NeedComma = true;

2263 break;

2264 }

2266 CEnd = Node->explicit_capture_end();

2267 C != CEnd;

2268 ++C) {

2269 if (C->capturesVLAType())

2270 continue;

2271

2272 if (NeedComma)

2273 OS << ", ";

2274 NeedComma = true;

2275

2276 switch (C->getCaptureKind()) {

2278 OS << "this";

2279 break;

2280

2282 OS << "*this";

2283 break;

2284

2286 if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C))

2287 OS << '&';

2288 OS << C->getCapturedVar()->getName();

2289 break;

2290

2292 OS << C->getCapturedVar()->getName();

2293 break;

2294

2296 llvm_unreachable("VLA type in explicit captures.");

2297 }

2298

2299 if (C->isPackExpansion())

2300 OS << "...";

2301

2302 if (Node->isInitCapture(C)) {

2303

2304 auto *D = cast(C->getCapturedVar());

2305

2306 llvm::StringRef Pre;

2307 llvm::StringRef Post;

2309 !isa(D->getInit())) {

2310 Pre = "(";

2313 Pre = " = ";

2314 }

2315

2316 OS << Pre;

2317 PrintExpr(D->getInit());

2319 }

2320 }

2321 OS << ']';

2322

2323 if ( Node ->getExplicitTemplateParameters().empty()) {

2324 Node->getTemplateParameterList()->print(

2325 OS, Node->getLambdaClass()->getASTContext(),

2326 true);

2327 }

2328

2329 if (Node->hasExplicitParameters()) {

2330 OS << '(';

2332 NeedComma = false;

2333 for (const auto *P : Method->parameters()) {

2334 if (NeedComma) {

2335 OS << ", ";

2336 } else {

2337 NeedComma = true;

2338 }

2339 std::string ParamStr =

2341 ? P->getIdentifier()->deuglifiedName().str()

2342 : P->getNameAsString();

2343 P->getOriginalType().print(OS, Policy, ParamStr);

2344 }

2346 if (NeedComma)

2347 OS << ", ";

2348 OS << "...";

2349 }

2350 OS << ')';

2351

2352 if (Node->isMutable())

2353 OS << " mutable";

2354

2357

2358

2359

2360

2361 if (Node->hasExplicitResultType()) {

2362 OS << " -> ";

2363 Proto->getReturnType().print(OS, Policy);

2364 }

2365 }

2366

2367

2368 OS << ' ';

2370 OS << "{}";

2371 else

2372 PrintRawCompoundStmt(Node->getCompoundStmtBody());

2373}

2374

2377 TSInfo->getType().print(OS, Policy);

2378 else

2379 Node->getType().print(OS, Policy);

2380 OS << "()";

2381}

2382

2383void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {

2384 if (E->isGlobalNew())

2385 OS << "::";

2386 OS << "new ";

2387 unsigned NumPlace = E->getNumPlacementArgs();

2388 if (NumPlace > 0 && !isa(E->getPlacementArg(0))) {

2389 OS << "(";

2390 PrintExpr(E->getPlacementArg(0));

2391 for (unsigned i = 1; i < NumPlace; ++i) {

2392 if (isa(E->getPlacementArg(i)))

2393 break;

2394 OS << ", ";

2395 PrintExpr(E->getPlacementArg(i));

2396 }

2397 OS << ") ";

2398 }

2399 if (E->isParenTypeId())

2400 OS << "(";

2401 std::string TypeS;

2402 if (E->isArray()) {

2403 llvm::raw_string_ostream s(TypeS);

2404 s << '[';

2405 if (std::optional<Expr *> Size = E->getArraySize())

2406 (*Size)->printPretty(s, Helper, Policy);

2407 s << ']';

2408 }

2409 E->getAllocatedType().print(OS, Policy, TypeS);

2410 if (E->isParenTypeId())

2411 OS << ")";

2412

2414 if (InitStyle != CXXNewInitializationStyle::None) {

2415 bool Bare = InitStyle == CXXNewInitializationStyle::Parens &&

2416 !isa(E->getInitializer());

2417 if (Bare)

2418 OS << "(";

2419 PrintExpr(E->getInitializer());

2420 if (Bare)

2421 OS << ")";

2422 }

2423}

2424

2425void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {

2426 if (E->isGlobalDelete())

2427 OS << "::";

2428 OS << "delete ";

2429 if (E->isArrayForm())

2430 OS << "[] ";

2431 PrintExpr(E->getArgument());

2432}

2433

2435 PrintExpr(E->getBase());

2436 if (E->isArrow())

2437 OS << "->";

2438 else

2439 OS << '.';

2440 if (E->getQualifier())

2441 E->getQualifier()->print(OS, Policy);

2442 OS << "~";

2443

2444 if (const IdentifierInfo *II = E->getDestroyedTypeIdentifier())

2445 OS << II->getName();

2446 else

2447 E->getDestroyedType().print(OS, Policy);

2448}

2449

2451 if (E->isListInitialization() && ->isStdInitListInitialization())

2452 OS << "{";

2453

2454 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {

2455 if (isa(E->getArg(i))) {

2456

2457 break;

2458 }

2459

2460 if (i) OS << ", ";

2461 PrintExpr(E->getArg(i));

2462 }

2463

2464 if (E->isListInitialization() && ->isStdInitListInitialization())

2465 OS << "}";

2466}

2467

2469

2470 OS << "";

2471}

2472

2474 PrintExpr(E->getSubExpr());

2475}

2476

2478

2479 PrintExpr(E->getSubExpr());

2480}

2481

2482void StmtPrinter::VisitCXXUnresolvedConstructExpr(

2484 Node->getTypeAsWritten().print(OS, Policy);

2485 if ( Node ->isListInitialization())

2486 OS << '(';

2487 for (auto Arg = Node->arg_begin(), ArgEnd = Node->arg_end(); Arg != ArgEnd;

2488 ++Arg) {

2489 if (Arg != Node->arg_begin())

2490 OS << ", ";

2491 PrintExpr(*Arg);

2492 }

2493 if ( Node ->isListInitialization())

2494 OS << ')';

2495}

2496

2497void StmtPrinter::VisitCXXDependentScopeMemberExpr(

2499 if ( Node ->isImplicitAccess()) {

2500 PrintExpr(Node->getBase());

2501 OS << (Node->isArrow() ? "->" : ".");

2502 }

2505 if (Node->hasTemplateKeyword())

2506 OS << "template ";

2507 OS << Node->getMemberNameInfo();

2508 if (Node->hasExplicitTemplateArgs())

2510}

2511

2513 if ( Node ->isImplicitAccess()) {

2514 PrintExpr(Node->getBase());

2515 OS << (Node->isArrow() ? "->" : ".");

2516 }

2519 if (Node->hasTemplateKeyword())

2520 OS << "template ";

2521 OS << Node->getMemberNameInfo();

2522 if (Node->hasExplicitTemplateArgs())

2524}

2525

2526void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {

2528 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {

2529 if (I > 0)

2530 OS << ", ";

2532 }

2533 OS << ")";

2534}

2535

2538 E->getQueriedType().print(OS, Policy);

2539 OS << ')';

2540}

2541

2544 PrintExpr(E->getQueriedExpression());

2545 OS << ')';

2546}

2547

2549 OS << "noexcept(";

2550 PrintExpr(E->getOperand());

2551 OS << ")";

2552}

2553

2555 PrintExpr(E->getPattern());

2556 OS << "...";

2557}

2558

2559void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {

2560 OS << "sizeof...(" << *E->getPack() << ")";

2561}

2562

2564 PrintExpr(E->getPackIdExpression());

2565 OS << "...[";

2566 PrintExpr(E->getIndexExpr());

2567 OS << "]";

2568}

2569

2570void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(

2572 OS << *Node->getParameterPack();

2573}

2574

2575void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(

2577 Visit(Node->getReplacement());

2578}

2579

2581 OS << *E->getParameterPack();

2582}

2583

2585 PrintExpr(Node->getSubExpr());

2586}

2587

2588void StmtPrinter::VisitCXXFoldExpr(CXXFoldExpr *E) {

2589 OS << "(";

2590 if (E->getLHS()) {

2591 PrintExpr(E->getLHS());

2593 }

2594 OS << "...";

2595 if (E->getRHS()) {

2597 PrintExpr(E->getRHS());

2598 }

2599 OS << ")";

2600}

2601

2603 OS << "(";

2604 llvm::interleaveComma(Node->getInitExprs(), OS,

2605 [&](Expr *E) { PrintExpr(E); });

2606 OS << ")";

2607}

2608

2611 if (NNS)

2613 if (E->getTemplateKWLoc().isValid())

2614 OS << "template ";

2615 OS << E->getFoundDecl()->getName();

2617 Policy,

2618 E->getNamedConcept()->getTemplateParameters());

2619}

2620

2621void StmtPrinter::VisitRequiresExpr(RequiresExpr *E) {

2622 OS << "requires ";

2623 auto LocalParameters = E->getLocalParameters();

2624 if (!LocalParameters.empty()) {

2625 OS << "(";

2626 for (ParmVarDecl *LocalParam : LocalParameters) {

2627 PrintRawDecl(LocalParam);

2628 if (LocalParam != LocalParameters.back())

2629 OS << ", ";

2630 }

2631

2632 OS << ") ";

2633 }

2634 OS << "{ ";

2635 auto Requirements = E->getRequirements();

2637 if (auto *TypeReq = dyn_castconcepts::TypeRequirement(Req)) {

2638 if (TypeReq->isSubstitutionFailure())

2639 OS << "<>";

2640 else

2641 TypeReq->getType()->getType().print(OS, Policy);

2642 } else if (auto *ExprReq = dyn_castconcepts::ExprRequirement(Req)) {

2643 if (ExprReq->isCompound())

2644 OS << "{ ";

2645 if (ExprReq->isExprSubstitutionFailure())

2646 OS << "<>";

2647 else

2648 PrintExpr(ExprReq->getExpr());

2649 if (ExprReq->isCompound()) {

2650 OS << " }";

2651 if (ExprReq->getNoexceptLoc().isValid())

2652 OS << " noexcept";

2653 const auto &RetReq = ExprReq->getReturnTypeRequirement();

2654 if (!RetReq.isEmpty()) {

2655 OS << " -> ";

2656 if (RetReq.isSubstitutionFailure())

2657 OS << "<>";

2658 else if (RetReq.isTypeConstraint())

2659 RetReq.getTypeConstraint()->print(OS, Policy);

2660 }

2661 }

2662 } else {

2663 auto *NestedReq = castconcepts::NestedRequirement(Req);

2664 OS << "requires ";

2665 if (NestedReq->hasInvalidConstraint())

2666 OS << "<>";

2667 else

2668 PrintExpr(NestedReq->getConstraintExpr());

2669 }

2670 OS << "; ";

2671 }

2672 OS << "}";

2673}

2674

2675

2676

2678 Visit(S->getBody());

2679}

2680

2681void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) {

2682 OS << "co_return";

2683 if (S->getOperand()) {

2684 OS << " ";

2685 Visit(S->getOperand());

2686 }

2687 OS << ";";

2688}

2689

2690void StmtPrinter::VisitCoawaitExpr(CoawaitExpr *S) {

2691 OS << "co_await ";

2692 PrintExpr(S->getOperand());

2693}

2694

2696 OS << "co_await ";

2697 PrintExpr(S->getOperand());

2698}

2699

2700void StmtPrinter::VisitCoyieldExpr(CoyieldExpr *S) {

2701 OS << "co_yield ";

2702 PrintExpr(S->getOperand());

2703}

2704

2705

2706

2708 OS << "@";

2709 VisitStringLiteral(Node->getString());

2710}

2711

2712void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {

2713 OS << "@";

2714 Visit(E->getSubExpr());

2715}

2716

2718 OS << "@[ ";

2720 for (auto I = Ch.begin(), E = Ch.end(); I != E; ++I) {

2721 if (I != Ch.begin())

2722 OS << ", ";

2723 Visit(*I);

2724 }

2725 OS << " ]";

2726}

2727

2729 OS << "@{ ";

2730 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {

2731 if (I > 0)

2732 OS << ", ";

2733

2735 Visit(Element.Key);

2736 OS << " : ";

2737 Visit(Element.Value);

2738 if (Element.isPackExpansion())

2739 OS << "...";

2740 }

2741 OS << " }";

2742}

2743

2745 OS << "@encode(";

2746 Node->getEncodedType().print(OS, Policy);

2747 OS << ')';

2748}

2749

2751 OS << "@selector(";

2753 OS << ')';

2754}

2755

2757 OS << "@protocol(" << *Node->getProtocol() << ')';

2758}

2759

2760void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {

2761 OS << "[";

2765 break;

2766

2769 break;

2770

2773 OS << "Super";

2774 break;

2775 }

2776

2777 OS << ' ';

2781 } else {

2782 for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {

2784 if (i > 0) OS << ' ';

2787 else

2788 OS << ":";

2789 }

2790 else OS << ", ";

2791

2792 PrintExpr(Mess->getArg(i));

2793 }

2794 }

2795 OS << "]";

2796}

2797

2799 OS << (Node->getValue() ? "__objc_yes" : "__objc_no");

2800}

2801

2802void

2804 PrintExpr(E->getSubExpr());

2805}

2806

2807void

2809 OS << '(' << E->getBridgeKindName();

2811 OS << ')';

2812 PrintExpr(E->getSubExpr());

2813}

2814

2815void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {

2817 OS << "^";

2818

2820

2821 if (isa(AFT)) {

2822 OS << "()";

2823 } else if (!BD->param_empty() || cast(AFT)->isVariadic()) {

2824 OS << '(';

2827 if (AI != BD->param_begin()) OS << ", ";

2828 std::string ParamStr = (*AI)->getNameAsString();

2829 (*AI)->getType().print(OS, Policy, ParamStr);

2830 }

2831

2832 const auto *FT = cast(AFT);

2833 if (FT->isVariadic()) {

2835 OS << "...";

2836 }

2837 OS << ')';

2838 }

2839 OS << "{ }";

2840}

2841

2843 PrintExpr(Node->getSourceExpr());

2844}

2845

2846void StmtPrinter::VisitTypoExpr(TypoExpr *Node) {

2847

2848 llvm_unreachable("Cannot print TypoExpr nodes");

2849}

2850

2852 OS << "(";

2853 const char *Sep = "";

2854 for (Expr *E : Node->subExpressions()) {

2855 OS << Sep;

2856 PrintExpr(E);

2857 Sep = ", ";

2858 }

2859 OS << ')';

2860}

2861

2862void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {

2863 OS << "__builtin_astype(";

2864 PrintExpr(Node->getSrcExpr());

2865 OS << ", ";

2866 Node->getType().print(OS, Policy);

2867 OS << ")";

2868}

2869

2871 PrintExpr(Node->getArgLValue());

2872}

2873

2874

2875

2876

2877

2880}

2881

2884 StringRef NL, const ASTContext *Context) const {

2885 StmtPrinter P(Out, Helper, Policy, Indentation, NL, Context);

2886 P.Visit(const_cast<Stmt *>(this));

2887}

2888

2891 unsigned Indentation, StringRef NL,

2893 StmtPrinter P(Out, Helper, Policy, Indentation, NL, Context);

2894 P.PrintControlledStmt(const_cast<Stmt *>(this));

2895}

2896

2898 const PrintingPolicy &Policy, bool AddQuotes) const {

2899 std::string Buf;

2900 llvm::raw_string_ostream TempOut(Buf);

2901

2903

2904 Out << JsonFormat(TempOut.str(), AddQuotes);

2905}

2906

2907

2908

2909

2910

2911

Defines the clang::ASTContext interface.

static Decl::Kind getKind(const Decl *D)

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

This file defines OpenMP nodes for declarative directives.

Defines the C++ template declaration subclasses.

Defines the clang::Expr interface and subclasses for C++ expressions.

Defines enumerations for expression traits intrinsics.

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines several types used to describe C++ lambda expressions that are shared between the parser and ...

This file defines OpenMP AST classes for clauses.

Defines some OpenMP-specific enums and functions.

Defines an enumeration for C++ overloaded operators.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

Defines the clang::SourceLocation class and associated facilities.

Defines the Objective-C statement AST node classes.

This file defines OpenMP AST classes for executable directives and clauses.

static bool isImplicitThis(const Expr *E)

static bool isImplicitSelf(const Expr *E)

static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node, bool PrintSuffix)

static bool printExprAsWritten(raw_ostream &OS, Expr *E, const ASTContext *Context)

Prints the given expression using the original source text.

This file defines SYCL AST classes used to represent calls to SYCL kernels.

Defines enumerations for the type traits support.

C Language Family Type Representation.

__device__ __2f16 float __ockl_bool s

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

SourceManager & getSourceManager()

const LangOptions & getLangOpts() const

AddrLabelExpr - The GNU address of label extension, representing &&label.

Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.

Represents a loop initializing the elements of an array.

This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...

ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.

An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.

AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...

AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...

Attr - This represents one attribute.

void printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const

Represents an attribute applied to a statement.

BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...

A builtin binary operation expression such as "x + y" or "x <= y".

StringRef getOpcodeStr() const

Represents a block literal declaration, which is like an unnamed FunctionDecl.

param_iterator param_end()

MutableArrayRef< ParmVarDecl * >::iterator param_iterator

param_iterator param_begin()

BlockExpr - Adaptor class for mixing a BlockDecl with expressions.

BreakStmt - This represents a break.

Represents a C++2a __builtin_bit_cast(T, v) expression.

This class is used for builtin types like 'int'.

CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....

Represents a call to a CUDA kernel function.

A C++ addrspace_cast expression (currently only enabled for OpenCL).

Represents binding an expression to a temporary.

A boolean literal, per ([C++ lex.bool] Boolean literals).

CXXCatchStmt - This represents a C++ catch block.

A C++ const_cast expression (C++ [expr.const.cast]).

Represents a call to a C++ constructor.

A default argument (C++ [dcl.fct.default]).

A use of a default initializer in a constructor or in aggregate initialization.

Represents a delete expression for memory deallocation and destructor calls, e.g.

Represents a C++ member access expression where the actual member referenced could not be resolved be...

A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).

Represents a folding of a pack over an operator.

CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...

Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....

Represents a call to an inherited base class constructor from an inheriting constructor.

Represents a call to a member function that may be written either with member call syntax (e....

Represents a static or instance method of a struct/union/class.

Abstract class common to all of the C++ "named"/"keyword" casts.

Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".

Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).

The null pointer literal (C++11 [lex.nullptr])

A call to an overloaded operator written using operator syntax.

Represents a list-initialization with parenthesis.

Represents a C++ pseudo-destructor (C++ [expr.pseudo]).

A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).

A rewritten comparison expression that was originally written using operator syntax.

An expression "T()" which creates an rvalue of a non-class type T.

A C++ static_cast expression (C++ [expr.static.cast]).

Implicit construction of a std::initializer_list object from an array temporary within list-initia...

Represents a C++ functional cast expression that builds a temporary object.

Represents the this expression in C++.

A C++ throw-expression (C++ [except.throw]).

CXXTryStmt - A C++ try block, including all handlers.

A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...

Describes an explicit type conversion that uses functional notion but could not be resolved because o...

A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

This captures a statement into a function.

CaseStmt - Represent a case statement.

static CharSourceRange getTokenRange(SourceRange R)

static void print(unsigned val, CharacterLiteralKind Kind, raw_ostream &OS)

ChooseExpr - GNU builtin-in function __builtin_choose_expr.

Represents a 'co_await' expression.

CompoundAssignOperator - For compound assignments (e.g.

CompoundLiteralExpr - [C99 6.5.2.5].

CompoundStmt - This represents a group of statements like { stmt stmt }.

Represents the specialization of a concept - evaluates to a prvalue of type bool.

ConditionalOperator - The ?: ternary operator.

ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...

ContinueStmt - This represents a continue.

ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...

Represents a 'co_return' statement in the C++ Coroutines TS.

Represents the body of a coroutine.

Represents a 'co_yield' expression.

A reference to a declared variable, function, enum, etc.

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

Decl - This represents one declaration (or definition), e.g.

static void printGroup(Decl **Begin, unsigned NumDecls, raw_ostream &Out, const PrintingPolicy &Policy, unsigned Indentation=0)

void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const

Represents a 'co_await' expression while the type of the promise is dependent.

A qualified reference to a name whose declaration cannot yet be resolved.

Represents a single C99 designator.

Represents a C99 designated initializer expression.

DoStmt - This represents a 'do/while' stmt.

void print(llvm::raw_ostream &OS, const PrintingPolicy &PP) const

Prints the node to the given output stream.

Represents a reference to #emded data.

Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...

This represents one expression.

An expression trait intrinsic.

ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...

Represents difference between two FPOptions values.

Represents a member of a struct/union/class.

bool isAnonymousStructOrUnion() const

Determines whether this field is a representative for an anonymous struct or union.

ForStmt - This represents a 'for (init;cond;inc)' stmt.

ArrayRef< ParmVarDecl * > parameters() const

bool isVariadic() const

Whether this function is variadic.

Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...

Represents a prototype with parameter type info, e.g.

void printExceptionSpecification(raw_ostream &OS, const PrintingPolicy &Policy) const

FunctionType - C99 6.7.5.3 - Function Declarators.

This represents a GCC inline-assembly statement extension.

GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...

Represents a C11 generic selection.

AssociationTy< false > Association

GotoStmt - This represents a direct goto.

This class represents temporary values used to represent inout and out arguments in HLSL.

One of these records is kept for each identifier that is lexed.

StringRef getName() const

Return the actual identifier string.

IfStmt - This represents an if/then/else.

ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....

ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...

Represents an implicitly-generated value initialization of an object of a given type.

IndirectGotoStmt - This represents an indirect goto.

Describes an C or C++ initializer list.

LabelStmt - Represents a label, which has a substatement.

Describes the capture of a variable or of this, or of a C++1y init-capture.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

llvm::RoundingMode RoundingMode

FPExceptionModeKind

Possible floating point exception behavior.

static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)

Returns a string for the source that the range encompasses.

This represents a Microsoft inline-assembly statement extension.

Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.

A member reference to an MSPropertyDecl.

MS property subscript expression.

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

A C++ nested-name-specifier augmented with source location information.

NestedNameSpecifier * getNestedNameSpecifier() const

Retrieve the nested-name-specifier to which this instance refers.

Represents a C++ nested name specifier, such as "\::std::vector::".

void print(raw_ostream &OS, const PrintingPolicy &Policy, bool ResolveTemplateArguments=false) const

Print this nested name specifier to the given output stream.

Represents a place-holder for an object not to be initialized by anything.

NullStmt - This is the null statement ";": C99 6.8.3p3.

An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......

This represents '#pragma omp atomic' directive.

This represents '#pragma omp barrier' directive.

This represents '#pragma omp cancel' directive.

This represents '#pragma omp cancellation point' directive.

Representation of an OpenMP canonical loop.

This represents '#pragma omp critical' directive.

This represents implicit clause 'depend' for the '#pragma omp task' directive.

This represents '#pragma omp depobj' directive.

This represents '#pragma omp dispatch' directive.

This represents '#pragma omp distribute' directive.

This represents '#pragma omp distribute parallel for' composite directive.

This represents '#pragma omp distribute parallel for simd' composite directive.

This represents '#pragma omp distribute simd' composite directive.

This represents '#pragma omp error' directive.

This is a basic class for representing single OpenMP executable directive.

This represents '#pragma omp flush' directive.

This represents '#pragma omp for' directive.

This represents '#pragma omp for simd' directive.

This represents '#pragma omp loop' directive.

Represents the '#pragma omp interchange' loop transformation directive.

This represents '#pragma omp interop' directive.

OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...

This represents '#pragma omp masked' directive.

This represents '#pragma omp masked taskloop' directive.

This represents '#pragma omp masked taskloop simd' directive.

This represents '#pragma omp master' directive.

This represents '#pragma omp master taskloop' directive.

This represents '#pragma omp master taskloop simd' directive.

This represents '#pragma omp ordered' directive.

This represents '#pragma omp parallel' directive.

This represents '#pragma omp parallel for' directive.

This represents '#pragma omp parallel for simd' directive.

This represents '#pragma omp parallel loop' directive.

This represents '#pragma omp parallel masked' directive.

This represents '#pragma omp parallel masked taskloop' directive.

This represents '#pragma omp parallel masked taskloop simd' directive.

This represents '#pragma omp parallel master' directive.

This represents '#pragma omp parallel master taskloop' directive.

This represents '#pragma omp parallel master taskloop simd' directive.

This represents '#pragma omp parallel sections' directive.

Represents the '#pragma omp reverse' loop transformation directive.

This represents '#pragma omp scan' directive.

This represents '#pragma omp scope' directive.

This represents '#pragma omp section' directive.

This represents '#pragma omp sections' directive.

This represents '#pragma omp simd' directive.

This represents '#pragma omp single' directive.

This represents '#pragma omp target data' directive.

This represents '#pragma omp target' directive.

This represents '#pragma omp target enter data' directive.

This represents '#pragma omp target exit data' directive.

This represents '#pragma omp target parallel' directive.

This represents '#pragma omp target parallel for' directive.

This represents '#pragma omp target parallel for simd' directive.

This represents '#pragma omp target parallel loop' directive.

This represents '#pragma omp target simd' directive.

This represents '#pragma omp target teams' directive.

This represents '#pragma omp target teams distribute' combined directive.

This represents '#pragma omp target teams distribute parallel for' combined directive.

This represents '#pragma omp target teams distribute parallel for simd' combined directive.

This represents '#pragma omp target teams distribute simd' combined directive.

This represents '#pragma omp target teams loop' directive.

This represents '#pragma omp target update' directive.

This represents '#pragma omp task' directive.

This represents '#pragma omp taskloop' directive.

This represents '#pragma omp taskloop simd' directive.

This represents '#pragma omp taskgroup' directive.

This represents '#pragma omp taskwait' directive.

This represents '#pragma omp taskyield' directive.

This represents '#pragma omp teams' directive.

This represents '#pragma omp teams distribute' directive.

This represents '#pragma omp teams distribute parallel for' composite directive.

This represents '#pragma omp teams distribute parallel for simd' composite directive.

This represents '#pragma omp teams distribute simd' combined directive.

This represents '#pragma omp teams loop' directive.

This represents the '#pragma omp tile' loop transformation directive.

This represents the '#pragma omp unroll' loop transformation directive.

ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...

Represents Objective-C's @catch statement.

Represents Objective-C's @finally statement.

Represents Objective-C's @synchronized statement.

Represents Objective-C's @throw statement.

Represents Objective-C's @try ... @catch ... @finally statement.

Represents Objective-C's @autoreleasepool Statement.

A runtime availability query.

ObjCBoolLiteralExpr - Objective-C Boolean Literal.

ObjCBoxedExpr - used for generalized expression boxing.

An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers,...

ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...

ObjCEncodeExpr, used for @encode in Objective-C.

Represents Objective-C's collection statement.

ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...

ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.

ObjCIvarRefExpr - A reference to an ObjC instance variable.

An expression that sends a message to the given Objective-C object or class.

Expr * getArg(unsigned Arg)

getArg - Return the specified argument.

Expr * getInstanceReceiver()

Returns the object expression (receiver) for an instance message, or null for a message that is not a...

Selector getSelector() const

@ SuperInstance

The receiver is the instance of the superclass object.

@ Instance

The receiver is an object instance.

@ SuperClass

The receiver is a superclass.

@ Class

The receiver is a class.

QualType getClassReceiver() const

Returns the type of a class message send, or NULL if the message is not a class message.

ReceiverKind getReceiverKind() const

Determine the kind of receiver that this message is being sent to.

unsigned getNumArgs() const

Return the number of actual arguments in this message, not counting the receiver.

ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.

ObjCProtocolExpr used for protocol expression in Objective-C.

ObjCSelectorExpr used for @selector in Objective-C.

ObjCStringLiteral, used for Objective-C string literals i.e.

ObjCSubscriptRefExpr - used for array and dictionary subscripting.

OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...

Helper class for OffsetOfExpr.

unsigned getArrayExprIndex() const

For an array element node, returns the index into the array of expressions.

IdentifierInfo * getFieldName() const

For a field or identifier offsetof node, returns the name of the field.

@ Array

An index into an array.

@ Base

An implicit indirection through a C++ base class, when the field found is in a base class.

Kind getKind() const

Determine what kind of offsetof node this is.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

This expression type represents an asterisk in an OpenACC Size-Expr, used in the 'tile' and 'gang' cl...

This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...

This is the base class for an OpenACC statement-level construct, other construct types are expected t...

This class represents a 'loop' construct.

Represents a C++11 pack expansion that produces a sequence of expressions.

ParenExpr - This represents a parenthesized expression, e.g.

Represents a parameter to a function.

[C99 6.4.2.2] - A predefined identifier such as func.

StringRef getIdentKindName() const

virtual bool handledStmt(Stmt *E, raw_ostream &OS)=0

PseudoObjectExpr - An expression which accesses a pseudo-object l-value.

A (possibly-)qualified type.

void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const

Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...

C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...

ReturnStmt - This represents a return, optionally of an expression: return; return 4;.

Represents a __leave statement.

SYCLKernelCallStmt represents the transformation that is applied to the body of a function declared w...

static std::string getPropertyNameFromSetterSelector(Selector Sel)

Return the property name for the given setter selector.

Smart pointer class that efficiently represents Objective-C method names.

StringRef getNameForSlot(unsigned argIndex) const

Retrieve the name at a given position in the selector.

const IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const

Retrieve the identifier at a given position in the selector.

bool isUnarySelector() const

unsigned getNumArgs() const

ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.

Represents an expression that computes the length of a parameter pack.

Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...

StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).

RetTy Visit(PTR(Stmt) S, ParamTys... P)

StmtVisitor - This class implements a simple visitor for Stmt subclasses.

Stmt - This represents one statement.

void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const

void printJson(raw_ostream &Out, PrinterHelper *Helper, const PrintingPolicy &Policy, bool AddQuotes) const

Pretty-prints in JSON format.

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

void printPrettyControlled(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const

llvm::iterator_range< child_iterator > child_range

void dumpPretty(const ASTContext &Context) const

dumpPretty/printPretty - These two methods do a "pretty print" of the AST back to its original source...

StringLiteral - This represents a string literal expression, e.g.

void outputString(raw_ostream &OS) const

Represents a reference to a non-type template parameter that has been substituted with a template arg...

Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...

SwitchStmt - This represents a 'switch' stmt.

A template argument list.

unsigned size() const

Retrieve the number of template arguments in this template argument list.

const TemplateArgument & get(unsigned Idx) const

Retrieve the template argument at a given index.

ArrayRef< TemplateArgument > asArray() const

Produce this as an array ref.

Represents a template argument.

ArrayRef< TemplateArgument > pack_elements() const

Iterator range referencing all of the elements of a template argument pack.

@ Pack

The template argument is actually a parameter pack.

ArgKind getKind() const

Return the kind of stored template argument.

Stores a list of template parameters for a TemplateDecl and its derived classes.

A container of type source information.

A type trait used in the implementation of various C++11 and Library TR1 trait templates.

const T * castAs() const

Member-template castAs.

TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...

UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

static StringRef getOpcodeStr(Opcode Op)

getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...

A reference to a name which we were able to look up during parsing but could not resolve to a specifi...

Represents a C++ member access expression for which lookup produced a set of overloaded functions.

A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....

@ LOK_String

operator "" X (const CharT *, size_t)

@ LOK_Raw

Raw form: operator "" X (const char *)

@ LOK_Floating

operator "" X (long double)

@ LOK_Integer

operator "" X (unsigned long long)

@ LOK_Template

Raw form: operator "" X<cs...> ()

@ LOK_Character

operator "" X (CharT)

Represents a call to the builtin function __builtin_va_arg.

@ CInit

C-style initialization with assignment.

@ CallInit

Call-style initialization (C++98)

WhileStmt - This represents a 'while' stmt.

A static requirement that can be used in a requires-expression to check properties of types and expre...

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

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

@ LCK_ByCopy

Capturing by copy (a.k.a., by value)

@ LCK_ByRef

Capturing by reference.

@ LCK_VLAType

Capturing variable-length array type.

@ LCK_StarThis

Capturing the *this object by copy.

@ LCK_This

Capturing the *this object by reference.

@ If

'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...

std::string JsonFormat(StringRef RawSR, bool AddQuotes)

const char * getTraitSpelling(ExpressionTrait T) LLVM_READONLY

Return the spelling of the type trait TT. Never null.

const FunctionProtoType * T

void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)

Print a template argument list, including the '<' and '>' enclosing the template arguments.

const char * getOperatorSpelling(OverloadedOperatorKind Operator)

Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword.

CXXNewInitializationStyle

const Expr * RHS

The original right-hand side.

BinaryOperatorKind Opcode

The original opcode, prior to rewriting.

const Expr * LHS

The original left-hand side.

Iterator range representation begin:end[:step].

An element in an Objective-C dictionary literal.

Describes how types, statements, expressions, and declarations should be printed.

unsigned Alignof

Whether we can use 'alignof' rather than '__alignof'.

unsigned CleanUglifiedParameters

Whether to strip underscores when printing reserved parameter names.

unsigned ConstantsAsWritten

Whether we should print the constant expressions as written in the sources.

unsigned IncludeNewlines

When true, include newlines after statements like "break", etc.

unsigned Indentation

The number of spaces to use to indent each line.

unsigned TerseOutput

Provide a 'terse' output.

unsigned UnderscoreAlignof

Whether we can use '_Alignof' rather than '__alignof'.

unsigned SuppressImplicitBase

When true, don't print the implicit 'self' or 'this' expressions.

Iterator for iterating over Stmt * arrays that contain only T *.