xref: /freebsd/contrib/llvm-project/clang/lib/AST/StmtPrinter.cpp (revision cfd6422a5217410fbd66f7a7a8a64d9d85e61229)
1 //===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Stmt::dumpPretty/Stmt::printPretty methods, which
10 // pretty print the AST back out to C code.
11 //
12 //===----------------------------------------------------------------------===//
13 
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"
56 #include <cassert>
57 #include <string>
58 
59 using namespace clang;
60 
61 //===----------------------------------------------------------------------===//
62 // StmtPrinter Visitor
63 //===----------------------------------------------------------------------===//
64 
65 namespace {
66 
67   class StmtPrinter : public StmtVisitor<StmtPrinter> {
68     raw_ostream &OS;
69     unsigned IndentLevel;
70     PrinterHelper* Helper;
71     PrintingPolicy Policy;
72     std::string NL;
73     const ASTContext *Context;
74 
75   public:
76     StmtPrinter(raw_ostream &os, PrinterHelper *helper,
77                 const PrintingPolicy &Policy, unsigned Indentation = 0,
78                 StringRef NL = "\n", const ASTContext *Context = nullptr)
79         : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy),
80           NL(NL), Context(Context) {}
81 
82     void PrintStmt(Stmt *S) { PrintStmt(S, Policy.Indentation); }
83 
84     void PrintStmt(Stmt *S, int SubIndent) {
85       IndentLevel += SubIndent;
86       if (S && isa<Expr>(S)) {
87         // If this is an expr used in a stmt context, indent and newline it.
88         Indent();
89         Visit(S);
90         OS << ";" << NL;
91       } else if (S) {
92         Visit(S);
93       } else {
94         Indent() << "<<<NULL STATEMENT>>>" << NL;
95       }
96       IndentLevel -= SubIndent;
97     }
98 
99     void PrintInitStmt(Stmt *S, unsigned PrefixWidth) {
100       // FIXME: Cope better with odd prefix widths.
101       IndentLevel += (PrefixWidth + 1) / 2;
102       if (auto *DS = dyn_cast<DeclStmt>(S))
103         PrintRawDeclStmt(DS);
104       else
105         PrintExpr(cast<Expr>(S));
106       OS << "; ";
107       IndentLevel -= (PrefixWidth + 1) / 2;
108     }
109 
110     void PrintControlledStmt(Stmt *S) {
111       if (auto *CS = dyn_cast<CompoundStmt>(S)) {
112         OS << " ";
113         PrintRawCompoundStmt(CS);
114         OS << NL;
115       } else {
116         OS << NL;
117         PrintStmt(S);
118       }
119     }
120 
121     void PrintRawCompoundStmt(CompoundStmt *S);
122     void PrintRawDecl(Decl *D);
123     void PrintRawDeclStmt(const DeclStmt *S);
124     void PrintRawIfStmt(IfStmt *If);
125     void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
126     void PrintCallArgs(CallExpr *E);
127     void PrintRawSEHExceptHandler(SEHExceptStmt *S);
128     void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
129     void PrintOMPExecutableDirective(OMPExecutableDirective *S,
130                                      bool ForceNoStmt = false);
131 
132     void PrintExpr(Expr *E) {
133       if (E)
134         Visit(E);
135       else
136         OS << "<null expr>";
137     }
138 
139     raw_ostream &Indent(int Delta = 0) {
140       for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
141         OS << "  ";
142       return OS;
143     }
144 
145     void Visit(Stmt* S) {
146       if (Helper && Helper->handledStmt(S,OS))
147           return;
148       else StmtVisitor<StmtPrinter>::Visit(S);
149     }
150 
151     void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
152       Indent() << "<<unknown stmt type>>" << NL;
153     }
154 
155     void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
156       OS << "<<unknown expr type>>";
157     }
158 
159     void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
160 
161 #define ABSTRACT_STMT(CLASS)
162 #define STMT(CLASS, PARENT) \
163     void Visit##CLASS(CLASS *Node);
164 #include "clang/AST/StmtNodes.inc"
165   };
166 
167 } // namespace
168 
169 //===----------------------------------------------------------------------===//
170 //  Stmt printing methods.
171 //===----------------------------------------------------------------------===//
172 
173 /// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
174 /// with no newline after the }.
175 void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
176   OS << "{" << NL;
177   for (auto *I : Node->body())
178     PrintStmt(I);
179 
180   Indent() << "}";
181 }
182 
183 void StmtPrinter::PrintRawDecl(Decl *D) {
184   D->print(OS, Policy, IndentLevel);
185 }
186 
187 void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) {
188   SmallVector<Decl *, 2> Decls(S->decls());
189   Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel);
190 }
191 
192 void StmtPrinter::VisitNullStmt(NullStmt *Node) {
193   Indent() << ";" << NL;
194 }
195 
196 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
197   Indent();
198   PrintRawDeclStmt(Node);
199   OS << ";" << NL;
200 }
201 
202 void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
203   Indent();
204   PrintRawCompoundStmt(Node);
205   OS << "" << NL;
206 }
207 
208 void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
209   Indent(-1) << "case ";
210   PrintExpr(Node->getLHS());
211   if (Node->getRHS()) {
212     OS << " ... ";
213     PrintExpr(Node->getRHS());
214   }
215   OS << ":" << NL;
216 
217   PrintStmt(Node->getSubStmt(), 0);
218 }
219 
220 void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
221   Indent(-1) << "default:" << NL;
222   PrintStmt(Node->getSubStmt(), 0);
223 }
224 
225 void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
226   Indent(-1) << Node->getName() << ":" << NL;
227   PrintStmt(Node->getSubStmt(), 0);
228 }
229 
230 void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
231   for (const auto *Attr : Node->getAttrs()) {
232     Attr->printPretty(OS, Policy);
233   }
234 
235   PrintStmt(Node->getSubStmt(), 0);
236 }
237 
238 void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
239   OS << "if (";
240   if (If->getInit())
241     PrintInitStmt(If->getInit(), 4);
242   if (const DeclStmt *DS = If->getConditionVariableDeclStmt())
243     PrintRawDeclStmt(DS);
244   else
245     PrintExpr(If->getCond());
246   OS << ')';
247 
248   if (auto *CS = dyn_cast<CompoundStmt>(If->getThen())) {
249     OS << ' ';
250     PrintRawCompoundStmt(CS);
251     OS << (If->getElse() ? " " : NL);
252   } else {
253     OS << NL;
254     PrintStmt(If->getThen());
255     if (If->getElse()) Indent();
256   }
257 
258   if (Stmt *Else = If->getElse()) {
259     OS << "else";
260 
261     if (auto *CS = dyn_cast<CompoundStmt>(Else)) {
262       OS << ' ';
263       PrintRawCompoundStmt(CS);
264       OS << NL;
265     } else if (auto *ElseIf = dyn_cast<IfStmt>(Else)) {
266       OS << ' ';
267       PrintRawIfStmt(ElseIf);
268     } else {
269       OS << NL;
270       PrintStmt(If->getElse());
271     }
272   }
273 }
274 
275 void StmtPrinter::VisitIfStmt(IfStmt *If) {
276   Indent();
277   PrintRawIfStmt(If);
278 }
279 
280 void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
281   Indent() << "switch (";
282   if (Node->getInit())
283     PrintInitStmt(Node->getInit(), 8);
284   if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
285     PrintRawDeclStmt(DS);
286   else
287     PrintExpr(Node->getCond());
288   OS << ")";
289   PrintControlledStmt(Node->getBody());
290 }
291 
292 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
293   Indent() << "while (";
294   if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
295     PrintRawDeclStmt(DS);
296   else
297     PrintExpr(Node->getCond());
298   OS << ")" << NL;
299   PrintStmt(Node->getBody());
300 }
301 
302 void StmtPrinter::VisitDoStmt(DoStmt *Node) {
303   Indent() << "do ";
304   if (auto *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
305     PrintRawCompoundStmt(CS);
306     OS << " ";
307   } else {
308     OS << NL;
309     PrintStmt(Node->getBody());
310     Indent();
311   }
312 
313   OS << "while (";
314   PrintExpr(Node->getCond());
315   OS << ");" << NL;
316 }
317 
318 void StmtPrinter::VisitForStmt(ForStmt *Node) {
319   Indent() << "for (";
320   if (Node->getInit())
321     PrintInitStmt(Node->getInit(), 5);
322   else
323     OS << (Node->getCond() ? "; " : ";");
324   if (Node->getCond())
325     PrintExpr(Node->getCond());
326   OS << ";";
327   if (Node->getInc()) {
328     OS << " ";
329     PrintExpr(Node->getInc());
330   }
331   OS << ")";
332   PrintControlledStmt(Node->getBody());
333 }
334 
335 void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
336   Indent() << "for (";
337   if (auto *DS = dyn_cast<DeclStmt>(Node->getElement()))
338     PrintRawDeclStmt(DS);
339   else
340     PrintExpr(cast<Expr>(Node->getElement()));
341   OS << " in ";
342   PrintExpr(Node->getCollection());
343   OS << ")";
344   PrintControlledStmt(Node->getBody());
345 }
346 
347 void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) {
348   Indent() << "for (";
349   if (Node->getInit())
350     PrintInitStmt(Node->getInit(), 5);
351   PrintingPolicy SubPolicy(Policy);
352   SubPolicy.SuppressInitializers = true;
353   Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel);
354   OS << " : ";
355   PrintExpr(Node->getRangeInit());
356   OS << ")";
357   PrintControlledStmt(Node->getBody());
358 }
359 
360 void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) {
361   Indent();
362   if (Node->isIfExists())
363     OS << "__if_exists (";
364   else
365     OS << "__if_not_exists (";
366 
367   if (NestedNameSpecifier *Qualifier
368         = Node->getQualifierLoc().getNestedNameSpecifier())
369     Qualifier->print(OS, Policy);
370 
371   OS << Node->getNameInfo() << ") ";
372 
373   PrintRawCompoundStmt(Node->getSubStmt());
374 }
375 
376 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
377   Indent() << "goto " << Node->getLabel()->getName() << ";";
378   if (Policy.IncludeNewlines) OS << NL;
379 }
380 
381 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
382   Indent() << "goto *";
383   PrintExpr(Node->getTarget());
384   OS << ";";
385   if (Policy.IncludeNewlines) OS << NL;
386 }
387 
388 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
389   Indent() << "continue;";
390   if (Policy.IncludeNewlines) OS << NL;
391 }
392 
393 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
394   Indent() << "break;";
395   if (Policy.IncludeNewlines) OS << NL;
396 }
397 
398 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
399   Indent() << "return";
400   if (Node->getRetValue()) {
401     OS << " ";
402     PrintExpr(Node->getRetValue());
403   }
404   OS << ";";
405   if (Policy.IncludeNewlines) OS << NL;
406 }
407 
408 void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
409   Indent() << "asm ";
410 
411   if (Node->isVolatile())
412     OS << "volatile ";
413 
414   if (Node->isAsmGoto())
415     OS << "goto ";
416 
417   OS << "(";
418   VisitStringLiteral(Node->getAsmString());
419 
420   // Outputs
421   if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
422       Node->getNumClobbers() != 0 || Node->getNumLabels() != 0)
423     OS << " : ";
424 
425   for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
426     if (i != 0)
427       OS << ", ";
428 
429     if (!Node->getOutputName(i).empty()) {
430       OS << '[';
431       OS << Node->getOutputName(i);
432       OS << "] ";
433     }
434 
435     VisitStringLiteral(Node->getOutputConstraintLiteral(i));
436     OS << " (";
437     Visit(Node->getOutputExpr(i));
438     OS << ")";
439   }
440 
441   // Inputs
442   if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0 ||
443       Node->getNumLabels() != 0)
444     OS << " : ";
445 
446   for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
447     if (i != 0)
448       OS << ", ";
449 
450     if (!Node->getInputName(i).empty()) {
451       OS << '[';
452       OS << Node->getInputName(i);
453       OS << "] ";
454     }
455 
456     VisitStringLiteral(Node->getInputConstraintLiteral(i));
457     OS << " (";
458     Visit(Node->getInputExpr(i));
459     OS << ")";
460   }
461 
462   // Clobbers
463   if (Node->getNumClobbers() != 0 || Node->getNumLabels())
464     OS << " : ";
465 
466   for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
467     if (i != 0)
468       OS << ", ";
469 
470     VisitStringLiteral(Node->getClobberStringLiteral(i));
471   }
472 
473   // Labels
474   if (Node->getNumLabels() != 0)
475     OS << " : ";
476 
477   for (unsigned i = 0, e = Node->getNumLabels(); i != e; ++i) {
478     if (i != 0)
479       OS << ", ";
480     OS << Node->getLabelName(i);
481   }
482 
483   OS << ");";
484   if (Policy.IncludeNewlines) OS << NL;
485 }
486 
487 void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
488   // FIXME: Implement MS style inline asm statement printer.
489   Indent() << "__asm ";
490   if (Node->hasBraces())
491     OS << "{" << NL;
492   OS << Node->getAsmString() << NL;
493   if (Node->hasBraces())
494     Indent() << "}" << NL;
495 }
496 
497 void StmtPrinter::VisitCapturedStmt(CapturedStmt *Node) {
498   PrintStmt(Node->getCapturedDecl()->getBody());
499 }
500 
501 void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
502   Indent() << "@try";
503   if (auto *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
504     PrintRawCompoundStmt(TS);
505     OS << NL;
506   }
507 
508   for (unsigned I = 0, N = Node->getNumCatchStmts(); I != N; ++I) {
509     ObjCAtCatchStmt *catchStmt = Node->getCatchStmt(I);
510     Indent() << "@catch(";
511     if (catchStmt->getCatchParamDecl()) {
512       if (Decl *DS = catchStmt->getCatchParamDecl())
513         PrintRawDecl(DS);
514     }
515     OS << ")";
516     if (auto *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody())) {
517       PrintRawCompoundStmt(CS);
518       OS << NL;
519     }
520   }
521 
522   if (auto *FS = static_cast<ObjCAtFinallyStmt *>(Node->getFinallyStmt())) {
523     Indent() << "@finally";
524     PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
525     OS << NL;
526   }
527 }
528 
529 void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
530 }
531 
532 void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
533   Indent() << "@catch (...) { /* todo */ } " << NL;
534 }
535 
536 void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
537   Indent() << "@throw";
538   if (Node->getThrowExpr()) {
539     OS << " ";
540     PrintExpr(Node->getThrowExpr());
541   }
542   OS << ";" << NL;
543 }
544 
545 void StmtPrinter::VisitObjCAvailabilityCheckExpr(
546     ObjCAvailabilityCheckExpr *Node) {
547   OS << "@available(...)";
548 }
549 
550 void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
551   Indent() << "@synchronized (";
552   PrintExpr(Node->getSynchExpr());
553   OS << ")";
554   PrintRawCompoundStmt(Node->getSynchBody());
555   OS << NL;
556 }
557 
558 void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) {
559   Indent() << "@autoreleasepool";
560   PrintRawCompoundStmt(dyn_cast<CompoundStmt>(Node->getSubStmt()));
561   OS << NL;
562 }
563 
564 void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
565   OS << "catch (";
566   if (Decl *ExDecl = Node->getExceptionDecl())
567     PrintRawDecl(ExDecl);
568   else
569     OS << "...";
570   OS << ") ";
571   PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
572 }
573 
574 void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
575   Indent();
576   PrintRawCXXCatchStmt(Node);
577   OS << NL;
578 }
579 
580 void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
581   Indent() << "try ";
582   PrintRawCompoundStmt(Node->getTryBlock());
583   for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
584     OS << " ";
585     PrintRawCXXCatchStmt(Node->getHandler(i));
586   }
587   OS << NL;
588 }
589 
590 void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) {
591   Indent() << (Node->getIsCXXTry() ? "try " : "__try ");
592   PrintRawCompoundStmt(Node->getTryBlock());
593   SEHExceptStmt *E = Node->getExceptHandler();
594   SEHFinallyStmt *F = Node->getFinallyHandler();
595   if(E)
596     PrintRawSEHExceptHandler(E);
597   else {
598     assert(F && "Must have a finally block...");
599     PrintRawSEHFinallyStmt(F);
600   }
601   OS << NL;
602 }
603 
604 void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) {
605   OS << "__finally ";
606   PrintRawCompoundStmt(Node->getBlock());
607   OS << NL;
608 }
609 
610 void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) {
611   OS << "__except (";
612   VisitExpr(Node->getFilterExpr());
613   OS << ")" << NL;
614   PrintRawCompoundStmt(Node->getBlock());
615   OS << NL;
616 }
617 
618 void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) {
619   Indent();
620   PrintRawSEHExceptHandler(Node);
621   OS << NL;
622 }
623 
624 void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) {
625   Indent();
626   PrintRawSEHFinallyStmt(Node);
627   OS << NL;
628 }
629 
630 void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) {
631   Indent() << "__leave;";
632   if (Policy.IncludeNewlines) OS << NL;
633 }
634 
635 //===----------------------------------------------------------------------===//
636 //  OpenMP directives printing methods
637 //===----------------------------------------------------------------------===//
638 
639 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
640                                               bool ForceNoStmt) {
641   OMPClausePrinter Printer(OS, Policy);
642   ArrayRef<OMPClause *> Clauses = S->clauses();
643   for (auto *Clause : Clauses)
644     if (Clause && !Clause->isImplicit()) {
645       OS << ' ';
646       Printer.Visit(Clause);
647     }
648   OS << NL;
649   if (!ForceNoStmt && S->hasAssociatedStmt())
650     PrintStmt(S->getInnermostCapturedStmt()->getCapturedStmt());
651 }
652 
653 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
654   Indent() << "#pragma omp parallel";
655   PrintOMPExecutableDirective(Node);
656 }
657 
658 void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) {
659   Indent() << "#pragma omp simd";
660   PrintOMPExecutableDirective(Node);
661 }
662 
663 void StmtPrinter::VisitOMPForDirective(OMPForDirective *Node) {
664   Indent() << "#pragma omp for";
665   PrintOMPExecutableDirective(Node);
666 }
667 
668 void StmtPrinter::VisitOMPForSimdDirective(OMPForSimdDirective *Node) {
669   Indent() << "#pragma omp for simd";
670   PrintOMPExecutableDirective(Node);
671 }
672 
673 void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) {
674   Indent() << "#pragma omp sections";
675   PrintOMPExecutableDirective(Node);
676 }
677 
678 void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) {
679   Indent() << "#pragma omp section";
680   PrintOMPExecutableDirective(Node);
681 }
682 
683 void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) {
684   Indent() << "#pragma omp single";
685   PrintOMPExecutableDirective(Node);
686 }
687 
688 void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) {
689   Indent() << "#pragma omp master";
690   PrintOMPExecutableDirective(Node);
691 }
692 
693 void StmtPrinter::VisitOMPCriticalDirective(OMPCriticalDirective *Node) {
694   Indent() << "#pragma omp critical";
695   if (Node->getDirectiveName().getName()) {
696     OS << " (";
697     Node->getDirectiveName().printName(OS, Policy);
698     OS << ")";
699   }
700   PrintOMPExecutableDirective(Node);
701 }
702 
703 void StmtPrinter::VisitOMPParallelForDirective(OMPParallelForDirective *Node) {
704   Indent() << "#pragma omp parallel for";
705   PrintOMPExecutableDirective(Node);
706 }
707 
708 void StmtPrinter::VisitOMPParallelForSimdDirective(
709     OMPParallelForSimdDirective *Node) {
710   Indent() << "#pragma omp parallel for simd";
711   PrintOMPExecutableDirective(Node);
712 }
713 
714 void StmtPrinter::VisitOMPParallelMasterDirective(
715     OMPParallelMasterDirective *Node) {
716   Indent() << "#pragma omp parallel master";
717   PrintOMPExecutableDirective(Node);
718 }
719 
720 void StmtPrinter::VisitOMPParallelSectionsDirective(
721     OMPParallelSectionsDirective *Node) {
722   Indent() << "#pragma omp parallel sections";
723   PrintOMPExecutableDirective(Node);
724 }
725 
726 void StmtPrinter::VisitOMPTaskDirective(OMPTaskDirective *Node) {
727   Indent() << "#pragma omp task";
728   PrintOMPExecutableDirective(Node);
729 }
730 
731 void StmtPrinter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *Node) {
732   Indent() << "#pragma omp taskyield";
733   PrintOMPExecutableDirective(Node);
734 }
735 
736 void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) {
737   Indent() << "#pragma omp barrier";
738   PrintOMPExecutableDirective(Node);
739 }
740 
741 void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) {
742   Indent() << "#pragma omp taskwait";
743   PrintOMPExecutableDirective(Node);
744 }
745 
746 void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) {
747   Indent() << "#pragma omp taskgroup";
748   PrintOMPExecutableDirective(Node);
749 }
750 
751 void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) {
752   Indent() << "#pragma omp flush";
753   PrintOMPExecutableDirective(Node);
754 }
755 
756 void StmtPrinter::VisitOMPDepobjDirective(OMPDepobjDirective *Node) {
757   Indent() << "#pragma omp depobj";
758   PrintOMPExecutableDirective(Node);
759 }
760 
761 void StmtPrinter::VisitOMPScanDirective(OMPScanDirective *Node) {
762   Indent() << "#pragma omp scan";
763   PrintOMPExecutableDirective(Node);
764 }
765 
766 void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) {
767   Indent() << "#pragma omp ordered";
768   PrintOMPExecutableDirective(Node, Node->hasClausesOfKind<OMPDependClause>());
769 }
770 
771 void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) {
772   Indent() << "#pragma omp atomic";
773   PrintOMPExecutableDirective(Node);
774 }
775 
776 void StmtPrinter::VisitOMPTargetDirective(OMPTargetDirective *Node) {
777   Indent() << "#pragma omp target";
778   PrintOMPExecutableDirective(Node);
779 }
780 
781 void StmtPrinter::VisitOMPTargetDataDirective(OMPTargetDataDirective *Node) {
782   Indent() << "#pragma omp target data";
783   PrintOMPExecutableDirective(Node);
784 }
785 
786 void StmtPrinter::VisitOMPTargetEnterDataDirective(
787     OMPTargetEnterDataDirective *Node) {
788   Indent() << "#pragma omp target enter data";
789   PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
790 }
791 
792 void StmtPrinter::VisitOMPTargetExitDataDirective(
793     OMPTargetExitDataDirective *Node) {
794   Indent() << "#pragma omp target exit data";
795   PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
796 }
797 
798 void StmtPrinter::VisitOMPTargetParallelDirective(
799     OMPTargetParallelDirective *Node) {
800   Indent() << "#pragma omp target parallel";
801   PrintOMPExecutableDirective(Node);
802 }
803 
804 void StmtPrinter::VisitOMPTargetParallelForDirective(
805     OMPTargetParallelForDirective *Node) {
806   Indent() << "#pragma omp target parallel for";
807   PrintOMPExecutableDirective(Node);
808 }
809 
810 void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) {
811   Indent() << "#pragma omp teams";
812   PrintOMPExecutableDirective(Node);
813 }
814 
815 void StmtPrinter::VisitOMPCancellationPointDirective(
816     OMPCancellationPointDirective *Node) {
817   Indent() << "#pragma omp cancellation point "
818            << getOpenMPDirectiveName(Node->getCancelRegion());
819   PrintOMPExecutableDirective(Node);
820 }
821 
822 void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) {
823   Indent() << "#pragma omp cancel "
824            << getOpenMPDirectiveName(Node->getCancelRegion());
825   PrintOMPExecutableDirective(Node);
826 }
827 
828 void StmtPrinter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *Node) {
829   Indent() << "#pragma omp taskloop";
830   PrintOMPExecutableDirective(Node);
831 }
832 
833 void StmtPrinter::VisitOMPTaskLoopSimdDirective(
834     OMPTaskLoopSimdDirective *Node) {
835   Indent() << "#pragma omp taskloop simd";
836   PrintOMPExecutableDirective(Node);
837 }
838 
839 void StmtPrinter::VisitOMPMasterTaskLoopDirective(
840     OMPMasterTaskLoopDirective *Node) {
841   Indent() << "#pragma omp master taskloop";
842   PrintOMPExecutableDirective(Node);
843 }
844 
845 void StmtPrinter::VisitOMPMasterTaskLoopSimdDirective(
846     OMPMasterTaskLoopSimdDirective *Node) {
847   Indent() << "#pragma omp master taskloop simd";
848   PrintOMPExecutableDirective(Node);
849 }
850 
851 void StmtPrinter::VisitOMPParallelMasterTaskLoopDirective(
852     OMPParallelMasterTaskLoopDirective *Node) {
853   Indent() << "#pragma omp parallel master taskloop";
854   PrintOMPExecutableDirective(Node);
855 }
856 
857 void StmtPrinter::VisitOMPParallelMasterTaskLoopSimdDirective(
858     OMPParallelMasterTaskLoopSimdDirective *Node) {
859   Indent() << "#pragma omp parallel master taskloop simd";
860   PrintOMPExecutableDirective(Node);
861 }
862 
863 void StmtPrinter::VisitOMPDistributeDirective(OMPDistributeDirective *Node) {
864   Indent() << "#pragma omp distribute";
865   PrintOMPExecutableDirective(Node);
866 }
867 
868 void StmtPrinter::VisitOMPTargetUpdateDirective(
869     OMPTargetUpdateDirective *Node) {
870   Indent() << "#pragma omp target update";
871   PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true);
872 }
873 
874 void StmtPrinter::VisitOMPDistributeParallelForDirective(
875     OMPDistributeParallelForDirective *Node) {
876   Indent() << "#pragma omp distribute parallel for";
877   PrintOMPExecutableDirective(Node);
878 }
879 
880 void StmtPrinter::VisitOMPDistributeParallelForSimdDirective(
881     OMPDistributeParallelForSimdDirective *Node) {
882   Indent() << "#pragma omp distribute parallel for simd";
883   PrintOMPExecutableDirective(Node);
884 }
885 
886 void StmtPrinter::VisitOMPDistributeSimdDirective(
887     OMPDistributeSimdDirective *Node) {
888   Indent() << "#pragma omp distribute simd";
889   PrintOMPExecutableDirective(Node);
890 }
891 
892 void StmtPrinter::VisitOMPTargetParallelForSimdDirective(
893     OMPTargetParallelForSimdDirective *Node) {
894   Indent() << "#pragma omp target parallel for simd";
895   PrintOMPExecutableDirective(Node);
896 }
897 
898 void StmtPrinter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *Node) {
899   Indent() << "#pragma omp target simd";
900   PrintOMPExecutableDirective(Node);
901 }
902 
903 void StmtPrinter::VisitOMPTeamsDistributeDirective(
904     OMPTeamsDistributeDirective *Node) {
905   Indent() << "#pragma omp teams distribute";
906   PrintOMPExecutableDirective(Node);
907 }
908 
909 void StmtPrinter::VisitOMPTeamsDistributeSimdDirective(
910     OMPTeamsDistributeSimdDirective *Node) {
911   Indent() << "#pragma omp teams distribute simd";
912   PrintOMPExecutableDirective(Node);
913 }
914 
915 void StmtPrinter::VisitOMPTeamsDistributeParallelForSimdDirective(
916     OMPTeamsDistributeParallelForSimdDirective *Node) {
917   Indent() << "#pragma omp teams distribute parallel for simd";
918   PrintOMPExecutableDirective(Node);
919 }
920 
921 void StmtPrinter::VisitOMPTeamsDistributeParallelForDirective(
922     OMPTeamsDistributeParallelForDirective *Node) {
923   Indent() << "#pragma omp teams distribute parallel for";
924   PrintOMPExecutableDirective(Node);
925 }
926 
927 void StmtPrinter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *Node) {
928   Indent() << "#pragma omp target teams";
929   PrintOMPExecutableDirective(Node);
930 }
931 
932 void StmtPrinter::VisitOMPTargetTeamsDistributeDirective(
933     OMPTargetTeamsDistributeDirective *Node) {
934   Indent() << "#pragma omp target teams distribute";
935   PrintOMPExecutableDirective(Node);
936 }
937 
938 void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForDirective(
939     OMPTargetTeamsDistributeParallelForDirective *Node) {
940   Indent() << "#pragma omp target teams distribute parallel for";
941   PrintOMPExecutableDirective(Node);
942 }
943 
944 void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
945     OMPTargetTeamsDistributeParallelForSimdDirective *Node) {
946   Indent() << "#pragma omp target teams distribute parallel for simd";
947   PrintOMPExecutableDirective(Node);
948 }
949 
950 void StmtPrinter::VisitOMPTargetTeamsDistributeSimdDirective(
951     OMPTargetTeamsDistributeSimdDirective *Node) {
952   Indent() << "#pragma omp target teams distribute simd";
953   PrintOMPExecutableDirective(Node);
954 }
955 
956 //===----------------------------------------------------------------------===//
957 //  Expr printing methods.
958 //===----------------------------------------------------------------------===//
959 
960 void StmtPrinter::VisitSourceLocExpr(SourceLocExpr *Node) {
961   OS << Node->getBuiltinStr() << "()";
962 }
963 
964 void StmtPrinter::VisitConstantExpr(ConstantExpr *Node) {
965   PrintExpr(Node->getSubExpr());
966 }
967 
968 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
969   if (const auto *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) {
970     OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy);
971     return;
972   }
973   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
974     Qualifier->print(OS, Policy);
975   if (Node->hasTemplateKeyword())
976     OS << "template ";
977   OS << Node->getNameInfo();
978   if (Node->hasExplicitTemplateArgs())
979     printTemplateArgumentList(OS, Node->template_arguments(), Policy);
980 }
981 
982 void StmtPrinter::VisitDependentScopeDeclRefExpr(
983                                            DependentScopeDeclRefExpr *Node) {
984   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
985     Qualifier->print(OS, Policy);
986   if (Node->hasTemplateKeyword())
987     OS << "template ";
988   OS << Node->getNameInfo();
989   if (Node->hasExplicitTemplateArgs())
990     printTemplateArgumentList(OS, Node->template_arguments(), Policy);
991 }
992 
993 void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
994   if (Node->getQualifier())
995     Node->getQualifier()->print(OS, Policy);
996   if (Node->hasTemplateKeyword())
997     OS << "template ";
998   OS << Node->getNameInfo();
999   if (Node->hasExplicitTemplateArgs())
1000     printTemplateArgumentList(OS, Node->template_arguments(), Policy);
1001 }
1002 
1003 static bool isImplicitSelf(const Expr *E) {
1004   if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
1005     if (const auto *PD = dyn_cast<ImplicitParamDecl>(DRE->getDecl())) {
1006       if (PD->getParameterKind() == ImplicitParamDecl::ObjCSelf &&
1007           DRE->getBeginLoc().isInvalid())
1008         return true;
1009     }
1010   }
1011   return false;
1012 }
1013 
1014 void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
1015   if (Node->getBase()) {
1016     if (!Policy.SuppressImplicitBase ||
1017         !isImplicitSelf(Node->getBase()->IgnoreImpCasts())) {
1018       PrintExpr(Node->getBase());
1019       OS << (Node->isArrow() ? "->" : ".");
1020     }
1021   }
1022   OS << *Node->getDecl();
1023 }
1024 
1025 void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
1026   if (Node->isSuperReceiver())
1027     OS << "super.";
1028   else if (Node->isObjectReceiver() && Node->getBase()) {
1029     PrintExpr(Node->getBase());
1030     OS << ".";
1031   } else if (Node->isClassReceiver() && Node->getClassReceiver()) {
1032     OS << Node->getClassReceiver()->getName() << ".";
1033   }
1034 
1035   if (Node->isImplicitProperty()) {
1036     if (const auto *Getter = Node->getImplicitPropertyGetter())
1037       Getter->getSelector().print(OS);
1038     else
1039       OS << SelectorTable::getPropertyNameFromSetterSelector(
1040           Node->getImplicitPropertySetter()->getSelector());
1041   } else
1042     OS << Node->getExplicitProperty()->getName();
1043 }
1044 
1045 void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) {
1046   PrintExpr(Node->getBaseExpr());
1047   OS << "[";
1048   PrintExpr(Node->getKeyExpr());
1049   OS << "]";
1050 }
1051 
1052 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
1053   OS << PredefinedExpr::getIdentKindName(Node->getIdentKind());
1054 }
1055 
1056 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
1057   unsigned value = Node->getValue();
1058 
1059   switch (Node->getKind()) {
1060   case CharacterLiteral::Ascii: break; // no prefix.
1061   case CharacterLiteral::Wide:  OS << 'L'; break;
1062   case CharacterLiteral::UTF8:  OS << "u8"; break;
1063   case CharacterLiteral::UTF16: OS << 'u'; break;
1064   case CharacterLiteral::UTF32: OS << 'U'; break;
1065   }
1066 
1067   switch (value) {
1068   case '\\':
1069     OS << "'\\\\'";
1070     break;
1071   case '\'':
1072     OS << "'\\''";
1073     break;
1074   case '\a':
1075     // TODO: K&R: the meaning of '\\a' is different in traditional C
1076     OS << "'\\a'";
1077     break;
1078   case '\b':
1079     OS << "'\\b'";
1080     break;
1081   // Nonstandard escape sequence.
1082   /*case '\e':
1083     OS << "'\\e'";
1084     break;*/
1085   case '\f':
1086     OS << "'\\f'";
1087     break;
1088   case '\n':
1089     OS << "'\\n'";
1090     break;
1091   case '\r':
1092     OS << "'\\r'";
1093     break;
1094   case '\t':
1095     OS << "'\\t'";
1096     break;
1097   case '\v':
1098     OS << "'\\v'";
1099     break;
1100   default:
1101     // A character literal might be sign-extended, which
1102     // would result in an invalid \U escape sequence.
1103     // FIXME: multicharacter literals such as '\xFF\xFF\xFF\xFF'
1104     // are not correctly handled.
1105     if ((value & ~0xFFu) == ~0xFFu && Node->getKind() == CharacterLiteral::Ascii)
1106       value &= 0xFFu;
1107     if (value < 256 && isPrintable((unsigned char)value))
1108       OS << "'" << (char)value << "'";
1109     else if (value < 256)
1110       OS << "'\\x" << llvm::format("%02x", value) << "'";
1111     else if (value <= 0xFFFF)
1112       OS << "'\\u" << llvm::format("%04x", value) << "'";
1113     else
1114       OS << "'\\U" << llvm::format("%08x", value) << "'";
1115   }
1116 }
1117 
1118 /// Prints the given expression using the original source text. Returns true on
1119 /// success, false otherwise.
1120 static bool printExprAsWritten(raw_ostream &OS, Expr *E,
1121                                const ASTContext *Context) {
1122   if (!Context)
1123     return false;
1124   bool Invalid = false;
1125   StringRef Source = Lexer::getSourceText(
1126       CharSourceRange::getTokenRange(E->getSourceRange()),
1127       Context->getSourceManager(), Context->getLangOpts(), &Invalid);
1128   if (!Invalid) {
1129     OS << Source;
1130     return true;
1131   }
1132   return false;
1133 }
1134 
1135 void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
1136   if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1137     return;
1138   bool isSigned = Node->getType()->isSignedIntegerType();
1139   OS << Node->getValue().toString(10, isSigned);
1140 
1141   // Emit suffixes.  Integer literals are always a builtin integer type.
1142   switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
1143   default: llvm_unreachable("Unexpected type for integer literal!");
1144   case BuiltinType::Char_S:
1145   case BuiltinType::Char_U:    OS << "i8"; break;
1146   case BuiltinType::UChar:     OS << "Ui8"; break;
1147   case BuiltinType::Short:     OS << "i16"; break;
1148   case BuiltinType::UShort:    OS << "Ui16"; break;
1149   case BuiltinType::Int:       break; // no suffix.
1150   case BuiltinType::UInt:      OS << 'U'; break;
1151   case BuiltinType::Long:      OS << 'L'; break;
1152   case BuiltinType::ULong:     OS << "UL"; break;
1153   case BuiltinType::LongLong:  OS << "LL"; break;
1154   case BuiltinType::ULongLong: OS << "ULL"; break;
1155   }
1156 }
1157 
1158 void StmtPrinter::VisitFixedPointLiteral(FixedPointLiteral *Node) {
1159   if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1160     return;
1161   OS << Node->getValueAsString(/*Radix=*/10);
1162 
1163   switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
1164     default: llvm_unreachable("Unexpected type for fixed point literal!");
1165     case BuiltinType::ShortFract:   OS << "hr"; break;
1166     case BuiltinType::ShortAccum:   OS << "hk"; break;
1167     case BuiltinType::UShortFract:  OS << "uhr"; break;
1168     case BuiltinType::UShortAccum:  OS << "uhk"; break;
1169     case BuiltinType::Fract:        OS << "r"; break;
1170     case BuiltinType::Accum:        OS << "k"; break;
1171     case BuiltinType::UFract:       OS << "ur"; break;
1172     case BuiltinType::UAccum:       OS << "uk"; break;
1173     case BuiltinType::LongFract:    OS << "lr"; break;
1174     case BuiltinType::LongAccum:    OS << "lk"; break;
1175     case BuiltinType::ULongFract:   OS << "ulr"; break;
1176     case BuiltinType::ULongAccum:   OS << "ulk"; break;
1177   }
1178 }
1179 
1180 static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
1181                                  bool PrintSuffix) {
1182   SmallString<16> Str;
1183   Node->getValue().toString(Str);
1184   OS << Str;
1185   if (Str.find_first_not_of("-0123456789") == StringRef::npos)
1186     OS << '.'; // Trailing dot in order to separate from ints.
1187 
1188   if (!PrintSuffix)
1189     return;
1190 
1191   // Emit suffixes.  Float literals are always a builtin float type.
1192   switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
1193   default: llvm_unreachable("Unexpected type for float literal!");
1194   case BuiltinType::Half:       break; // FIXME: suffix?
1195   case BuiltinType::Double:     break; // no suffix.
1196   case BuiltinType::Float16:    OS << "F16"; break;
1197   case BuiltinType::Float:      OS << 'F'; break;
1198   case BuiltinType::LongDouble: OS << 'L'; break;
1199   case BuiltinType::Float128:   OS << 'Q'; break;
1200   }
1201 }
1202 
1203 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
1204   if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
1205     return;
1206   PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
1207 }
1208 
1209 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
1210   PrintExpr(Node->getSubExpr());
1211   OS << "i";
1212 }
1213 
1214 void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {
1215   Str->outputString(OS);
1216 }
1217 
1218 void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
1219   OS << "(";
1220   PrintExpr(Node->getSubExpr());
1221   OS << ")";
1222 }
1223 
1224 void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
1225   if (!Node->isPostfix()) {
1226     OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1227 
1228     // Print a space if this is an "identifier operator" like __real, or if
1229     // it might be concatenated incorrectly like '+'.
1230     switch (Node->getOpcode()) {
1231     default: break;
1232     case UO_Real:
1233     case UO_Imag:
1234     case UO_Extension:
1235       OS << ' ';
1236       break;
1237     case UO_Plus:
1238     case UO_Minus:
1239       if (isa<UnaryOperator>(Node->getSubExpr()))
1240         OS << ' ';
1241       break;
1242     }
1243   }
1244   PrintExpr(Node->getSubExpr());
1245 
1246   if (Node->isPostfix())
1247     OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1248 }
1249 
1250 void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) {
1251   OS << "__builtin_offsetof(";
1252   Node->getTypeSourceInfo()->getType().print(OS, Policy);
1253   OS << ", ";
1254   bool PrintedSomething = false;
1255   for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {
1256     OffsetOfNode ON = Node->getComponent(i);
1257     if (ON.getKind() == OffsetOfNode::Array) {
1258       // Array node
1259       OS << "[";
1260       PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex()));
1261       OS << "]";
1262       PrintedSomething = true;
1263       continue;
1264     }
1265 
1266     // Skip implicit base indirections.
1267     if (ON.getKind() == OffsetOfNode::Base)
1268       continue;
1269 
1270     // Field or identifier node.
1271     IdentifierInfo *Id = ON.getFieldName();
1272     if (!Id)
1273       continue;
1274 
1275     if (PrintedSomething)
1276       OS << ".";
1277     else
1278       PrintedSomething = true;
1279     OS << Id->getName();
1280   }
1281   OS << ")";
1282 }
1283 
1284 void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(
1285     UnaryExprOrTypeTraitExpr *Node) {
1286   const char *Spelling = getTraitSpelling(Node->getKind());
1287   if (Node->getKind() == UETT_AlignOf) {
1288     if (Policy.Alignof)
1289       Spelling = "alignof";
1290     else if (Policy.UnderscoreAlignof)
1291       Spelling = "_Alignof";
1292     else
1293       Spelling = "__alignof";
1294   }
1295 
1296   OS << Spelling;
1297 
1298   if (Node->isArgumentType()) {
1299     OS << '(';
1300     Node->getArgumentType().print(OS, Policy);
1301     OS << ')';
1302   } else {
1303     OS << " ";
1304     PrintExpr(Node->getArgumentExpr());
1305   }
1306 }
1307 
1308 void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
1309   OS << "_Generic(";
1310   PrintExpr(Node->getControllingExpr());
1311   for (const GenericSelectionExpr::Association Assoc : Node->associations()) {
1312     OS << ", ";
1313     QualType T = Assoc.getType();
1314     if (T.isNull())
1315       OS << "default";
1316     else
1317       T.print(OS, Policy);
1318     OS << ": ";
1319     PrintExpr(Assoc.getAssociationExpr());
1320   }
1321   OS << ")";
1322 }
1323 
1324 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
1325   PrintExpr(Node->getLHS());
1326   OS << "[";
1327   PrintExpr(Node->getRHS());
1328   OS << "]";
1329 }
1330 
1331 void StmtPrinter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *Node) {
1332   PrintExpr(Node->getBase());
1333   OS << "[";
1334   PrintExpr(Node->getRowIdx());
1335   OS << "]";
1336   OS << "[";
1337   PrintExpr(Node->getColumnIdx());
1338   OS << "]";
1339 }
1340 
1341 void StmtPrinter::VisitOMPArraySectionExpr(OMPArraySectionExpr *Node) {
1342   PrintExpr(Node->getBase());
1343   OS << "[";
1344   if (Node->getLowerBound())
1345     PrintExpr(Node->getLowerBound());
1346   if (Node->getColonLocFirst().isValid()) {
1347     OS << ":";
1348     if (Node->getLength())
1349       PrintExpr(Node->getLength());
1350   }
1351   if (Node->getColonLocSecond().isValid()) {
1352     OS << ":";
1353     if (Node->getStride())
1354       PrintExpr(Node->getStride());
1355   }
1356   OS << "]";
1357 }
1358 
1359 void StmtPrinter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *Node) {
1360   OS << "(";
1361   for (Expr *E : Node->getDimensions()) {
1362     OS << "[";
1363     PrintExpr(E);
1364     OS << "]";
1365   }
1366   OS << ")";
1367   PrintExpr(Node->getBase());
1368 }
1369 
1370 void StmtPrinter::VisitOMPIteratorExpr(OMPIteratorExpr *Node) {
1371   OS << "iterator(";
1372   for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) {
1373     auto *VD = cast<ValueDecl>(Node->getIteratorDecl(I));
1374     VD->getType().print(OS, Policy);
1375     const OMPIteratorExpr::IteratorRange Range = Node->getIteratorRange(I);
1376     OS << " " << VD->getName() << " = ";
1377     PrintExpr(Range.Begin);
1378     OS << ":";
1379     PrintExpr(Range.End);
1380     if (Range.Step) {
1381       OS << ":";
1382       PrintExpr(Range.Step);
1383     }
1384     if (I < E - 1)
1385       OS << ", ";
1386   }
1387   OS << ")";
1388 }
1389 
1390 void StmtPrinter::PrintCallArgs(CallExpr *Call) {
1391   for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
1392     if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
1393       // Don't print any defaulted arguments
1394       break;
1395     }
1396 
1397     if (i) OS << ", ";
1398     PrintExpr(Call->getArg(i));
1399   }
1400 }
1401 
1402 void StmtPrinter::VisitCallExpr(CallExpr *Call) {
1403   PrintExpr(Call->getCallee());
1404   OS << "(";
1405   PrintCallArgs(Call);
1406   OS << ")";
1407 }
1408 
1409 static bool isImplicitThis(const Expr *E) {
1410   if (const auto *TE = dyn_cast<CXXThisExpr>(E))
1411     return TE->isImplicit();
1412   return false;
1413 }
1414 
1415 void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
1416   if (!Policy.SuppressImplicitBase || !isImplicitThis(Node->getBase())) {
1417     PrintExpr(Node->getBase());
1418 
1419     auto *ParentMember = dyn_cast<MemberExpr>(Node->getBase());
1420     FieldDecl *ParentDecl =
1421         ParentMember ? dyn_cast<FieldDecl>(ParentMember->getMemberDecl())
1422                      : nullptr;
1423 
1424     if (!ParentDecl || !ParentDecl->isAnonymousStructOrUnion())
1425       OS << (Node->isArrow() ? "->" : ".");
1426   }
1427 
1428   if (auto *FD = dyn_cast<FieldDecl>(Node->getMemberDecl()))
1429     if (FD->isAnonymousStructOrUnion())
1430       return;
1431 
1432   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1433     Qualifier->print(OS, Policy);
1434   if (Node->hasTemplateKeyword())
1435     OS << "template ";
1436   OS << Node->getMemberNameInfo();
1437   if (Node->hasExplicitTemplateArgs())
1438     printTemplateArgumentList(OS, Node->template_arguments(), Policy);
1439 }
1440 
1441 void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) {
1442   PrintExpr(Node->getBase());
1443   OS << (Node->isArrow() ? "->isa" : ".isa");
1444 }
1445 
1446 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
1447   PrintExpr(Node->getBase());
1448   OS << ".";
1449   OS << Node->getAccessor().getName();
1450 }
1451 
1452 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
1453   OS << '(';
1454   Node->getTypeAsWritten().print(OS, Policy);
1455   OS << ')';
1456   PrintExpr(Node->getSubExpr());
1457 }
1458 
1459 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
1460   OS << '(';
1461   Node->getType().print(OS, Policy);
1462   OS << ')';
1463   PrintExpr(Node->getInitializer());
1464 }
1465 
1466 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
1467   // No need to print anything, simply forward to the subexpression.
1468   PrintExpr(Node->getSubExpr());
1469 }
1470 
1471 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
1472   PrintExpr(Node->getLHS());
1473   OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1474   PrintExpr(Node->getRHS());
1475 }
1476 
1477 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
1478   PrintExpr(Node->getLHS());
1479   OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1480   PrintExpr(Node->getRHS());
1481 }
1482 
1483 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
1484   PrintExpr(Node->getCond());
1485   OS << " ? ";
1486   PrintExpr(Node->getLHS());
1487   OS << " : ";
1488   PrintExpr(Node->getRHS());
1489 }
1490 
1491 // GNU extensions.
1492 
1493 void
1494 StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) {
1495   PrintExpr(Node->getCommon());
1496   OS << " ?: ";
1497   PrintExpr(Node->getFalseExpr());
1498 }
1499 
1500 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
1501   OS << "&&" << Node->getLabel()->getName();
1502 }
1503 
1504 void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
1505   OS << "(";
1506   PrintRawCompoundStmt(E->getSubStmt());
1507   OS << ")";
1508 }
1509 
1510 void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
1511   OS << "__builtin_choose_expr(";
1512   PrintExpr(Node->getCond());
1513   OS << ", ";
1514   PrintExpr(Node->getLHS());
1515   OS << ", ";
1516   PrintExpr(Node->getRHS());
1517   OS << ")";
1518 }
1519 
1520 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
1521   OS << "__null";
1522 }
1523 
1524 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
1525   OS << "__builtin_shufflevector(";
1526   for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
1527     if (i) OS << ", ";
1528     PrintExpr(Node->getExpr(i));
1529   }
1530   OS << ")";
1531 }
1532 
1533 void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) {
1534   OS << "__builtin_convertvector(";
1535   PrintExpr(Node->getSrcExpr());
1536   OS << ", ";
1537   Node->getType().print(OS, Policy);
1538   OS << ")";
1539 }
1540 
1541 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
1542   if (Node->getSyntacticForm()) {
1543     Visit(Node->getSyntacticForm());
1544     return;
1545   }
1546 
1547   OS << "{";
1548   for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
1549     if (i) OS << ", ";
1550     if (Node->getInit(i))
1551       PrintExpr(Node->getInit(i));
1552     else
1553       OS << "{}";
1554   }
1555   OS << "}";
1556 }
1557 
1558 void StmtPrinter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *Node) {
1559   // There's no way to express this expression in any of our supported
1560   // languages, so just emit something terse and (hopefully) clear.
1561   OS << "{";
1562   PrintExpr(Node->getSubExpr());
1563   OS << "}";
1564 }
1565 
1566 void StmtPrinter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *Node) {
1567   OS << "*";
1568 }
1569 
1570 void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) {
1571   OS << "(";
1572   for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
1573     if (i) OS << ", ";
1574     PrintExpr(Node->getExpr(i));
1575   }
1576   OS << ")";
1577 }
1578 
1579 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
1580   bool NeedsEquals = true;
1581   for (const DesignatedInitExpr::Designator &D : Node->designators()) {
1582     if (D.isFieldDesignator()) {
1583       if (D.getDotLoc().isInvalid()) {
1584         if (IdentifierInfo *II = D.getFieldName()) {
1585           OS << II->getName() << ":";
1586           NeedsEquals = false;
1587         }
1588       } else {
1589         OS << "." << D.getFieldName()->getName();
1590       }
1591     } else {
1592       OS << "[";
1593       if (D.isArrayDesignator()) {
1594         PrintExpr(Node->getArrayIndex(D));
1595       } else {
1596         PrintExpr(Node->getArrayRangeStart(D));
1597         OS << " ... ";
1598         PrintExpr(Node->getArrayRangeEnd(D));
1599       }
1600       OS << "]";
1601     }
1602   }
1603 
1604   if (NeedsEquals)
1605     OS << " = ";
1606   else
1607     OS << " ";
1608   PrintExpr(Node->getInit());
1609 }
1610 
1611 void StmtPrinter::VisitDesignatedInitUpdateExpr(
1612     DesignatedInitUpdateExpr *Node) {
1613   OS << "{";
1614   OS << "/*base*/";
1615   PrintExpr(Node->getBase());
1616   OS << ", ";
1617 
1618   OS << "/*updater*/";
1619   PrintExpr(Node->getUpdater());
1620   OS << "}";
1621 }
1622 
1623 void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) {
1624   OS << "/*no init*/";
1625 }
1626 
1627 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
1628   if (Node->getType()->getAsCXXRecordDecl()) {
1629     OS << "/*implicit*/";
1630     Node->getType().print(OS, Policy);
1631     OS << "()";
1632   } else {
1633     OS << "/*implicit*/(";
1634     Node->getType().print(OS, Policy);
1635     OS << ')';
1636     if (Node->getType()->isRecordType())
1637       OS << "{}";
1638     else
1639       OS << 0;
1640   }
1641 }
1642 
1643 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
1644   OS << "__builtin_va_arg(";
1645   PrintExpr(Node->getSubExpr());
1646   OS << ", ";
1647   Node->getType().print(OS, Policy);
1648   OS << ")";
1649 }
1650 
1651 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
1652   PrintExpr(Node->getSyntacticForm());
1653 }
1654 
1655 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
1656   const char *Name = nullptr;
1657   switch (Node->getOp()) {
1658 #define BUILTIN(ID, TYPE, ATTRS)
1659 #define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
1660   case AtomicExpr::AO ## ID: \
1661     Name = #ID "("; \
1662     break;
1663 #include "clang/Basic/Builtins.def"
1664   }
1665   OS << Name;
1666 
1667   // AtomicExpr stores its subexpressions in a permuted order.
1668   PrintExpr(Node->getPtr());
1669   if (Node->getOp() != AtomicExpr::AO__c11_atomic_load &&
1670       Node->getOp() != AtomicExpr::AO__atomic_load_n &&
1671       Node->getOp() != AtomicExpr::AO__opencl_atomic_load) {
1672     OS << ", ";
1673     PrintExpr(Node->getVal1());
1674   }
1675   if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||
1676       Node->isCmpXChg()) {
1677     OS << ", ";
1678     PrintExpr(Node->getVal2());
1679   }
1680   if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
1681       Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) {
1682     OS << ", ";
1683     PrintExpr(Node->getWeak());
1684   }
1685   if (Node->getOp() != AtomicExpr::AO__c11_atomic_init &&
1686       Node->getOp() != AtomicExpr::AO__opencl_atomic_init) {
1687     OS << ", ";
1688     PrintExpr(Node->getOrder());
1689   }
1690   if (Node->isCmpXChg()) {
1691     OS << ", ";
1692     PrintExpr(Node->getOrderFail());
1693   }
1694   OS << ")";
1695 }
1696 
1697 // C++
1698 void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
1699   OverloadedOperatorKind Kind = Node->getOperator();
1700   if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
1701     if (Node->getNumArgs() == 1) {
1702       OS << getOperatorSpelling(Kind) << ' ';
1703       PrintExpr(Node->getArg(0));
1704     } else {
1705       PrintExpr(Node->getArg(0));
1706       OS << ' ' << getOperatorSpelling(Kind);
1707     }
1708   } else if (Kind == OO_Arrow) {
1709     PrintExpr(Node->getArg(0));
1710   } else if (Kind == OO_Call) {
1711     PrintExpr(Node->getArg(0));
1712     OS << '(';
1713     for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
1714       if (ArgIdx > 1)
1715         OS << ", ";
1716       if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
1717         PrintExpr(Node->getArg(ArgIdx));
1718     }
1719     OS << ')';
1720   } else if (Kind == OO_Subscript) {
1721     PrintExpr(Node->getArg(0));
1722     OS << '[';
1723     PrintExpr(Node->getArg(1));
1724     OS << ']';
1725   } else if (Node->getNumArgs() == 1) {
1726     OS << getOperatorSpelling(Kind) << ' ';
1727     PrintExpr(Node->getArg(0));
1728   } else if (Node->getNumArgs() == 2) {
1729     PrintExpr(Node->getArg(0));
1730     OS << ' ' << getOperatorSpelling(Kind) << ' ';
1731     PrintExpr(Node->getArg(1));
1732   } else {
1733     llvm_unreachable("unknown overloaded operator");
1734   }
1735 }
1736 
1737 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
1738   // If we have a conversion operator call only print the argument.
1739   CXXMethodDecl *MD = Node->getMethodDecl();
1740   if (MD && isa<CXXConversionDecl>(MD)) {
1741     PrintExpr(Node->getImplicitObjectArgument());
1742     return;
1743   }
1744   VisitCallExpr(cast<CallExpr>(Node));
1745 }
1746 
1747 void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) {
1748   PrintExpr(Node->getCallee());
1749   OS << "<<<";
1750   PrintCallArgs(Node->getConfig());
1751   OS << ">>>(";
1752   PrintCallArgs(Node);
1753   OS << ")";
1754 }
1755 
1756 void StmtPrinter::VisitCXXRewrittenBinaryOperator(
1757     CXXRewrittenBinaryOperator *Node) {
1758   CXXRewrittenBinaryOperator::DecomposedForm Decomposed =
1759       Node->getDecomposedForm();
1760   PrintExpr(const_cast<Expr*>(Decomposed.LHS));
1761   OS << ' ' << BinaryOperator::getOpcodeStr(Decomposed.Opcode) << ' ';
1762   PrintExpr(const_cast<Expr*>(Decomposed.RHS));
1763 }
1764 
1765 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
1766   OS << Node->getCastName() << '<';
1767   Node->getTypeAsWritten().print(OS, Policy);
1768   OS << ">(";
1769   PrintExpr(Node->getSubExpr());
1770   OS << ")";
1771 }
1772 
1773 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
1774   VisitCXXNamedCastExpr(Node);
1775 }
1776 
1777 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
1778   VisitCXXNamedCastExpr(Node);
1779 }
1780 
1781 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
1782   VisitCXXNamedCastExpr(Node);
1783 }
1784 
1785 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
1786   VisitCXXNamedCastExpr(Node);
1787 }
1788 
1789 void StmtPrinter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *Node) {
1790   OS << "__builtin_bit_cast(";
1791   Node->getTypeInfoAsWritten()->getType().print(OS, Policy);
1792   OS << ", ";
1793   PrintExpr(Node->getSubExpr());
1794   OS << ")";
1795 }
1796 
1797 void StmtPrinter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *Node) {
1798   VisitCXXNamedCastExpr(Node);
1799 }
1800 
1801 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
1802   OS << "typeid(";
1803   if (Node->isTypeOperand()) {
1804     Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
1805   } else {
1806     PrintExpr(Node->getExprOperand());
1807   }
1808   OS << ")";
1809 }
1810 
1811 void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) {
1812   OS << "__uuidof(";
1813   if (Node->isTypeOperand()) {
1814     Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
1815   } else {
1816     PrintExpr(Node->getExprOperand());
1817   }
1818   OS << ")";
1819 }
1820 
1821 void StmtPrinter::VisitMSPropertyRefExpr(MSPropertyRefExpr *Node) {
1822   PrintExpr(Node->getBaseExpr());
1823   if (Node->isArrow())
1824     OS << "->";
1825   else
1826     OS << ".";
1827   if (NestedNameSpecifier *Qualifier =
1828       Node->getQualifierLoc().getNestedNameSpecifier())
1829     Qualifier->print(OS, Policy);
1830   OS << Node->getPropertyDecl()->getDeclName();
1831 }
1832 
1833 void StmtPrinter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *Node) {
1834   PrintExpr(Node->getBase());
1835   OS << "[";
1836   PrintExpr(Node->getIdx());
1837   OS << "]";
1838 }
1839 
1840 void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) {
1841   switch (Node->getLiteralOperatorKind()) {
1842   case UserDefinedLiteral::LOK_Raw:
1843     OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
1844     break;
1845   case UserDefinedLiteral::LOK_Template: {
1846     const auto *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
1847     const TemplateArgumentList *Args =
1848       cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
1849     assert(Args);
1850 
1851     if (Args->size() != 1) {
1852       OS << "operator\"\"" << Node->getUDSuffix()->getName();
1853       printTemplateArgumentList(OS, Args->asArray(), Policy);
1854       OS << "()";
1855       return;
1856     }
1857 
1858     const TemplateArgument &Pack = Args->get(0);
1859     for (const auto &P : Pack.pack_elements()) {
1860       char C = (char)P.getAsIntegral().getZExtValue();
1861       OS << C;
1862     }
1863     break;
1864   }
1865   case UserDefinedLiteral::LOK_Integer: {
1866     // Print integer literal without suffix.
1867     const auto *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
1868     OS << Int->getValue().toString(10, /*isSigned*/false);
1869     break;
1870   }
1871   case UserDefinedLiteral::LOK_Floating: {
1872     // Print floating literal without suffix.
1873     auto *Float = cast<FloatingLiteral>(Node->getCookedLiteral());
1874     PrintFloatingLiteral(OS, Float, /*PrintSuffix=*/false);
1875     break;
1876   }
1877   case UserDefinedLiteral::LOK_String:
1878   case UserDefinedLiteral::LOK_Character:
1879     PrintExpr(Node->getCookedLiteral());
1880     break;
1881   }
1882   OS << Node->getUDSuffix()->getName();
1883 }
1884 
1885 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
1886   OS << (Node->getValue() ? "true" : "false");
1887 }
1888 
1889 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
1890   OS << "nullptr";
1891 }
1892 
1893 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
1894   OS << "this";
1895 }
1896 
1897 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
1898   if (!Node->getSubExpr())
1899     OS << "throw";
1900   else {
1901     OS << "throw ";
1902     PrintExpr(Node->getSubExpr());
1903   }
1904 }
1905 
1906 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
1907   // Nothing to print: we picked up the default argument.
1908 }
1909 
1910 void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) {
1911   // Nothing to print: we picked up the default initializer.
1912 }
1913 
1914 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
1915   Node->getType().print(OS, Policy);
1916   // If there are no parens, this is list-initialization, and the braces are
1917   // part of the syntax of the inner construct.
1918   if (Node->getLParenLoc().isValid())
1919     OS << "(";
1920   PrintExpr(Node->getSubExpr());
1921   if (Node->getLParenLoc().isValid())
1922     OS << ")";
1923 }
1924 
1925 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
1926   PrintExpr(Node->getSubExpr());
1927 }
1928 
1929 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
1930   Node->getType().print(OS, Policy);
1931   if (Node->isStdInitListInitialization())
1932     /* Nothing to do; braces are part of creating the std::initializer_list. */;
1933   else if (Node->isListInitialization())
1934     OS << "{";
1935   else
1936     OS << "(";
1937   for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
1938                                          ArgEnd = Node->arg_end();
1939        Arg != ArgEnd; ++Arg) {
1940     if ((*Arg)->isDefaultArgument())
1941       break;
1942     if (Arg != Node->arg_begin())
1943       OS << ", ";
1944     PrintExpr(*Arg);
1945   }
1946   if (Node->isStdInitListInitialization())
1947     /* See above. */;
1948   else if (Node->isListInitialization())
1949     OS << "}";
1950   else
1951     OS << ")";
1952 }
1953 
1954 void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) {
1955   OS << '[';
1956   bool NeedComma = false;
1957   switch (Node->getCaptureDefault()) {
1958   case LCD_None:
1959     break;
1960 
1961   case LCD_ByCopy:
1962     OS << '=';
1963     NeedComma = true;
1964     break;
1965 
1966   case LCD_ByRef:
1967     OS << '&';
1968     NeedComma = true;
1969     break;
1970   }
1971   for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
1972                                  CEnd = Node->explicit_capture_end();
1973        C != CEnd;
1974        ++C) {
1975     if (C->capturesVLAType())
1976       continue;
1977 
1978     if (NeedComma)
1979       OS << ", ";
1980     NeedComma = true;
1981 
1982     switch (C->getCaptureKind()) {
1983     case LCK_This:
1984       OS << "this";
1985       break;
1986 
1987     case LCK_StarThis:
1988       OS << "*this";
1989       break;
1990 
1991     case LCK_ByRef:
1992       if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C))
1993         OS << '&';
1994       OS << C->getCapturedVar()->getName();
1995       break;
1996 
1997     case LCK_ByCopy:
1998       OS << C->getCapturedVar()->getName();
1999       break;
2000 
2001     case LCK_VLAType:
2002       llvm_unreachable("VLA type in explicit captures.");
2003     }
2004 
2005     if (C->isPackExpansion())
2006       OS << "...";
2007 
2008     if (Node->isInitCapture(C))
2009       PrintExpr(C->getCapturedVar()->getInit());
2010   }
2011   OS << ']';
2012 
2013   if (!Node->getExplicitTemplateParameters().empty()) {
2014     Node->getTemplateParameterList()->print(
2015         OS, Node->getLambdaClass()->getASTContext(),
2016         /*OmitTemplateKW*/true);
2017   }
2018 
2019   if (Node->hasExplicitParameters()) {
2020     OS << '(';
2021     CXXMethodDecl *Method = Node->getCallOperator();
2022     NeedComma = false;
2023     for (const auto *P : Method->parameters()) {
2024       if (NeedComma) {
2025         OS << ", ";
2026       } else {
2027         NeedComma = true;
2028       }
2029       std::string ParamStr = P->getNameAsString();
2030       P->getOriginalType().print(OS, Policy, ParamStr);
2031     }
2032     if (Method->isVariadic()) {
2033       if (NeedComma)
2034         OS << ", ";
2035       OS << "...";
2036     }
2037     OS << ')';
2038 
2039     if (Node->isMutable())
2040       OS << " mutable";
2041 
2042     auto *Proto = Method->getType()->castAs<FunctionProtoType>();
2043     Proto->printExceptionSpecification(OS, Policy);
2044 
2045     // FIXME: Attributes
2046 
2047     // Print the trailing return type if it was specified in the source.
2048     if (Node->hasExplicitResultType()) {
2049       OS << " -> ";
2050       Proto->getReturnType().print(OS, Policy);
2051     }
2052   }
2053 
2054   // Print the body.
2055   OS << ' ';
2056   if (Policy.TerseOutput)
2057     OS << "{}";
2058   else
2059     PrintRawCompoundStmt(Node->getCompoundStmtBody());
2060 }
2061 
2062 void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) {
2063   if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo())
2064     TSInfo->getType().print(OS, Policy);
2065   else
2066     Node->getType().print(OS, Policy);
2067   OS << "()";
2068 }
2069 
2070 void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
2071   if (E->isGlobalNew())
2072     OS << "::";
2073   OS << "new ";
2074   unsigned NumPlace = E->getNumPlacementArgs();
2075   if (NumPlace > 0 && !isa<CXXDefaultArgExpr>(E->getPlacementArg(0))) {
2076     OS << "(";
2077     PrintExpr(E->getPlacementArg(0));
2078     for (unsigned i = 1; i < NumPlace; ++i) {
2079       if (isa<CXXDefaultArgExpr>(E->getPlacementArg(i)))
2080         break;
2081       OS << ", ";
2082       PrintExpr(E->getPlacementArg(i));
2083     }
2084     OS << ") ";
2085   }
2086   if (E->isParenTypeId())
2087     OS << "(";
2088   std::string TypeS;
2089   if (Optional<Expr *> Size = E->getArraySize()) {
2090     llvm::raw_string_ostream s(TypeS);
2091     s << '[';
2092     if (*Size)
2093       (*Size)->printPretty(s, Helper, Policy);
2094     s << ']';
2095   }
2096   E->getAllocatedType().print(OS, Policy, TypeS);
2097   if (E->isParenTypeId())
2098     OS << ")";
2099 
2100   CXXNewExpr::InitializationStyle InitStyle = E->getInitializationStyle();
2101   if (InitStyle) {
2102     if (InitStyle == CXXNewExpr::CallInit)
2103       OS << "(";
2104     PrintExpr(E->getInitializer());
2105     if (InitStyle == CXXNewExpr::CallInit)
2106       OS << ")";
2107   }
2108 }
2109 
2110 void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
2111   if (E->isGlobalDelete())
2112     OS << "::";
2113   OS << "delete ";
2114   if (E->isArrayForm())
2115     OS << "[] ";
2116   PrintExpr(E->getArgument());
2117 }
2118 
2119 void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
2120   PrintExpr(E->getBase());
2121   if (E->isArrow())
2122     OS << "->";
2123   else
2124     OS << '.';
2125   if (E->getQualifier())
2126     E->getQualifier()->print(OS, Policy);
2127   OS << "~";
2128 
2129   if (IdentifierInfo *II = E->getDestroyedTypeIdentifier())
2130     OS << II->getName();
2131   else
2132     E->getDestroyedType().print(OS, Policy);
2133 }
2134 
2135 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
2136   if (E->isListInitialization() && !E->isStdInitListInitialization())
2137     OS << "{";
2138 
2139   for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
2140     if (isa<CXXDefaultArgExpr>(E->getArg(i))) {
2141       // Don't print any defaulted arguments
2142       break;
2143     }
2144 
2145     if (i) OS << ", ";
2146     PrintExpr(E->getArg(i));
2147   }
2148 
2149   if (E->isListInitialization() && !E->isStdInitListInitialization())
2150     OS << "}";
2151 }
2152 
2153 void StmtPrinter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
2154   // Parens are printed by the surrounding context.
2155   OS << "<forwarded>";
2156 }
2157 
2158 void StmtPrinter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
2159   PrintExpr(E->getSubExpr());
2160 }
2161 
2162 void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) {
2163   // Just forward to the subexpression.
2164   PrintExpr(E->getSubExpr());
2165 }
2166 
2167 void
2168 StmtPrinter::VisitCXXUnresolvedConstructExpr(
2169                                            CXXUnresolvedConstructExpr *Node) {
2170   Node->getTypeAsWritten().print(OS, Policy);
2171   OS << "(";
2172   for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
2173                                              ArgEnd = Node->arg_end();
2174        Arg != ArgEnd; ++Arg) {
2175     if (Arg != Node->arg_begin())
2176       OS << ", ";
2177     PrintExpr(*Arg);
2178   }
2179   OS << ")";
2180 }
2181 
2182 void StmtPrinter::VisitCXXDependentScopeMemberExpr(
2183                                          CXXDependentScopeMemberExpr *Node) {
2184   if (!Node->isImplicitAccess()) {
2185     PrintExpr(Node->getBase());
2186     OS << (Node->isArrow() ? "->" : ".");
2187   }
2188   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2189     Qualifier->print(OS, Policy);
2190   if (Node->hasTemplateKeyword())
2191     OS << "template ";
2192   OS << Node->getMemberNameInfo();
2193   if (Node->hasExplicitTemplateArgs())
2194     printTemplateArgumentList(OS, Node->template_arguments(), Policy);
2195 }
2196 
2197 void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) {
2198   if (!Node->isImplicitAccess()) {
2199     PrintExpr(Node->getBase());
2200     OS << (Node->isArrow() ? "->" : ".");
2201   }
2202   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2203     Qualifier->print(OS, Policy);
2204   if (Node->hasTemplateKeyword())
2205     OS << "template ";
2206   OS << Node->getMemberNameInfo();
2207   if (Node->hasExplicitTemplateArgs())
2208     printTemplateArgumentList(OS, Node->template_arguments(), Policy);
2209 }
2210 
2211 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
2212   OS << getTraitSpelling(E->getTrait()) << "(";
2213   for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
2214     if (I > 0)
2215       OS << ", ";
2216     E->getArg(I)->getType().print(OS, Policy);
2217   }
2218   OS << ")";
2219 }
2220 
2221 void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2222   OS << getTraitSpelling(E->getTrait()) << '(';
2223   E->getQueriedType().print(OS, Policy);
2224   OS << ')';
2225 }
2226 
2227 void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2228   OS << getTraitSpelling(E->getTrait()) << '(';
2229   PrintExpr(E->getQueriedExpression());
2230   OS << ')';
2231 }
2232 
2233 void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2234   OS << "noexcept(";
2235   PrintExpr(E->getOperand());
2236   OS << ")";
2237 }
2238 
2239 void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) {
2240   PrintExpr(E->getPattern());
2241   OS << "...";
2242 }
2243 
2244 void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2245   OS << "sizeof...(" << *E->getPack() << ")";
2246 }
2247 
2248 void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(
2249                                        SubstNonTypeTemplateParmPackExpr *Node) {
2250   OS << *Node->getParameterPack();
2251 }
2252 
2253 void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(
2254                                        SubstNonTypeTemplateParmExpr *Node) {
2255   Visit(Node->getReplacement());
2256 }
2257 
2258 void StmtPrinter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2259   OS << *E->getParameterPack();
2260 }
2261 
2262 void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){
2263   PrintExpr(Node->getSubExpr());
2264 }
2265 
2266 void StmtPrinter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2267   OS << "(";
2268   if (E->getLHS()) {
2269     PrintExpr(E->getLHS());
2270     OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
2271   }
2272   OS << "...";
2273   if (E->getRHS()) {
2274     OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
2275     PrintExpr(E->getRHS());
2276   }
2277   OS << ")";
2278 }
2279 
2280 void StmtPrinter::VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) {
2281   NestedNameSpecifierLoc NNS = E->getNestedNameSpecifierLoc();
2282   if (NNS)
2283     NNS.getNestedNameSpecifier()->print(OS, Policy);
2284   if (E->getTemplateKWLoc().isValid())
2285     OS << "template ";
2286   OS << E->getFoundDecl()->getName();
2287   printTemplateArgumentList(OS, E->getTemplateArgsAsWritten()->arguments(),
2288                             Policy);
2289 }
2290 
2291 void StmtPrinter::VisitRequiresExpr(RequiresExpr *E) {
2292   OS << "requires ";
2293   auto LocalParameters = E->getLocalParameters();
2294   if (!LocalParameters.empty()) {
2295     OS << "(";
2296     for (ParmVarDecl *LocalParam : LocalParameters) {
2297       PrintRawDecl(LocalParam);
2298       if (LocalParam != LocalParameters.back())
2299         OS << ", ";
2300     }
2301 
2302     OS << ") ";
2303   }
2304   OS << "{ ";
2305   auto Requirements = E->getRequirements();
2306   for (concepts::Requirement *Req : Requirements) {
2307     if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req)) {
2308       if (TypeReq->isSubstitutionFailure())
2309         OS << "<<error-type>>";
2310       else
2311         TypeReq->getType()->getType().print(OS, Policy);
2312     } else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req)) {
2313       if (ExprReq->isCompound())
2314         OS << "{ ";
2315       if (ExprReq->isExprSubstitutionFailure())
2316         OS << "<<error-expression>>";
2317       else
2318         PrintExpr(ExprReq->getExpr());
2319       if (ExprReq->isCompound()) {
2320         OS << " }";
2321         if (ExprReq->getNoexceptLoc().isValid())
2322           OS << " noexcept";
2323         const auto &RetReq = ExprReq->getReturnTypeRequirement();
2324         if (!RetReq.isEmpty()) {
2325           OS << " -> ";
2326           if (RetReq.isSubstitutionFailure())
2327             OS << "<<error-type>>";
2328           else if (RetReq.isTypeConstraint())
2329             RetReq.getTypeConstraint()->print(OS, Policy);
2330         }
2331       }
2332     } else {
2333       auto *NestedReq = cast<concepts::NestedRequirement>(Req);
2334       OS << "requires ";
2335       if (NestedReq->isSubstitutionFailure())
2336         OS << "<<error-expression>>";
2337       else
2338         PrintExpr(NestedReq->getConstraintExpr());
2339     }
2340     OS << "; ";
2341   }
2342   OS << "}";
2343 }
2344 
2345 // C++ Coroutines TS
2346 
2347 void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
2348   Visit(S->getBody());
2349 }
2350 
2351 void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) {
2352   OS << "co_return";
2353   if (S->getOperand()) {
2354     OS << " ";
2355     Visit(S->getOperand());
2356   }
2357   OS << ";";
2358 }
2359 
2360 void StmtPrinter::VisitCoawaitExpr(CoawaitExpr *S) {
2361   OS << "co_await ";
2362   PrintExpr(S->getOperand());
2363 }
2364 
2365 void StmtPrinter::VisitDependentCoawaitExpr(DependentCoawaitExpr *S) {
2366   OS << "co_await ";
2367   PrintExpr(S->getOperand());
2368 }
2369 
2370 void StmtPrinter::VisitCoyieldExpr(CoyieldExpr *S) {
2371   OS << "co_yield ";
2372   PrintExpr(S->getOperand());
2373 }
2374 
2375 // Obj-C
2376 
2377 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
2378   OS << "@";
2379   VisitStringLiteral(Node->getString());
2380 }
2381 
2382 void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
2383   OS << "@";
2384   Visit(E->getSubExpr());
2385 }
2386 
2387 void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
2388   OS << "@[ ";
2389   ObjCArrayLiteral::child_range Ch = E->children();
2390   for (auto I = Ch.begin(), E = Ch.end(); I != E; ++I) {
2391     if (I != Ch.begin())
2392       OS << ", ";
2393     Visit(*I);
2394   }
2395   OS << " ]";
2396 }
2397 
2398 void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
2399   OS << "@{ ";
2400   for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
2401     if (I > 0)
2402       OS << ", ";
2403 
2404     ObjCDictionaryElement Element = E->getKeyValueElement(I);
2405     Visit(Element.Key);
2406     OS << " : ";
2407     Visit(Element.Value);
2408     if (Element.isPackExpansion())
2409       OS << "...";
2410   }
2411   OS << " }";
2412 }
2413 
2414 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
2415   OS << "@encode(";
2416   Node->getEncodedType().print(OS, Policy);
2417   OS << ')';
2418 }
2419 
2420 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
2421   OS << "@selector(";
2422   Node->getSelector().print(OS);
2423   OS << ')';
2424 }
2425 
2426 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
2427   OS << "@protocol(" << *Node->getProtocol() << ')';
2428 }
2429 
2430 void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
2431   OS << "[";
2432   switch (Mess->getReceiverKind()) {
2433   case ObjCMessageExpr::Instance:
2434     PrintExpr(Mess->getInstanceReceiver());
2435     break;
2436 
2437   case ObjCMessageExpr::Class:
2438     Mess->getClassReceiver().print(OS, Policy);
2439     break;
2440 
2441   case ObjCMessageExpr::SuperInstance:
2442   case ObjCMessageExpr::SuperClass:
2443     OS << "Super";
2444     break;
2445   }
2446 
2447   OS << ' ';
2448   Selector selector = Mess->getSelector();
2449   if (selector.isUnarySelector()) {
2450     OS << selector.getNameForSlot(0);
2451   } else {
2452     for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
2453       if (i < selector.getNumArgs()) {
2454         if (i > 0) OS << ' ';
2455         if (selector.getIdentifierInfoForSlot(i))
2456           OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
2457         else
2458            OS << ":";
2459       }
2460       else OS << ", "; // Handle variadic methods.
2461 
2462       PrintExpr(Mess->getArg(i));
2463     }
2464   }
2465   OS << "]";
2466 }
2467 
2468 void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) {
2469   OS << (Node->getValue() ? "__objc_yes" : "__objc_no");
2470 }
2471 
2472 void
2473 StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
2474   PrintExpr(E->getSubExpr());
2475 }
2476 
2477 void
2478 StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
2479   OS << '(' << E->getBridgeKindName();
2480   E->getType().print(OS, Policy);
2481   OS << ')';
2482   PrintExpr(E->getSubExpr());
2483 }
2484 
2485 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
2486   BlockDecl *BD = Node->getBlockDecl();
2487   OS << "^";
2488 
2489   const FunctionType *AFT = Node->getFunctionType();
2490 
2491   if (isa<FunctionNoProtoType>(AFT)) {
2492     OS << "()";
2493   } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
2494     OS << '(';
2495     for (BlockDecl::param_iterator AI = BD->param_begin(),
2496          E = BD->param_end(); AI != E; ++AI) {
2497       if (AI != BD->param_begin()) OS << ", ";
2498       std::string ParamStr = (*AI)->getNameAsString();
2499       (*AI)->getType().print(OS, Policy, ParamStr);
2500     }
2501 
2502     const auto *FT = cast<FunctionProtoType>(AFT);
2503     if (FT->isVariadic()) {
2504       if (!BD->param_empty()) OS << ", ";
2505       OS << "...";
2506     }
2507     OS << ')';
2508   }
2509   OS << "{ }";
2510 }
2511 
2512 void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) {
2513   PrintExpr(Node->getSourceExpr());
2514 }
2515 
2516 void StmtPrinter::VisitTypoExpr(TypoExpr *Node) {
2517   // TODO: Print something reasonable for a TypoExpr, if necessary.
2518   llvm_unreachable("Cannot print TypoExpr nodes");
2519 }
2520 
2521 void StmtPrinter::VisitRecoveryExpr(RecoveryExpr *Node) {
2522   OS << "<recovery-expr>(";
2523   const char *Sep = "";
2524   for (Expr *E : Node->subExpressions()) {
2525     OS << Sep;
2526     PrintExpr(E);
2527     Sep = ", ";
2528   }
2529   OS << ')';
2530 }
2531 
2532 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
2533   OS << "__builtin_astype(";
2534   PrintExpr(Node->getSrcExpr());
2535   OS << ", ";
2536   Node->getType().print(OS, Policy);
2537   OS << ")";
2538 }
2539 
2540 //===----------------------------------------------------------------------===//
2541 // Stmt method implementations
2542 //===----------------------------------------------------------------------===//
2543 
2544 void Stmt::dumpPretty(const ASTContext &Context) const {
2545   printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts()));
2546 }
2547 
2548 void Stmt::printPretty(raw_ostream &Out, PrinterHelper *Helper,
2549                        const PrintingPolicy &Policy, unsigned Indentation,
2550                        StringRef NL, const ASTContext *Context) const {
2551   StmtPrinter P(Out, Helper, Policy, Indentation, NL, Context);
2552   P.Visit(const_cast<Stmt *>(this));
2553 }
2554 
2555 void Stmt::printJson(raw_ostream &Out, PrinterHelper *Helper,
2556                      const PrintingPolicy &Policy, bool AddQuotes) const {
2557   std::string Buf;
2558   llvm::raw_string_ostream TempOut(Buf);
2559 
2560   printPretty(TempOut, Helper, Policy);
2561 
2562   Out << JsonFormat(TempOut.str(), AddQuotes);
2563 }
2564 
2565 //===----------------------------------------------------------------------===//
2566 // PrinterHelper
2567 //===----------------------------------------------------------------------===//
2568 
2569 // Implement virtual destructor.
2570 PrinterHelper::~PrinterHelper() = default;
2571