1 //===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file implements the Stmt::dumpPretty/Stmt::printPretty methods, which
10 // pretty print the AST back out to C code.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/Attr.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/DeclBase.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclObjC.h"
20 #include "clang/AST/DeclOpenMP.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/ExprObjC.h"
25 #include "clang/AST/ExprOpenMP.h"
26 #include "clang/AST/NestedNameSpecifier.h"
27 #include "clang/AST/OpenMPClause.h"
28 #include "clang/AST/PrettyPrinter.h"
29 #include "clang/AST/Stmt.h"
30 #include "clang/AST/StmtCXX.h"
31 #include "clang/AST/StmtObjC.h"
32 #include "clang/AST/StmtOpenMP.h"
33 #include "clang/AST/StmtVisitor.h"
34 #include "clang/AST/TemplateBase.h"
35 #include "clang/AST/Type.h"
36 #include "clang/Basic/CharInfo.h"
37 #include "clang/Basic/ExpressionTraits.h"
38 #include "clang/Basic/IdentifierTable.h"
39 #include "clang/Basic/JsonSupport.h"
40 #include "clang/Basic/LLVM.h"
41 #include "clang/Basic/Lambda.h"
42 #include "clang/Basic/OpenMPKinds.h"
43 #include "clang/Basic/OperatorKinds.h"
44 #include "clang/Basic/SourceLocation.h"
45 #include "clang/Basic/TypeTraits.h"
46 #include "clang/Lex/Lexer.h"
47 #include "llvm/ADT/ArrayRef.h"
48 #include "llvm/ADT/SmallString.h"
49 #include "llvm/ADT/SmallVector.h"
50 #include "llvm/ADT/StringRef.h"
51 #include "llvm/Support/Casting.h"
52 #include "llvm/Support/Compiler.h"
53 #include "llvm/Support/ErrorHandling.h"
54 #include "llvm/Support/Format.h"
55 #include "llvm/Support/raw_ostream.h"
59 using namespace clang;
61 //===----------------------------------------------------------------------===//
62 // StmtPrinter Visitor
63 //===----------------------------------------------------------------------===//
67 class StmtPrinter : public StmtVisitor<StmtPrinter> {
70 PrinterHelper* Helper;
71 PrintingPolicy Policy;
73 const ASTContext *Context;
76 StmtPrinter(raw_ostream &os, PrinterHelper *helper,
77 const PrintingPolicy &Policy, unsigned Indentation = 0,
79 const ASTContext *Context = nullptr)
80 : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy),
81 NL(NL), Context(Context) {}
83 void PrintStmt(Stmt *S) {
84 PrintStmt(S, Policy.Indentation);
87 void PrintStmt(Stmt *S, int SubIndent) {
88 IndentLevel += SubIndent;
89 if (S && isa<Expr>(S)) {
90 // If this is an expr used in a stmt context, indent and newline it.
97 Indent() << "<<<NULL STATEMENT>>>" << NL;
99 IndentLevel -= SubIndent;
102 void PrintInitStmt(Stmt *S, unsigned PrefixWidth) {
103 // FIXME: Cope better with odd prefix widths.
104 IndentLevel += (PrefixWidth + 1) / 2;
105 if (auto *DS = dyn_cast<DeclStmt>(S))
106 PrintRawDeclStmt(DS);
108 PrintExpr(cast<Expr>(S));
110 IndentLevel -= (PrefixWidth + 1) / 2;
113 void PrintControlledStmt(Stmt *S) {
114 if (auto *CS = dyn_cast<CompoundStmt>(S)) {
116 PrintRawCompoundStmt(CS);
124 void PrintRawCompoundStmt(CompoundStmt *S);
125 void PrintRawDecl(Decl *D);
126 void PrintRawDeclStmt(const DeclStmt *S);
127 void PrintRawIfStmt(IfStmt *If);
128 void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
129 void PrintCallArgs(CallExpr *E);
130 void PrintRawSEHExceptHandler(SEHExceptStmt *S);
131 void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
132 void PrintOMPExecutableDirective(OMPExecutableDirective *S,
133 bool ForceNoStmt = false);
135 void PrintExpr(Expr *E) {
142 raw_ostream &Indent(int Delta = 0) {
143 for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
148 void Visit(Stmt* S) {
149 if (Helper && Helper->handledStmt(S,OS))
151 else StmtVisitor<StmtPrinter>::Visit(S);
154 void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
155 Indent() << "<<unknown stmt type>>" << NL;
158 void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
159 OS << "<<unknown expr type>>";
162 void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
164 #define ABSTRACT_STMT(CLASS)
165 #define STMT(CLASS, PARENT) \
166 void Visit##CLASS(CLASS *Node);
167 #include "clang/AST/StmtNodes.inc"
172 //===----------------------------------------------------------------------===//
173 // Stmt printing methods.
174 //===----------------------------------------------------------------------===//
176 /// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
177 /// with no newline after the }.
178 void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
180 for (auto *I : Node->body())
186 void StmtPrinter::PrintRawDecl(Decl *D) {
187 D->print(OS, Policy, IndentLevel);
190 void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) {
191 SmallVector<Decl *, 2> Decls(S->decls());
192 Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel);
195 void StmtPrinter::VisitNullStmt(NullStmt *Node) {
196 Indent() << ";" << NL;
199 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
201 PrintRawDeclStmt(Node);
205 void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
207 PrintRawCompoundStmt(Node);
211 void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
212 Indent(-1) << "case ";
213 PrintExpr(Node->getLHS());
214 if (Node->getRHS()) {
216 PrintExpr(Node->getRHS());
220 PrintStmt(Node->getSubStmt(), 0);
223 void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
224 Indent(-1) << "default:" << NL;
225 PrintStmt(Node->getSubStmt(), 0);
228 void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
229 Indent(-1) << Node->getName() << ":" << NL;
230 PrintStmt(Node->getSubStmt(), 0);
233 void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
234 for (const auto *Attr : Node->getAttrs()) {
235 Attr->printPretty(OS, Policy);
238 PrintStmt(Node->getSubStmt(), 0);
241 void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
244 PrintInitStmt(If->getInit(), 4);
245 if (const DeclStmt *DS = If->getConditionVariableDeclStmt())
246 PrintRawDeclStmt(DS);
248 PrintExpr(If->getCond());
251 if (auto *CS = dyn_cast<CompoundStmt>(If->getThen())) {
253 PrintRawCompoundStmt(CS);
254 OS << (If->getElse() ? " " : NL);
257 PrintStmt(If->getThen());
258 if (If->getElse()) Indent();
261 if (Stmt *Else = If->getElse()) {
264 if (auto *CS = dyn_cast<CompoundStmt>(Else)) {
266 PrintRawCompoundStmt(CS);
268 } else if (auto *ElseIf = dyn_cast<IfStmt>(Else)) {
270 PrintRawIfStmt(ElseIf);
273 PrintStmt(If->getElse());
278 void StmtPrinter::VisitIfStmt(IfStmt *If) {
283 void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
284 Indent() << "switch (";
286 PrintInitStmt(Node->getInit(), 8);
287 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
288 PrintRawDeclStmt(DS);
290 PrintExpr(Node->getCond());
292 PrintControlledStmt(Node->getBody());
295 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
296 Indent() << "while (";
297 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
298 PrintRawDeclStmt(DS);
300 PrintExpr(Node->getCond());
302 PrintStmt(Node->getBody());
305 void StmtPrinter::VisitDoStmt(DoStmt *Node) {
307 if (auto *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
308 PrintRawCompoundStmt(CS);
312 PrintStmt(Node->getBody());
317 PrintExpr(Node->getCond());
321 void StmtPrinter::VisitForStmt(ForStmt *Node) {
324 PrintInitStmt(Node->getInit(), 5);
326 OS << (Node->getCond() ? "; " : ";");
328 PrintExpr(Node->getCond());
330 if (Node->getInc()) {
332 PrintExpr(Node->getInc());
335 PrintControlledStmt(Node->getBody());
338 void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
340 if (auto *DS = dyn_cast<DeclStmt>(Node->getElement()))
341 PrintRawDeclStmt(DS);
343 PrintExpr(cast<Expr>(Node->getElement()));
345 PrintExpr(Node->getCollection());
347 PrintControlledStmt(Node->getBody());
350 void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) {
353 PrintInitStmt(Node->getInit(), 5);
354 PrintingPolicy SubPolicy(Policy);
355 SubPolicy.SuppressInitializers = true;
356 Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel);
358 PrintExpr(Node->getRangeInit());
360 PrintControlledStmt(Node->getBody());
363 void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) {
365 if (Node->isIfExists())
366 OS << "__if_exists (";
368 OS << "__if_not_exists (";
370 if (NestedNameSpecifier *Qualifier
371 = Node->getQualifierLoc().getNestedNameSpecifier())
372 Qualifier->print(OS, Policy);
374 OS << Node->getNameInfo() << ") ";
376 PrintRawCompoundStmt(Node->getSubStmt());
379 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
380 Indent() << "goto " << Node->getLabel()->getName() << ";";
381 if (Policy.IncludeNewlines) OS << NL;
384 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
385 Indent() << "goto *";
386 PrintExpr(Node->getTarget());
388 if (Policy.IncludeNewlines) OS << NL;
391 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
392 Indent() << "continue;";
393 if (Policy.IncludeNewlines) OS << NL;
396 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
397 Indent() << "break;";
398 if (Policy.IncludeNewlines) OS << NL;
401 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
402 Indent() << "return";
403 if (Node->getRetValue()) {
405 PrintExpr(Node->getRetValue());
408 if (Policy.IncludeNewlines) OS << NL;
411 void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
414 if (Node->isVolatile())
417 if (Node->isAsmGoto())
421 VisitStringLiteral(Node->getAsmString());
424 if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
425 Node->getNumClobbers() != 0 || Node->getNumLabels() != 0)
428 for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
432 if (!Node->getOutputName(i).empty()) {
434 OS << Node->getOutputName(i);
438 VisitStringLiteral(Node->getOutputConstraintLiteral(i));
440 Visit(Node->getOutputExpr(i));
445 if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0 ||
446 Node->getNumLabels() != 0)
449 for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
453 if (!Node->getInputName(i).empty()) {
455 OS << Node->getInputName(i);
459 VisitStringLiteral(Node->getInputConstraintLiteral(i));
461 Visit(Node->getInputExpr(i));
466 if (Node->getNumClobbers() != 0 || Node->getNumLabels())
469 for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
473 VisitStringLiteral(Node->getClobberStringLiteral(i));
477 if (Node->getNumLabels() != 0)
480 for (unsigned i = 0, e = Node->getNumLabels(); i != e; ++i) {
483 OS << Node->getLabelName(i);
487 if (Policy.IncludeNewlines) OS << NL;
490 void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
491 // FIXME: Implement MS style inline asm statement printer.
492 Indent() << "__asm ";
493 if (Node->hasBraces())
495 OS << Node->getAsmString() << NL;
496 if (Node->hasBraces())
497 Indent() << "}" << NL;
500 void StmtPrinter::VisitCapturedStmt(CapturedStmt *Node) {
501 PrintStmt(Node->getCapturedDecl()->getBody());
504 void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
506 if (auto *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
507 PrintRawCompoundStmt(TS);
511 for (unsigned I = 0, N = Node->getNumCatchStmts(); I != N; ++I) {
512 ObjCAtCatchStmt *catchStmt = Node->getCatchStmt(I);
513 Indent() << "@catch(";
514 if (catchStmt->getCatchParamDecl()) {
515 if (Decl *DS = catchStmt->getCatchParamDecl())
519 if (auto *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody())) {
520 PrintRawCompoundStmt(CS);
525 if (auto *FS = static_cast<ObjCAtFinallyStmt *>(Node->getFinallyStmt())) {
526 Indent() << "@finally";
527 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
532 void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
535 void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
536 Indent() << "@catch (...) { /* todo */ } " << NL;
539 void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
540 Indent() << "@throw";
541 if (Node->getThrowExpr()) {
543 PrintExpr(Node->getThrowExpr());
548 void StmtPrinter::VisitObjCAvailabilityCheckExpr(
549 ObjCAvailabilityCheckExpr *Node) {
550 OS << "@available(...)";
553 void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
554 Indent() << "@synchronized (";
555 PrintExpr(Node->getSynchExpr());
557 PrintRawCompoundStmt(Node->getSynchBody());
561 void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) {
562 Indent() << "@autoreleasepool";
563 PrintRawCompoundStmt(dyn_cast<CompoundStmt>(Node->getSubStmt()));
567 void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
569 if (Decl *ExDecl = Node->getExceptionDecl())
570 PrintRawDecl(ExDecl);
574 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
577 void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
579 PrintRawCXXCatchStmt(Node);
583 void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
585 PrintRawCompoundStmt(Node->getTryBlock());
586 for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
588 PrintRawCXXCatchStmt(Node->getHandler(i));
593 void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) {
594 Indent() << (Node->getIsCXXTry() ? "try " : "__try ");
595 PrintRawCompoundStmt(Node->getTryBlock());
596 SEHExceptStmt *E = Node->getExceptHandler();
597 SEHFinallyStmt *F = Node->getFinallyHandler();
599 PrintRawSEHExceptHandler(E);
601 assert(F && "Must have a finally block...");
602 PrintRawSEHFinallyStmt(F);
607 void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) {
609 PrintRawCompoundStmt(Node->getBlock());
613 void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) {
615 VisitExpr(Node->getFilterExpr());
617 PrintRawCompoundStmt(Node->getBlock());
621 void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) {
623 PrintRawSEHExceptHandler(Node);
627 void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) {
629 PrintRawSEHFinallyStmt(Node);
633 void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) {
634 Indent() << "__leave;";
635 if (Policy.IncludeNewlines) OS << NL;
638 //===----------------------------------------------------------------------===//
639 // OpenMP directives printing methods
640 //===----------------------------------------------------------------------===//
642 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
644 OMPClausePrinter Printer(OS, Policy);
645 ArrayRef<OMPClause *> Clauses = S->clauses();
646 for (auto *Clause : Clauses)
647 if (Clause && !Clause->isImplicit()) {
649 Printer.Visit(Clause);
652 if (!ForceNoStmt && S->hasAssociatedStmt())
653 PrintStmt(S->getInnermostCapturedStmt()->getCapturedStmt());
656 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
657 Indent() << "#pragma omp parallel";
658 PrintOMPExecutableDirective(Node);
661 void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) {
662 Indent() << "#pragma omp simd";
663 PrintOMPExecutableDirective(Node);
666 void StmtPrinter::VisitOMPForDirective(OMPForDirective *Node) {
667 Indent() << "#pragma omp for";
668 PrintOMPExecutableDirective(Node);
671 void StmtPrinter::VisitOMPForSimdDirective(OMPForSimdDirective *Node) {
672 Indent() << "#pragma omp for simd";
673 PrintOMPExecutableDirective(Node);
676 void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) {
677 Indent() << "#pragma omp sections";
678 PrintOMPExecutableDirective(Node);
681 void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) {
682 Indent() << "#pragma omp section";
683 PrintOMPExecutableDirective(Node);
686 void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) {
687 Indent() << "#pragma omp single";
688 PrintOMPExecutableDirective(Node);
691 void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) {
692 Indent() << "#pragma omp master";
693 PrintOMPExecutableDirective(Node);
696 void StmtPrinter::VisitOMPCriticalDirective(OMPCriticalDirective *Node) {
697 Indent() << "#pragma omp critical";
698 if (Node->getDirectiveName().getName()) {
700 Node->getDirectiveName().printName(OS);
703 PrintOMPExecutableDirective(Node);
706 void StmtPrinter::VisitOMPParallelForDirective(OMPParallelForDirective *Node) {
707 Indent() << "#pragma omp parallel for";
708 PrintOMPExecutableDirective(Node);
711 void StmtPrinter::VisitOMPParallelForSimdDirective(
712 OMPParallelForSimdDirective *Node) {
713 Indent() << "#pragma omp parallel for simd";
714 PrintOMPExecutableDirective(Node);
717 void StmtPrinter::VisitOMPParallelSectionsDirective(
718 OMPParallelSectionsDirective *Node) {
719 Indent() << "#pragma omp parallel sections";
720 PrintOMPExecutableDirective(Node);
723 void StmtPrinter::VisitOMPTaskDirective(OMPTaskDirective *Node) {
724 Indent() << "#pragma omp task";
725 PrintOMPExecutableDirective(Node);
728 void StmtPrinter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *Node) {
729 Indent() << "#pragma omp taskyield";
730 PrintOMPExecutableDirective(Node);
733 void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) {
734 Indent() << "#pragma omp barrier";
735 PrintOMPExecutableDirective(Node);
738 void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) {
739 Indent() << "#pragma omp taskwait";
740 PrintOMPExecutableDirective(Node);
743 void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) {
744 Indent() << "#pragma omp taskgroup";
745 PrintOMPExecutableDirective(Node);
748 void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) {
749 Indent() << "#pragma omp flush";
750 PrintOMPExecutableDirective(Node);
753 void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) {
754 Indent() << "#pragma omp ordered";
755 PrintOMPExecutableDirective(Node, Node->hasClausesOfKind<OMPDependClause>());
758 void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) {
759 Indent() << "#pragma omp atomic";
760 PrintOMPExecutableDirective(Node);
763 void StmtPrinter::VisitOMPTargetDirective(OMPTargetDirective *Node) {
764 Indent() << "#pragma omp target";
765 PrintOMPExecutableDirective(Node);
768 void StmtPrinter::VisitOMPTargetDataDirective(OMPTargetDataDirective *Node) {
769 Indent() << "#pragma omp target data";
770 PrintOMPExecutableDirective(Node);
773 void StmtPrinter::VisitOMPTargetEnterDataDirective(
774 OMPTargetEnterDataDirective *Node) {
775 Indent() << "#pragma omp target enter data";
776 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
779 void StmtPrinter::VisitOMPTargetExitDataDirective(
780 OMPTargetExitDataDirective *Node) {
781 Indent() << "#pragma omp target exit data";
782 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
785 void StmtPrinter::VisitOMPTargetParallelDirective(
786 OMPTargetParallelDirective *Node) {
787 Indent() << "#pragma omp target parallel";
788 PrintOMPExecutableDirective(Node);
791 void StmtPrinter::VisitOMPTargetParallelForDirective(
792 OMPTargetParallelForDirective *Node) {
793 Indent() << "#pragma omp target parallel for";
794 PrintOMPExecutableDirective(Node);
797 void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) {
798 Indent() << "#pragma omp teams";
799 PrintOMPExecutableDirective(Node);
802 void StmtPrinter::VisitOMPCancellationPointDirective(
803 OMPCancellationPointDirective *Node) {
804 Indent() << "#pragma omp cancellation point "
805 << getOpenMPDirectiveName(Node->getCancelRegion());
806 PrintOMPExecutableDirective(Node);
809 void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) {
810 Indent() << "#pragma omp cancel "
811 << getOpenMPDirectiveName(Node->getCancelRegion());
812 PrintOMPExecutableDirective(Node);
815 void StmtPrinter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *Node) {
816 Indent() << "#pragma omp taskloop";
817 PrintOMPExecutableDirective(Node);
820 void StmtPrinter::VisitOMPTaskLoopSimdDirective(
821 OMPTaskLoopSimdDirective *Node) {
822 Indent() << "#pragma omp taskloop simd";
823 PrintOMPExecutableDirective(Node);
826 void StmtPrinter::VisitOMPDistributeDirective(OMPDistributeDirective *Node) {
827 Indent() << "#pragma omp distribute";
828 PrintOMPExecutableDirective(Node);
831 void StmtPrinter::VisitOMPTargetUpdateDirective(
832 OMPTargetUpdateDirective *Node) {
833 Indent() << "#pragma omp target update";
834 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
837 void StmtPrinter::VisitOMPDistributeParallelForDirective(
838 OMPDistributeParallelForDirective *Node) {
839 Indent() << "#pragma omp distribute parallel for";
840 PrintOMPExecutableDirective(Node);
843 void StmtPrinter::VisitOMPDistributeParallelForSimdDirective(
844 OMPDistributeParallelForSimdDirective *Node) {
845 Indent() << "#pragma omp distribute parallel for simd";
846 PrintOMPExecutableDirective(Node);
849 void StmtPrinter::VisitOMPDistributeSimdDirective(
850 OMPDistributeSimdDirective *Node) {
851 Indent() << "#pragma omp distribute simd";
852 PrintOMPExecutableDirective(Node);
855 void StmtPrinter::VisitOMPTargetParallelForSimdDirective(
856 OMPTargetParallelForSimdDirective *Node) {
857 Indent() << "#pragma omp target parallel for simd";
858 PrintOMPExecutableDirective(Node);
861 void StmtPrinter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *Node) {
862 Indent() << "#pragma omp target simd";
863 PrintOMPExecutableDirective(Node);
866 void StmtPrinter::VisitOMPTeamsDistributeDirective(
867 OMPTeamsDistributeDirective *Node) {
868 Indent() << "#pragma omp teams distribute";
869 PrintOMPExecutableDirective(Node);
872 void StmtPrinter::VisitOMPTeamsDistributeSimdDirective(
873 OMPTeamsDistributeSimdDirective *Node) {
874 Indent() << "#pragma omp teams distribute simd";
875 PrintOMPExecutableDirective(Node);
878 void StmtPrinter::VisitOMPTeamsDistributeParallelForSimdDirective(
879 OMPTeamsDistributeParallelForSimdDirective *Node) {
880 Indent() << "#pragma omp teams distribute parallel for simd";
881 PrintOMPExecutableDirective(Node);
884 void StmtPrinter::VisitOMPTeamsDistributeParallelForDirective(
885 OMPTeamsDistributeParallelForDirective *Node) {
886 Indent() << "#pragma omp teams distribute parallel for";
887 PrintOMPExecutableDirective(Node);
890 void StmtPrinter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *Node) {
891 Indent() << "#pragma omp target teams";
892 PrintOMPExecutableDirective(Node);
895 void StmtPrinter::VisitOMPTargetTeamsDistributeDirective(
896 OMPTargetTeamsDistributeDirective *Node) {
897 Indent() << "#pragma omp target teams distribute";
898 PrintOMPExecutableDirective(Node);
901 void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForDirective(
902 OMPTargetTeamsDistributeParallelForDirective *Node) {
903 Indent() << "#pragma omp target teams distribute parallel for";
904 PrintOMPExecutableDirective(Node);
907 void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
908 OMPTargetTeamsDistributeParallelForSimdDirective *Node) {
909 Indent() << "#pragma omp target teams distribute parallel for simd";
910 PrintOMPExecutableDirective(Node);
913 void StmtPrinter::VisitOMPTargetTeamsDistributeSimdDirective(
914 OMPTargetTeamsDistributeSimdDirective *Node) {
915 Indent() << "#pragma omp target teams distribute simd";
916 PrintOMPExecutableDirective(Node);
919 //===----------------------------------------------------------------------===//
920 // Expr printing methods.
921 //===----------------------------------------------------------------------===//
923 void StmtPrinter::VisitSourceLocExpr(SourceLocExpr *Node) {
924 OS << Node->getBuiltinStr() << "()";
927 void StmtPrinter::VisitConstantExpr(ConstantExpr *Node) {
928 PrintExpr(Node->getSubExpr());
931 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
932 if (const auto *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) {
933 OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy);
936 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
937 Qualifier->print(OS, Policy);
938 if (Node->hasTemplateKeyword())
940 OS << Node->getNameInfo();
941 if (Node->hasExplicitTemplateArgs())
942 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
945 void StmtPrinter::VisitDependentScopeDeclRefExpr(
946 DependentScopeDeclRefExpr *Node) {
947 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
948 Qualifier->print(OS, Policy);
949 if (Node->hasTemplateKeyword())
951 OS << Node->getNameInfo();
952 if (Node->hasExplicitTemplateArgs())
953 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
956 void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
957 if (Node->getQualifier())
958 Node->getQualifier()->print(OS, Policy);
959 if (Node->hasTemplateKeyword())
961 OS << Node->getNameInfo();
962 if (Node->hasExplicitTemplateArgs())
963 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
966 static bool isImplicitSelf(const Expr *E) {
967 if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
968 if (const auto *PD = dyn_cast<ImplicitParamDecl>(DRE->getDecl())) {
969 if (PD->getParameterKind() == ImplicitParamDecl::ObjCSelf &&
970 DRE->getBeginLoc().isInvalid())
977 void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
978 if (Node->getBase()) {
979 if (!Policy.SuppressImplicitBase ||
980 !isImplicitSelf(Node->getBase()->IgnoreImpCasts())) {
981 PrintExpr(Node->getBase());
982 OS << (Node->isArrow() ? "->" : ".");
985 OS << *Node->getDecl();
988 void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
989 if (Node->isSuperReceiver())
991 else if (Node->isObjectReceiver() && Node->getBase()) {
992 PrintExpr(Node->getBase());
994 } else if (Node->isClassReceiver() && Node->getClassReceiver()) {
995 OS << Node->getClassReceiver()->getName() << ".";
998 if (Node->isImplicitProperty()) {
999 if (const auto *Getter = Node->getImplicitPropertyGetter())
1000 Getter->getSelector().print(OS);
1002 OS << SelectorTable::getPropertyNameFromSetterSelector(
1003 Node->getImplicitPropertySetter()->getSelector());
1005 OS << Node->getExplicitProperty()->getName();
1008 void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) {
1009 PrintExpr(Node->getBaseExpr());
1011 PrintExpr(Node->getKeyExpr());
1015 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
1016 OS << PredefinedExpr::getIdentKindName(Node->getIdentKind());
1019 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
1020 unsigned value = Node->getValue();
1022 switch (Node->getKind()) {
1023 case CharacterLiteral::Ascii: break; // no prefix.
1024 case CharacterLiteral::Wide: OS << 'L'; break;
1025 case CharacterLiteral::UTF8: OS << "u8"; break;
1026 case CharacterLiteral::UTF16: OS << 'u'; break;
1027 case CharacterLiteral::UTF32: OS << 'U'; break;
1038 // TODO: K&R: the meaning of '\\a' is different in traditional C
1044 // Nonstandard escape sequence.
1064 // A character literal might be sign-extended, which
1065 // would result in an invalid \U escape sequence.
1066 // FIXME: multicharacter literals such as '\xFF\xFF\xFF\xFF'
1067 // are not correctly handled.
1068 if ((value & ~0xFFu) == ~0xFFu && Node->getKind() == CharacterLiteral::Ascii)
1070 if (value < 256 && isPrintable((unsigned char)value))
1071 OS << "'" << (char)value << "'";
1072 else if (value < 256)
1073 OS << "'\\x" << llvm::format("%02x", value) << "'";
1074 else if (value <= 0xFFFF)
1075 OS << "'\\u" << llvm::format("%04x", value) << "'";
1077 OS << "'\\U" << llvm::format("%08x", value) << "'";
1081 /// Prints the given expression using the original source text. Returns true on
1082 /// success, false otherwise.
1083 static bool printExprAsWritten(raw_ostream &OS, Expr *E,
1084 const ASTContext *Context) {
1087 bool Invalid = false;
1088 StringRef Source = Lexer::getSourceText(
1089 CharSourceRange::getTokenRange(E->getSourceRange()),
1090 Context->getSourceManager(), Context->getLangOpts(), &Invalid);
1098 void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
1099 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1101 bool isSigned = Node->getType()->isSignedIntegerType();
1102 OS << Node->getValue().toString(10, isSigned);
1104 // Emit suffixes. Integer literals are always a builtin integer type.
1105 switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
1106 default: llvm_unreachable("Unexpected type for integer literal!");
1107 case BuiltinType::Char_S:
1108 case BuiltinType::Char_U: OS << "i8"; break;
1109 case BuiltinType::UChar: OS << "Ui8"; break;
1110 case BuiltinType::Short: OS << "i16"; break;
1111 case BuiltinType::UShort: OS << "Ui16"; break;
1112 case BuiltinType::Int: break; // no suffix.
1113 case BuiltinType::UInt: OS << 'U'; break;
1114 case BuiltinType::Long: OS << 'L'; break;
1115 case BuiltinType::ULong: OS << "UL"; break;
1116 case BuiltinType::LongLong: OS << "LL"; break;
1117 case BuiltinType::ULongLong: OS << "ULL"; break;
1121 void StmtPrinter::VisitFixedPointLiteral(FixedPointLiteral *Node) {
1122 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1124 OS << Node->getValueAsString(/*Radix=*/10);
1126 switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
1127 default: llvm_unreachable("Unexpected type for fixed point literal!");
1128 case BuiltinType::ShortFract: OS << "hr"; break;
1129 case BuiltinType::ShortAccum: OS << "hk"; break;
1130 case BuiltinType::UShortFract: OS << "uhr"; break;
1131 case BuiltinType::UShortAccum: OS << "uhk"; break;
1132 case BuiltinType::Fract: OS << "r"; break;
1133 case BuiltinType::Accum: OS << "k"; break;
1134 case BuiltinType::UFract: OS << "ur"; break;
1135 case BuiltinType::UAccum: OS << "uk"; break;
1136 case BuiltinType::LongFract: OS << "lr"; break;
1137 case BuiltinType::LongAccum: OS << "lk"; break;
1138 case BuiltinType::ULongFract: OS << "ulr"; break;
1139 case BuiltinType::ULongAccum: OS << "ulk"; break;
1143 static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
1145 SmallString<16> Str;
1146 Node->getValue().toString(Str);
1148 if (Str.find_first_not_of("-0123456789") == StringRef::npos)
1149 OS << '.'; // Trailing dot in order to separate from ints.
1154 // Emit suffixes. Float literals are always a builtin float type.
1155 switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
1156 default: llvm_unreachable("Unexpected type for float literal!");
1157 case BuiltinType::Half: break; // FIXME: suffix?
1158 case BuiltinType::Double: break; // no suffix.
1159 case BuiltinType::Float16: OS << "F16"; break;
1160 case BuiltinType::Float: OS << 'F'; break;
1161 case BuiltinType::LongDouble: OS << 'L'; break;
1162 case BuiltinType::Float128: OS << 'Q'; break;
1166 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
1167 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1169 PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
1172 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
1173 PrintExpr(Node->getSubExpr());
1177 void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {
1178 Str->outputString(OS);
1181 void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
1183 PrintExpr(Node->getSubExpr());
1187 void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
1188 if (!Node->isPostfix()) {
1189 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1191 // Print a space if this is an "identifier operator" like __real, or if
1192 // it might be concatenated incorrectly like '+'.
1193 switch (Node->getOpcode()) {
1202 if (isa<UnaryOperator>(Node->getSubExpr()))
1207 PrintExpr(Node->getSubExpr());
1209 if (Node->isPostfix())
1210 OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1213 void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) {
1214 OS << "__builtin_offsetof(";
1215 Node->getTypeSourceInfo()->getType().print(OS, Policy);
1217 bool PrintedSomething = false;
1218 for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {
1219 OffsetOfNode ON = Node->getComponent(i);
1220 if (ON.getKind() == OffsetOfNode::Array) {
1223 PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex()));
1225 PrintedSomething = true;
1229 // Skip implicit base indirections.
1230 if (ON.getKind() == OffsetOfNode::Base)
1233 // Field or identifier node.
1234 IdentifierInfo *Id = ON.getFieldName();
1238 if (PrintedSomething)
1241 PrintedSomething = true;
1242 OS << Id->getName();
1247 void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){
1248 switch(Node->getKind()) {
1255 else if (Policy.UnderscoreAlignof)
1260 case UETT_PreferredAlignOf:
1266 case UETT_OpenMPRequiredSimdAlign:
1267 OS << "__builtin_omp_required_simd_align";
1270 if (Node->isArgumentType()) {
1272 Node->getArgumentType().print(OS, Policy);
1276 PrintExpr(Node->getArgumentExpr());
1280 void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
1282 PrintExpr(Node->getControllingExpr());
1283 for (const GenericSelectionExpr::Association &Assoc : Node->associations()) {
1285 QualType T = Assoc.getType();
1289 T.print(OS, Policy);
1291 PrintExpr(Assoc.getAssociationExpr());
1296 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
1297 PrintExpr(Node->getLHS());
1299 PrintExpr(Node->getRHS());
1303 void StmtPrinter::VisitOMPArraySectionExpr(OMPArraySectionExpr *Node) {
1304 PrintExpr(Node->getBase());
1306 if (Node->getLowerBound())
1307 PrintExpr(Node->getLowerBound());
1308 if (Node->getColonLoc().isValid()) {
1310 if (Node->getLength())
1311 PrintExpr(Node->getLength());
1316 void StmtPrinter::PrintCallArgs(CallExpr *Call) {
1317 for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
1318 if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
1319 // Don't print any defaulted arguments
1324 PrintExpr(Call->getArg(i));
1328 void StmtPrinter::VisitCallExpr(CallExpr *Call) {
1329 PrintExpr(Call->getCallee());
1331 PrintCallArgs(Call);
1335 static bool isImplicitThis(const Expr *E) {
1336 if (const auto *TE = dyn_cast<CXXThisExpr>(E))
1337 return TE->isImplicit();
1341 void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
1342 if (!Policy.SuppressImplicitBase || !isImplicitThis(Node->getBase())) {
1343 PrintExpr(Node->getBase());
1345 auto *ParentMember = dyn_cast<MemberExpr>(Node->getBase());
1346 FieldDecl *ParentDecl =
1347 ParentMember ? dyn_cast<FieldDecl>(ParentMember->getMemberDecl())
1350 if (!ParentDecl || !ParentDecl->isAnonymousStructOrUnion())
1351 OS << (Node->isArrow() ? "->" : ".");
1354 if (auto *FD = dyn_cast<FieldDecl>(Node->getMemberDecl()))
1355 if (FD->isAnonymousStructOrUnion())
1358 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1359 Qualifier->print(OS, Policy);
1360 if (Node->hasTemplateKeyword())
1362 OS << Node->getMemberNameInfo();
1363 if (Node->hasExplicitTemplateArgs())
1364 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
1367 void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) {
1368 PrintExpr(Node->getBase());
1369 OS << (Node->isArrow() ? "->isa" : ".isa");
1372 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
1373 PrintExpr(Node->getBase());
1375 OS << Node->getAccessor().getName();
1378 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
1380 Node->getTypeAsWritten().print(OS, Policy);
1382 PrintExpr(Node->getSubExpr());
1385 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
1387 Node->getType().print(OS, Policy);
1389 PrintExpr(Node->getInitializer());
1392 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
1393 // No need to print anything, simply forward to the subexpression.
1394 PrintExpr(Node->getSubExpr());
1397 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
1398 PrintExpr(Node->getLHS());
1399 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1400 PrintExpr(Node->getRHS());
1403 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
1404 PrintExpr(Node->getLHS());
1405 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1406 PrintExpr(Node->getRHS());
1409 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
1410 PrintExpr(Node->getCond());
1412 PrintExpr(Node->getLHS());
1414 PrintExpr(Node->getRHS());
1420 StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) {
1421 PrintExpr(Node->getCommon());
1423 PrintExpr(Node->getFalseExpr());
1426 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
1427 OS << "&&" << Node->getLabel()->getName();
1430 void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
1432 PrintRawCompoundStmt(E->getSubStmt());
1436 void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
1437 OS << "__builtin_choose_expr(";
1438 PrintExpr(Node->getCond());
1440 PrintExpr(Node->getLHS());
1442 PrintExpr(Node->getRHS());
1446 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
1450 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
1451 OS << "__builtin_shufflevector(";
1452 for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
1454 PrintExpr(Node->getExpr(i));
1459 void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) {
1460 OS << "__builtin_convertvector(";
1461 PrintExpr(Node->getSrcExpr());
1463 Node->getType().print(OS, Policy);
1467 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
1468 if (Node->getSyntacticForm()) {
1469 Visit(Node->getSyntacticForm());
1474 for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
1476 if (Node->getInit(i))
1477 PrintExpr(Node->getInit(i));
1484 void StmtPrinter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *Node) {
1485 // There's no way to express this expression in any of our supported
1486 // languages, so just emit something terse and (hopefully) clear.
1488 PrintExpr(Node->getSubExpr());
1492 void StmtPrinter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *Node) {
1496 void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) {
1498 for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
1500 PrintExpr(Node->getExpr(i));
1505 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
1506 bool NeedsEquals = true;
1507 for (const DesignatedInitExpr::Designator &D : Node->designators()) {
1508 if (D.isFieldDesignator()) {
1509 if (D.getDotLoc().isInvalid()) {
1510 if (IdentifierInfo *II = D.getFieldName()) {
1511 OS << II->getName() << ":";
1512 NeedsEquals = false;
1515 OS << "." << D.getFieldName()->getName();
1519 if (D.isArrayDesignator()) {
1520 PrintExpr(Node->getArrayIndex(D));
1522 PrintExpr(Node->getArrayRangeStart(D));
1524 PrintExpr(Node->getArrayRangeEnd(D));
1534 PrintExpr(Node->getInit());
1537 void StmtPrinter::VisitDesignatedInitUpdateExpr(
1538 DesignatedInitUpdateExpr *Node) {
1541 PrintExpr(Node->getBase());
1544 OS << "/*updater*/";
1545 PrintExpr(Node->getUpdater());
1549 void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) {
1550 OS << "/*no init*/";
1553 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
1554 if (Node->getType()->getAsCXXRecordDecl()) {
1555 OS << "/*implicit*/";
1556 Node->getType().print(OS, Policy);
1559 OS << "/*implicit*/(";
1560 Node->getType().print(OS, Policy);
1562 if (Node->getType()->isRecordType())
1569 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
1570 OS << "__builtin_va_arg(";
1571 PrintExpr(Node->getSubExpr());
1573 Node->getType().print(OS, Policy);
1577 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
1578 PrintExpr(Node->getSyntacticForm());
1581 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
1582 const char *Name = nullptr;
1583 switch (Node->getOp()) {
1584 #define BUILTIN(ID, TYPE, ATTRS)
1585 #define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
1586 case AtomicExpr::AO ## ID: \
1589 #include "clang/Basic/Builtins.def"
1593 // AtomicExpr stores its subexpressions in a permuted order.
1594 PrintExpr(Node->getPtr());
1595 if (Node->getOp() != AtomicExpr::AO__c11_atomic_load &&
1596 Node->getOp() != AtomicExpr::AO__atomic_load_n &&
1597 Node->getOp() != AtomicExpr::AO__opencl_atomic_load) {
1599 PrintExpr(Node->getVal1());
1601 if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||
1602 Node->isCmpXChg()) {
1604 PrintExpr(Node->getVal2());
1606 if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
1607 Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) {
1609 PrintExpr(Node->getWeak());
1611 if (Node->getOp() != AtomicExpr::AO__c11_atomic_init &&
1612 Node->getOp() != AtomicExpr::AO__opencl_atomic_init) {
1614 PrintExpr(Node->getOrder());
1616 if (Node->isCmpXChg()) {
1618 PrintExpr(Node->getOrderFail());
1624 void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
1625 OverloadedOperatorKind Kind = Node->getOperator();
1626 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
1627 if (Node->getNumArgs() == 1) {
1628 OS << getOperatorSpelling(Kind) << ' ';
1629 PrintExpr(Node->getArg(0));
1631 PrintExpr(Node->getArg(0));
1632 OS << ' ' << getOperatorSpelling(Kind);
1634 } else if (Kind == OO_Arrow) {
1635 PrintExpr(Node->getArg(0));
1636 } else if (Kind == OO_Call) {
1637 PrintExpr(Node->getArg(0));
1639 for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
1642 if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
1643 PrintExpr(Node->getArg(ArgIdx));
1646 } else if (Kind == OO_Subscript) {
1647 PrintExpr(Node->getArg(0));
1649 PrintExpr(Node->getArg(1));
1651 } else if (Node->getNumArgs() == 1) {
1652 OS << getOperatorSpelling(Kind) << ' ';
1653 PrintExpr(Node->getArg(0));
1654 } else if (Node->getNumArgs() == 2) {
1655 PrintExpr(Node->getArg(0));
1656 OS << ' ' << getOperatorSpelling(Kind) << ' ';
1657 PrintExpr(Node->getArg(1));
1659 llvm_unreachable("unknown overloaded operator");
1663 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
1664 // If we have a conversion operator call only print the argument.
1665 CXXMethodDecl *MD = Node->getMethodDecl();
1666 if (MD && isa<CXXConversionDecl>(MD)) {
1667 PrintExpr(Node->getImplicitObjectArgument());
1670 VisitCallExpr(cast<CallExpr>(Node));
1673 void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) {
1674 PrintExpr(Node->getCallee());
1676 PrintCallArgs(Node->getConfig());
1678 PrintCallArgs(Node);
1682 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
1683 OS << Node->getCastName() << '<';
1684 Node->getTypeAsWritten().print(OS, Policy);
1686 PrintExpr(Node->getSubExpr());
1690 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
1691 VisitCXXNamedCastExpr(Node);
1694 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
1695 VisitCXXNamedCastExpr(Node);
1698 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
1699 VisitCXXNamedCastExpr(Node);
1702 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
1703 VisitCXXNamedCastExpr(Node);
1706 void StmtPrinter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *Node) {
1707 OS << "__builtin_bit_cast(";
1708 Node->getTypeInfoAsWritten()->getType().print(OS, Policy);
1710 PrintExpr(Node->getSubExpr());
1714 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
1716 if (Node->isTypeOperand()) {
1717 Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
1719 PrintExpr(Node->getExprOperand());
1724 void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) {
1726 if (Node->isTypeOperand()) {
1727 Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
1729 PrintExpr(Node->getExprOperand());
1734 void StmtPrinter::VisitMSPropertyRefExpr(MSPropertyRefExpr *Node) {
1735 PrintExpr(Node->getBaseExpr());
1736 if (Node->isArrow())
1740 if (NestedNameSpecifier *Qualifier =
1741 Node->getQualifierLoc().getNestedNameSpecifier())
1742 Qualifier->print(OS, Policy);
1743 OS << Node->getPropertyDecl()->getDeclName();
1746 void StmtPrinter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *Node) {
1747 PrintExpr(Node->getBase());
1749 PrintExpr(Node->getIdx());
1753 void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) {
1754 switch (Node->getLiteralOperatorKind()) {
1755 case UserDefinedLiteral::LOK_Raw:
1756 OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
1758 case UserDefinedLiteral::LOK_Template: {
1759 const auto *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
1760 const TemplateArgumentList *Args =
1761 cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
1764 if (Args->size() != 1) {
1765 OS << "operator\"\"" << Node->getUDSuffix()->getName();
1766 printTemplateArgumentList(OS, Args->asArray(), Policy);
1771 const TemplateArgument &Pack = Args->get(0);
1772 for (const auto &P : Pack.pack_elements()) {
1773 char C = (char)P.getAsIntegral().getZExtValue();
1778 case UserDefinedLiteral::LOK_Integer: {
1779 // Print integer literal without suffix.
1780 const auto *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
1781 OS << Int->getValue().toString(10, /*isSigned*/false);
1784 case UserDefinedLiteral::LOK_Floating: {
1785 // Print floating literal without suffix.
1786 auto *Float = cast<FloatingLiteral>(Node->getCookedLiteral());
1787 PrintFloatingLiteral(OS, Float, /*PrintSuffix=*/false);
1790 case UserDefinedLiteral::LOK_String:
1791 case UserDefinedLiteral::LOK_Character:
1792 PrintExpr(Node->getCookedLiteral());
1795 OS << Node->getUDSuffix()->getName();
1798 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
1799 OS << (Node->getValue() ? "true" : "false");
1802 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
1806 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
1810 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
1811 if (!Node->getSubExpr())
1815 PrintExpr(Node->getSubExpr());
1819 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
1820 // Nothing to print: we picked up the default argument.
1823 void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) {
1824 // Nothing to print: we picked up the default initializer.
1827 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
1828 Node->getType().print(OS, Policy);
1829 // If there are no parens, this is list-initialization, and the braces are
1830 // part of the syntax of the inner construct.
1831 if (Node->getLParenLoc().isValid())
1833 PrintExpr(Node->getSubExpr());
1834 if (Node->getLParenLoc().isValid())
1838 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
1839 PrintExpr(Node->getSubExpr());
1842 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
1843 Node->getType().print(OS, Policy);
1844 if (Node->isStdInitListInitialization())
1845 /* Nothing to do; braces are part of creating the std::initializer_list. */;
1846 else if (Node->isListInitialization())
1850 for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
1851 ArgEnd = Node->arg_end();
1852 Arg != ArgEnd; ++Arg) {
1853 if ((*Arg)->isDefaultArgument())
1855 if (Arg != Node->arg_begin())
1859 if (Node->isStdInitListInitialization())
1861 else if (Node->isListInitialization())
1867 void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) {
1869 bool NeedComma = false;
1870 switch (Node->getCaptureDefault()) {
1884 for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
1885 CEnd = Node->explicit_capture_end();
1888 if (C->capturesVLAType())
1895 switch (C->getCaptureKind()) {
1905 if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C))
1907 OS << C->getCapturedVar()->getName();
1911 OS << C->getCapturedVar()->getName();
1915 llvm_unreachable("VLA type in explicit captures.");
1918 if (C->isPackExpansion())
1921 if (Node->isInitCapture(C))
1922 PrintExpr(C->getCapturedVar()->getInit());
1926 if (!Node->getExplicitTemplateParameters().empty()) {
1927 Node->getTemplateParameterList()->print(
1928 OS, Node->getLambdaClass()->getASTContext(),
1929 /*OmitTemplateKW*/true);
1932 if (Node->hasExplicitParameters()) {
1934 CXXMethodDecl *Method = Node->getCallOperator();
1936 for (const auto *P : Method->parameters()) {
1942 std::string ParamStr = P->getNameAsString();
1943 P->getOriginalType().print(OS, Policy, ParamStr);
1945 if (Method->isVariadic()) {
1952 if (Node->isMutable())
1955 auto *Proto = Method->getType()->getAs<FunctionProtoType>();
1956 Proto->printExceptionSpecification(OS, Policy);
1958 // FIXME: Attributes
1960 // Print the trailing return type if it was specified in the source.
1961 if (Node->hasExplicitResultType()) {
1963 Proto->getReturnType().print(OS, Policy);
1969 if (Policy.TerseOutput)
1972 PrintRawCompoundStmt(Node->getBody());
1975 void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) {
1976 if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo())
1977 TSInfo->getType().print(OS, Policy);
1979 Node->getType().print(OS, Policy);
1983 void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
1984 if (E->isGlobalNew())
1987 unsigned NumPlace = E->getNumPlacementArgs();
1988 if (NumPlace > 0 && !isa<CXXDefaultArgExpr>(E->getPlacementArg(0))) {
1990 PrintExpr(E->getPlacementArg(0));
1991 for (unsigned i = 1; i < NumPlace; ++i) {
1992 if (isa<CXXDefaultArgExpr>(E->getPlacementArg(i)))
1995 PrintExpr(E->getPlacementArg(i));
1999 if (E->isParenTypeId())
2002 if (Optional<Expr *> Size = E->getArraySize()) {
2003 llvm::raw_string_ostream s(TypeS);
2006 (*Size)->printPretty(s, Helper, Policy);
2009 E->getAllocatedType().print(OS, Policy, TypeS);
2010 if (E->isParenTypeId())
2013 CXXNewExpr::InitializationStyle InitStyle = E->getInitializationStyle();
2015 if (InitStyle == CXXNewExpr::CallInit)
2017 PrintExpr(E->getInitializer());
2018 if (InitStyle == CXXNewExpr::CallInit)
2023 void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
2024 if (E->isGlobalDelete())
2027 if (E->isArrayForm())
2029 PrintExpr(E->getArgument());
2032 void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
2033 PrintExpr(E->getBase());
2038 if (E->getQualifier())
2039 E->getQualifier()->print(OS, Policy);
2042 if (IdentifierInfo *II = E->getDestroyedTypeIdentifier())
2043 OS << II->getName();
2045 E->getDestroyedType().print(OS, Policy);
2048 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
2049 if (E->isListInitialization() && !E->isStdInitListInitialization())
2052 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
2053 if (isa<CXXDefaultArgExpr>(E->getArg(i))) {
2054 // Don't print any defaulted arguments
2059 PrintExpr(E->getArg(i));
2062 if (E->isListInitialization() && !E->isStdInitListInitialization())
2066 void StmtPrinter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
2067 // Parens are printed by the surrounding context.
2068 OS << "<forwarded>";
2071 void StmtPrinter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
2072 PrintExpr(E->getSubExpr());
2075 void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) {
2076 // Just forward to the subexpression.
2077 PrintExpr(E->getSubExpr());
2081 StmtPrinter::VisitCXXUnresolvedConstructExpr(
2082 CXXUnresolvedConstructExpr *Node) {
2083 Node->getTypeAsWritten().print(OS, Policy);
2085 for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
2086 ArgEnd = Node->arg_end();
2087 Arg != ArgEnd; ++Arg) {
2088 if (Arg != Node->arg_begin())
2095 void StmtPrinter::VisitCXXDependentScopeMemberExpr(
2096 CXXDependentScopeMemberExpr *Node) {
2097 if (!Node->isImplicitAccess()) {
2098 PrintExpr(Node->getBase());
2099 OS << (Node->isArrow() ? "->" : ".");
2101 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2102 Qualifier->print(OS, Policy);
2103 if (Node->hasTemplateKeyword())
2105 OS << Node->getMemberNameInfo();
2106 if (Node->hasExplicitTemplateArgs())
2107 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
2110 void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) {
2111 if (!Node->isImplicitAccess()) {
2112 PrintExpr(Node->getBase());
2113 OS << (Node->isArrow() ? "->" : ".");
2115 if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2116 Qualifier->print(OS, Policy);
2117 if (Node->hasTemplateKeyword())
2119 OS << Node->getMemberNameInfo();
2120 if (Node->hasExplicitTemplateArgs())
2121 printTemplateArgumentList(OS, Node->template_arguments(), Policy);
2124 static const char *getTypeTraitName(TypeTrait TT) {
2126 #define TYPE_TRAIT_1(Spelling, Name, Key) \
2127 case clang::UTT_##Name: return #Spelling;
2128 #define TYPE_TRAIT_2(Spelling, Name, Key) \
2129 case clang::BTT_##Name: return #Spelling;
2130 #define TYPE_TRAIT_N(Spelling, Name, Key) \
2131 case clang::TT_##Name: return #Spelling;
2132 #include "clang/Basic/TokenKinds.def"
2134 llvm_unreachable("Type trait not covered by switch");
2137 static const char *getTypeTraitName(ArrayTypeTrait ATT) {
2139 case ATT_ArrayRank: return "__array_rank";
2140 case ATT_ArrayExtent: return "__array_extent";
2142 llvm_unreachable("Array type trait not covered by switch");
2145 static const char *getExpressionTraitName(ExpressionTrait ET) {
2147 case ET_IsLValueExpr: return "__is_lvalue_expr";
2148 case ET_IsRValueExpr: return "__is_rvalue_expr";
2150 llvm_unreachable("Expression type trait not covered by switch");
2153 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
2154 OS << getTypeTraitName(E->getTrait()) << "(";
2155 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
2158 E->getArg(I)->getType().print(OS, Policy);
2163 void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2164 OS << getTypeTraitName(E->getTrait()) << '(';
2165 E->getQueriedType().print(OS, Policy);
2169 void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2170 OS << getExpressionTraitName(E->getTrait()) << '(';
2171 PrintExpr(E->getQueriedExpression());
2175 void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2177 PrintExpr(E->getOperand());
2181 void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) {
2182 PrintExpr(E->getPattern());
2186 void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2187 OS << "sizeof...(" << *E->getPack() << ")";
2190 void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(
2191 SubstNonTypeTemplateParmPackExpr *Node) {
2192 OS << *Node->getParameterPack();
2195 void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(
2196 SubstNonTypeTemplateParmExpr *Node) {
2197 Visit(Node->getReplacement());
2200 void StmtPrinter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2201 OS << *E->getParameterPack();
2204 void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){
2205 PrintExpr(Node->GetTemporaryExpr());
2208 void StmtPrinter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2211 PrintExpr(E->getLHS());
2212 OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
2216 OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
2217 PrintExpr(E->getRHS());
2222 // C++ Coroutines TS
2224 void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
2225 Visit(S->getBody());
2228 void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) {
2230 if (S->getOperand()) {
2232 Visit(S->getOperand());
2237 void StmtPrinter::VisitCoawaitExpr(CoawaitExpr *S) {
2239 PrintExpr(S->getOperand());
2242 void StmtPrinter::VisitDependentCoawaitExpr(DependentCoawaitExpr *S) {
2244 PrintExpr(S->getOperand());
2247 void StmtPrinter::VisitCoyieldExpr(CoyieldExpr *S) {
2249 PrintExpr(S->getOperand());
2254 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
2256 VisitStringLiteral(Node->getString());
2259 void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
2261 Visit(E->getSubExpr());
2264 void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
2266 ObjCArrayLiteral::child_range Ch = E->children();
2267 for (auto I = Ch.begin(), E = Ch.end(); I != E; ++I) {
2268 if (I != Ch.begin())
2275 void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
2277 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
2281 ObjCDictionaryElement Element = E->getKeyValueElement(I);
2284 Visit(Element.Value);
2285 if (Element.isPackExpansion())
2291 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
2293 Node->getEncodedType().print(OS, Policy);
2297 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
2299 Node->getSelector().print(OS);
2303 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
2304 OS << "@protocol(" << *Node->getProtocol() << ')';
2307 void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
2309 switch (Mess->getReceiverKind()) {
2310 case ObjCMessageExpr::Instance:
2311 PrintExpr(Mess->getInstanceReceiver());
2314 case ObjCMessageExpr::Class:
2315 Mess->getClassReceiver().print(OS, Policy);
2318 case ObjCMessageExpr::SuperInstance:
2319 case ObjCMessageExpr::SuperClass:
2325 Selector selector = Mess->getSelector();
2326 if (selector.isUnarySelector()) {
2327 OS << selector.getNameForSlot(0);
2329 for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
2330 if (i < selector.getNumArgs()) {
2331 if (i > 0) OS << ' ';
2332 if (selector.getIdentifierInfoForSlot(i))
2333 OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
2337 else OS << ", "; // Handle variadic methods.
2339 PrintExpr(Mess->getArg(i));
2345 void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) {
2346 OS << (Node->getValue() ? "__objc_yes" : "__objc_no");
2350 StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
2351 PrintExpr(E->getSubExpr());
2355 StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
2356 OS << '(' << E->getBridgeKindName();
2357 E->getType().print(OS, Policy);
2359 PrintExpr(E->getSubExpr());
2362 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
2363 BlockDecl *BD = Node->getBlockDecl();
2366 const FunctionType *AFT = Node->getFunctionType();
2368 if (isa<FunctionNoProtoType>(AFT)) {
2370 } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
2372 for (BlockDecl::param_iterator AI = BD->param_begin(),
2373 E = BD->param_end(); AI != E; ++AI) {
2374 if (AI != BD->param_begin()) OS << ", ";
2375 std::string ParamStr = (*AI)->getNameAsString();
2376 (*AI)->getType().print(OS, Policy, ParamStr);
2379 const auto *FT = cast<FunctionProtoType>(AFT);
2380 if (FT->isVariadic()) {
2381 if (!BD->param_empty()) OS << ", ";
2389 void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) {
2390 PrintExpr(Node->getSourceExpr());
2393 void StmtPrinter::VisitTypoExpr(TypoExpr *Node) {
2394 // TODO: Print something reasonable for a TypoExpr, if necessary.
2395 llvm_unreachable("Cannot print TypoExpr nodes");
2398 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
2399 OS << "__builtin_astype(";
2400 PrintExpr(Node->getSrcExpr());
2402 Node->getType().print(OS, Policy);
2406 //===----------------------------------------------------------------------===//
2407 // Stmt method implementations
2408 //===----------------------------------------------------------------------===//
2410 void Stmt::dumpPretty(const ASTContext &Context) const {
2411 printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts()));
2414 void Stmt::printPretty(raw_ostream &Out, PrinterHelper *Helper,
2415 const PrintingPolicy &Policy, unsigned Indentation,
2416 StringRef NL, const ASTContext *Context) const {
2417 StmtPrinter P(Out, Helper, Policy, Indentation, NL, Context);
2418 P.Visit(const_cast<Stmt *>(this));
2421 void Stmt::printJson(raw_ostream &Out, PrinterHelper *Helper,
2422 const PrintingPolicy &Policy, bool AddQuotes) const {
2424 llvm::raw_string_ostream TempOut(Buf);
2426 printPretty(TempOut, Helper, Policy);
2428 Out << JsonFormat(TempOut.str(), AddQuotes);
2431 //===----------------------------------------------------------------------===//
2433 //===----------------------------------------------------------------------===//
2435 // Implement virtual destructor.
2436 PrinterHelper::~PrinterHelper() = default;