clang/lib/AST/StmtPrinter.cpp

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