clang/lib/AST/DeclPrinter.cpp

   1 //===--- DeclPrinter.cpp - Printing implementation for Decl 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 Decl::print method, which pretty prints the
  10 // AST back out to C/Objective-C/C++/Objective-C++ code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #include "clang/AST/ASTContext.h"
  14 #include "clang/AST/Attr.h"
  15 #include "clang/AST/Decl.h"
  16 #include "clang/AST/DeclCXX.h"
  17 #include "clang/AST/DeclObjC.h"
  18 #include "clang/AST/DeclTemplate.h"
  19 #include "clang/AST/DeclVisitor.h"
  20 #include "clang/AST/Expr.h"
  21 #include "clang/AST/ExprCXX.h"
  22 #include "clang/AST/PrettyPrinter.h"
  23 #include "clang/Basic/Module.h"
  24 #include "llvm/Support/raw_ostream.h"
  25 using namespace clang;
  26
  27 namespace {
  28   class DeclPrinter : public DeclVisitor<DeclPrinter> {
  29     raw_ostream &Out;
  30     PrintingPolicy Policy;
  31     const ASTContext &Context;
  32     unsigned Indentation;
  33     bool PrintInstantiation;
  34
  35     raw_ostream& Indent() { return Indent(Indentation); }
  36     raw_ostream& Indent(unsigned Indentation);
  37     void ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls);
  38
  39     void Print(AccessSpecifier AS);
  40     void PrintConstructorInitializers(CXXConstructorDecl *CDecl,
  41                                       std::string &Proto);
  42
  43     /// Print an Objective-C method type in parentheses.
  44     ///
  45     /// \param Quals The Objective-C declaration qualifiers.
  46     /// \param T The type to print.
  47     void PrintObjCMethodType(ASTContext &Ctx, Decl::ObjCDeclQualifier Quals,
  48                              QualType T);
  49
  50     void PrintObjCTypeParams(ObjCTypeParamList *Params);
  51
  52     enum class AttrPrintLoc {
  53       None = 0,
  54       Left = 1,
  55       Right = 2,
  56       Any = Left | Right,
  57
  58       LLVM_MARK_AS_BITMASK_ENUM(/*DefaultValue=*/Any)
  59     };
  60
  61     void prettyPrintAttributes(Decl *D, raw_ostream &out,
  62                                AttrPrintLoc loc = AttrPrintLoc::Any);
  63
  64   public:
  65     DeclPrinter(raw_ostream &Out, const PrintingPolicy &Policy,
  66                 const ASTContext &Context, unsigned Indentation = 0,
  67                 bool PrintInstantiation = false)
  68         : Out(Out), Policy(Policy), Context(Context), Indentation(Indentation),
  69           PrintInstantiation(PrintInstantiation) {}
  70
  71     void VisitDeclContext(DeclContext *DC, bool Indent = true);
  72
  73     void VisitTranslationUnitDecl(TranslationUnitDecl *D);
  74     void VisitTypedefDecl(TypedefDecl *D);
  75     void VisitTypeAliasDecl(TypeAliasDecl *D);
  76     void VisitEnumDecl(EnumDecl *D);
  77     void VisitRecordDecl(RecordDecl *D);
  78     void VisitEnumConstantDecl(EnumConstantDecl *D);
  79     void VisitEmptyDecl(EmptyDecl *D);
  80     void VisitFunctionDecl(FunctionDecl *D);
  81     void VisitFriendDecl(FriendDecl *D);
  82     void VisitFieldDecl(FieldDecl *D);
  83     void VisitVarDecl(VarDecl *D);
  84     void VisitLabelDecl(LabelDecl *D);
  85     void VisitParmVarDecl(ParmVarDecl *D);
  86     void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
  87     void VisitTopLevelStmtDecl(TopLevelStmtDecl *D);
  88     void VisitImportDecl(ImportDecl *D);
  89     void VisitStaticAssertDecl(StaticAssertDecl *D);
  90     void VisitNamespaceDecl(NamespaceDecl *D);
  91     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
  92     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
  93     void VisitCXXRecordDecl(CXXRecordDecl *D);
  94     void VisitLinkageSpecDecl(LinkageSpecDecl *D);
  95     void VisitTemplateDecl(const TemplateDecl *D);
  96     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
  97     void VisitClassTemplateDecl(ClassTemplateDecl *D);
  98     void VisitClassTemplateSpecializationDecl(
  99                                             ClassTemplateSpecializationDecl *D);
 100     void VisitClassTemplatePartialSpecializationDecl(
 101                                      ClassTemplatePartialSpecializationDecl *D);
 102     void VisitObjCMethodDecl(ObjCMethodDecl *D);
 103     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
 104     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
 105     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
 106     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
 107     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
 108     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
 109     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
 110     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
 111     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
 112     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
 113     void VisitUsingDecl(UsingDecl *D);
 114     void VisitUsingEnumDecl(UsingEnumDecl *D);
 115     void VisitUsingShadowDecl(UsingShadowDecl *D);
 116     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
 117     void VisitOMPAllocateDecl(OMPAllocateDecl *D);
 118     void VisitOMPRequiresDecl(OMPRequiresDecl *D);
 119     void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
 120     void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
 121     void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
 122     void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP);
 123     void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *NTTP);
 124     void VisitHLSLBufferDecl(HLSLBufferDecl *D);
 125
 126     void printTemplateParameters(const TemplateParameterList *Params,
 127                                  bool OmitTemplateKW = false);
 128     void printTemplateArguments(llvm::ArrayRef<TemplateArgument> Args,
 129                                 const TemplateParameterList *Params);
 130     void printTemplateArguments(llvm::ArrayRef<TemplateArgumentLoc> Args,
 131                                 const TemplateParameterList *Params);
 132
 133     inline void prettyPrintAttributes(Decl *D) {
 134       prettyPrintAttributes(D, Out);
 135     }
 136
 137     void prettyPrintPragmas(Decl *D);
 138     void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
 139   };
 140 }
 141
 142 void Decl::print(raw_ostream &Out, unsigned Indentation,
 143                  bool PrintInstantiation) const {
 144   print(Out, getASTContext().getPrintingPolicy(), Indentation, PrintInstantiation);
 145 }
 146
 147 void Decl::print(raw_ostream &Out, const PrintingPolicy &Policy,
 148                  unsigned Indentation, bool PrintInstantiation) const {
 149   DeclPrinter Printer(Out, Policy, getASTContext(), Indentation,
 150                       PrintInstantiation);
 151   Printer.Visit(const_cast<Decl*>(this));
 152 }
 153
 154 void TemplateParameterList::print(raw_ostream &Out, const ASTContext &Context,
 155                                   bool OmitTemplateKW) const {
 156   print(Out, Context, Context.getPrintingPolicy(), OmitTemplateKW);
 157 }
 158
 159 void TemplateParameterList::print(raw_ostream &Out, const ASTContext &Context,
 160                                   const PrintingPolicy &Policy,
 161                                   bool OmitTemplateKW) const {
 162   DeclPrinter Printer(Out, Policy, Context);
 163   Printer.printTemplateParameters(this, OmitTemplateKW);
 164 }
 165
 166 static QualType GetBaseType(QualType T) {
 167   // FIXME: This should be on the Type class!
 168   QualType BaseType = T;
 169   while (!BaseType->isSpecifierType()) {
 170     if (const PointerType *PTy = BaseType->getAs<PointerType>())
 171       BaseType = PTy->getPointeeType();
 172     else if (const ObjCObjectPointerType *OPT =
 173                  BaseType->getAs<ObjCObjectPointerType>())
 174       BaseType = OPT->getPointeeType();
 175     else if (const BlockPointerType *BPy = BaseType->getAs<BlockPointerType>())
 176       BaseType = BPy->getPointeeType();
 177     else if (const ArrayType *ATy = dyn_cast<ArrayType>(BaseType))
 178       BaseType = ATy->getElementType();
 179     else if (const FunctionType *FTy = BaseType->getAs<FunctionType>())
 180       BaseType = FTy->getReturnType();
 181     else if (const VectorType *VTy = BaseType->getAs<VectorType>())
 182       BaseType = VTy->getElementType();
 183     else if (const ReferenceType *RTy = BaseType->getAs<ReferenceType>())
 184       BaseType = RTy->getPointeeType();
 185     else if (const AutoType *ATy = BaseType->getAs<AutoType>())
 186       BaseType = ATy->getDeducedType();
 187     else if (const ParenType *PTy = BaseType->getAs<ParenType>())
 188       BaseType = PTy->desugar();
 189     else
 190       // This must be a syntax error.
 191       break;
 192   }
 193   return BaseType;
 194 }
 195
 196 static QualType getDeclType(Decl* D) {
 197   if (TypedefNameDecl* TDD = dyn_cast<TypedefNameDecl>(D))
 198     return TDD->getUnderlyingType();
 199   if (ValueDecl* VD = dyn_cast<ValueDecl>(D))
 200     return VD->getType();
 201   return QualType();
 202 }
 203
 204 void Decl::printGroup(Decl** Begin, unsigned NumDecls,
 205                       raw_ostream &Out, const PrintingPolicy &Policy,
 206                       unsigned Indentation) {
 207   if (NumDecls == 1) {
 208     (*Begin)->print(Out, Policy, Indentation);
 209     return;
 210   }
 211
 212   Decl** End = Begin + NumDecls;
 213   TagDecl* TD = dyn_cast<TagDecl>(*Begin);
 214   if (TD)
 215     ++Begin;
 216
 217   PrintingPolicy SubPolicy(Policy);
 218
 219   bool isFirst = true;
 220   for ( ; Begin != End; ++Begin) {
 221     if (isFirst) {
 222       if(TD)
 223         SubPolicy.IncludeTagDefinition = true;
 224       SubPolicy.SuppressSpecifiers = false;
 225       isFirst = false;
 226     } else {
 227       if (!isFirst) Out << ", ";
 228       SubPolicy.IncludeTagDefinition = false;
 229       SubPolicy.SuppressSpecifiers = true;
 230     }
 231
 232     (*Begin)->print(Out, SubPolicy, Indentation);
 233   }
 234 }
 235
 236 LLVM_DUMP_METHOD void DeclContext::dumpDeclContext() const {
 237   // Get the translation unit
 238   const DeclContext *DC = this;
 239   while (!DC->isTranslationUnit())
 240     DC = DC->getParent();
 241
 242   ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
 243   DeclPrinter Printer(llvm::errs(), Ctx.getPrintingPolicy(), Ctx, 0);
 244   Printer.VisitDeclContext(const_cast<DeclContext *>(this), /*Indent=*/false);
 245 }
 246
 247 raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
 248   for (unsigned i = 0; i != Indentation; ++i)
 249     Out << "  ";
 250   return Out;
 251 }
 252
 253 // For CLANG_ATTR_LIST_CanPrintOnLeft macro.
 254 #include "clang/Basic/AttrLeftSideCanPrintList.inc"
 255
 256 // For CLANG_ATTR_LIST_PrintOnLeft macro.
 257 #include "clang/Basic/AttrLeftSideMustPrintList.inc"
 258
 259 static bool canPrintOnLeftSide(attr::Kind kind) {
 260 #ifdef CLANG_ATTR_LIST_CanPrintOnLeft
 261   switch (kind) {
 262   CLANG_ATTR_LIST_CanPrintOnLeft
 263     return true;
 264   default:
 265     return false;
 266   }
 267 #else
 268   return false;
 269 #endif
 270 }
 271
 272 static bool canPrintOnLeftSide(const Attr *A) {
 273   if (A->isStandardAttributeSyntax())
 274     return false;
 275
 276   return canPrintOnLeftSide(A->getKind());
 277 }
 278
 279 static bool mustPrintOnLeftSide(attr::Kind kind) {
 280 #ifdef CLANG_ATTR_LIST_PrintOnLeft
 281   switch (kind) {
 282   CLANG_ATTR_LIST_PrintOnLeft
 283     return true;
 284   default:
 285     return false;
 286   }
 287 #else
 288   return false;
 289 #endif
 290 }
 291
 292 static bool mustPrintOnLeftSide(const Attr *A) {
 293   if (A->isDeclspecAttribute())
 294     return true;
 295
 296   return mustPrintOnLeftSide(A->getKind());
 297 }
 298
 299 void DeclPrinter::prettyPrintAttributes(Decl *D, llvm::raw_ostream &Out,
 300                                         AttrPrintLoc Loc) {
 301   if (Policy.PolishForDeclaration)
 302     return;
 303
 304   if (D->hasAttrs()) {
 305     AttrVec &Attrs = D->getAttrs();
 306     for (auto *A : Attrs) {
 307       if (A->isInherited() || A->isImplicit())
 308         continue;
 309
 310       AttrPrintLoc AttrLoc = AttrPrintLoc::Right;
 311       if (mustPrintOnLeftSide(A)) {
 312         // If we must always print on left side (e.g. declspec), then mark as
 313         // so.
 314         AttrLoc = AttrPrintLoc::Left;
 315       } else if (canPrintOnLeftSide(A)) {
 316         // For functions with body defined we print the attributes on the left
 317         // side so that GCC accept our dumps as well.
 318         if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
 319             FD && FD->isThisDeclarationADefinition())
 320           // In case Decl is a function with a body, then attrs should be print
 321           // on the left side.
 322           AttrLoc = AttrPrintLoc::Left;
 323
 324           // In case it is a variable declaration with a ctor, then allow
 325           // printing on the left side for readbility.
 326         else if (const VarDecl *VD = dyn_cast<VarDecl>(D);
 327                    VD && VD->getInit() &&
 328                    VD->getInitStyle() == VarDecl::CallInit)
 329           AttrLoc = AttrPrintLoc::Left;
 330       }
 331       // Only print the side matches the user requested.
 332       if ((Loc & AttrLoc) != AttrPrintLoc::None)
 333         A->printPretty(Out, Policy);
 334     }
 335   }
 336 }
 337
 338 void DeclPrinter::prettyPrintPragmas(Decl *D) {
 339   if (Policy.PolishForDeclaration)
 340     return;
 341
 342   if (D->hasAttrs()) {
 343     AttrVec &Attrs = D->getAttrs();
 344     for (auto *A : Attrs) {
 345       switch (A->getKind()) {
 346 #define ATTR(X)
 347 #define PRAGMA_SPELLING_ATTR(X) case attr::X:
 348 #include "clang/Basic/AttrList.inc"
 349         A->printPretty(Out, Policy);
 350         Indent();
 351         break;
 352       default:
 353         break;
 354       }
 355     }
 356   }
 357 }
 358
 359 void DeclPrinter::printDeclType(QualType T, StringRef DeclName, bool Pack) {
 360   // Normally, a PackExpansionType is written as T[3]... (for instance, as a
 361   // template argument), but if it is the type of a declaration, the ellipsis
 362   // is placed before the name being declared.
 363   if (auto *PET = T->getAs<PackExpansionType>()) {
 364     Pack = true;
 365     T = PET->getPattern();
 366   }
 367   T.print(Out, Policy, (Pack ? "..." : "") + DeclName, Indentation);
 368 }
 369
 370 void DeclPrinter::ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls) {
 371   this->Indent();
 372   Decl::printGroup(Decls.data(), Decls.size(), Out, Policy, Indentation);
 373   Out << ";\n";
 374   Decls.clear();
 375
 376 }
 377
 378 void DeclPrinter::Print(AccessSpecifier AS) {
 379   const auto AccessSpelling = getAccessSpelling(AS);
 380   if (AccessSpelling.empty())
 381     llvm_unreachable("No access specifier!");
 382   Out << AccessSpelling;
 383 }
 384
 385 void DeclPrinter::PrintConstructorInitializers(CXXConstructorDecl *CDecl,
 386                                                std::string &Proto) {
 387   bool HasInitializerList = false;
 388   for (const auto *BMInitializer : CDecl->inits()) {
 389     if (BMInitializer->isInClassMemberInitializer())
 390       continue;
 391     if (!BMInitializer->isWritten())
 392       continue;
 393
 394     if (!HasInitializerList) {
 395       Proto += " : ";
 396       Out << Proto;
 397       Proto.clear();
 398       HasInitializerList = true;
 399     } else
 400       Out << ", ";
 401
 402     if (BMInitializer->isAnyMemberInitializer()) {
 403       FieldDecl *FD = BMInitializer->getAnyMember();
 404       Out << *FD;
 405     } else if (BMInitializer->isDelegatingInitializer()) {
 406       Out << CDecl->getNameAsString();
 407     } else {
 408       Out << QualType(BMInitializer->getBaseClass(), 0).getAsString(Policy);
 409     }
 410
 411     if (Expr *Init = BMInitializer->getInit()) {
 412       bool OutParens = !isa<InitListExpr>(Init);
 413
 414       if (OutParens)
 415         Out << "(";
 416
 417       if (ExprWithCleanups *Tmp = dyn_cast<ExprWithCleanups>(Init))
 418         Init = Tmp->getSubExpr();
 419
 420       Init = Init->IgnoreParens();
 421
 422       Expr *SimpleInit = nullptr;
 423       Expr **Args = nullptr;
 424       unsigned NumArgs = 0;
 425       if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) {
 426         Args = ParenList->getExprs();
 427         NumArgs = ParenList->getNumExprs();
 428       } else if (CXXConstructExpr *Construct =
 429                      dyn_cast<CXXConstructExpr>(Init)) {
 430         Args = Construct->getArgs();
 431         NumArgs = Construct->getNumArgs();
 432       } else
 433         SimpleInit = Init;
 434
 435       if (SimpleInit)
 436         SimpleInit->printPretty(Out, nullptr, Policy, Indentation, "\n",
 437                                 &Context);
 438       else {
 439         for (unsigned I = 0; I != NumArgs; ++I) {
 440           assert(Args[I] != nullptr && "Expected non-null Expr");
 441           if (isa<CXXDefaultArgExpr>(Args[I]))
 442             break;
 443
 444           if (I)
 445             Out << ", ";
 446           Args[I]->printPretty(Out, nullptr, Policy, Indentation, "\n",
 447                                &Context);
 448         }
 449       }
 450
 451       if (OutParens)
 452         Out << ")";
 453     } else {
 454       Out << "()";
 455     }
 456
 457     if (BMInitializer->isPackExpansion())
 458       Out << "...";
 459   }
 460 }
 461
 462 //----------------------------------------------------------------------------
 463 // Common C declarations
 464 //----------------------------------------------------------------------------
 465
 466 void DeclPrinter::VisitDeclContext(DeclContext *DC, bool Indent) {
 467   if (Policy.TerseOutput)
 468     return;
 469
 470   if (Indent)
 471     Indentation += Policy.Indentation;
 472
 473   SmallVector<Decl*, 2> Decls;
 474   for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end();
 475        D != DEnd; ++D) {
 476
 477     // Don't print ObjCIvarDecls, as they are printed when visiting the
 478     // containing ObjCInterfaceDecl.
 479     if (isa<ObjCIvarDecl>(*D))
 480       continue;
 481
 482     // Skip over implicit declarations in pretty-printing mode.
 483     if (D->isImplicit())
 484       continue;
 485
 486     // Don't print implicit specializations, as they are printed when visiting
 487     // corresponding templates.
 488     if (auto FD = dyn_cast<FunctionDecl>(*D))
 489       if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation &&
 490           !isa<ClassTemplateSpecializationDecl>(DC))
 491         continue;
 492
 493     // The next bits of code handle stuff like "struct {int x;} a,b"; we're
 494     // forced to merge the declarations because there's no other way to
 495     // refer to the struct in question.  When that struct is named instead, we
 496     // also need to merge to avoid splitting off a stand-alone struct
 497     // declaration that produces the warning ext_no_declarators in some
 498     // contexts.
 499     //
 500     // This limited merging is safe without a bunch of other checks because it
 501     // only merges declarations directly referring to the tag, not typedefs.
 502     //
 503     // Check whether the current declaration should be grouped with a previous
 504     // non-free-standing tag declaration.
 505     QualType CurDeclType = getDeclType(*D);
 506     if (!Decls.empty() && !CurDeclType.isNull()) {
 507       QualType BaseType = GetBaseType(CurDeclType);
 508       if (!BaseType.isNull() && isa<ElaboratedType>(BaseType) &&
 509           cast<ElaboratedType>(BaseType)->getOwnedTagDecl() == Decls[0]) {
 510         Decls.push_back(*D);
 511         continue;
 512       }
 513     }
 514
 515     // If we have a merged group waiting to be handled, handle it now.
 516     if (!Decls.empty())
 517       ProcessDeclGroup(Decls);
 518
 519     // If the current declaration is not a free standing declaration, save it
 520     // so we can merge it with the subsequent declaration(s) using it.
 521     if (isa<TagDecl>(*D) && !cast<TagDecl>(*D)->isFreeStanding()) {
 522       Decls.push_back(*D);
 523       continue;
 524     }
 525
 526     if (isa<AccessSpecDecl>(*D)) {
 527       Indentation -= Policy.Indentation;
 528       this->Indent();
 529       Print(D->getAccess());
 530       Out << ":\n";
 531       Indentation += Policy.Indentation;
 532       continue;
 533     }
 534
 535     this->Indent();
 536     Visit(*D);
 537
 538     // FIXME: Need to be able to tell the DeclPrinter when
 539     const char *Terminator = nullptr;
 540     if (isa<OMPThreadPrivateDecl>(*D) || isa<OMPDeclareReductionDecl>(*D) ||
 541         isa<OMPDeclareMapperDecl>(*D) || isa<OMPRequiresDecl>(*D) ||
 542         isa<OMPAllocateDecl>(*D))
 543       Terminator = nullptr;
 544     else if (isa<ObjCMethodDecl>(*D) && cast<ObjCMethodDecl>(*D)->hasBody())
 545       Terminator = nullptr;
 546     else if (auto FD = dyn_cast<FunctionDecl>(*D)) {
 547       if (FD->doesThisDeclarationHaveABody() && !FD->isDefaulted())
 548         Terminator = nullptr;
 549       else
 550         Terminator = ";";
 551     } else if (auto TD = dyn_cast<FunctionTemplateDecl>(*D)) {
 552       if (TD->getTemplatedDecl()->doesThisDeclarationHaveABody())
 553         Terminator = nullptr;
 554       else
 555         Terminator = ";";
 556     } else if (isa<NamespaceDecl, LinkageSpecDecl, ObjCImplementationDecl,
 557                    ObjCInterfaceDecl, ObjCProtocolDecl, ObjCCategoryImplDecl,
 558                    ObjCCategoryDecl, HLSLBufferDecl>(*D))
 559       Terminator = nullptr;
 560     else if (isa<EnumConstantDecl>(*D)) {
 561       DeclContext::decl_iterator Next = D;
 562       ++Next;
 563       if (Next != DEnd)
 564         Terminator = ",";
 565     } else
 566       Terminator = ";";
 567
 568     if (Terminator)
 569       Out << Terminator;
 570     if (!Policy.TerseOutput &&
 571         ((isa<FunctionDecl>(*D) &&
 572           cast<FunctionDecl>(*D)->doesThisDeclarationHaveABody()) ||
 573          (isa<FunctionTemplateDecl>(*D) &&
 574           cast<FunctionTemplateDecl>(*D)->getTemplatedDecl()->doesThisDeclarationHaveABody())))
 575       ; // StmtPrinter already added '\n' after CompoundStmt.
 576     else
 577       Out << "\n";
 578
 579     // Declare target attribute is special one, natural spelling for the pragma
 580     // assumes "ending" construct so print it here.
 581     if (D->hasAttr<OMPDeclareTargetDeclAttr>())
 582       Out << "#pragma omp end declare target\n";
 583   }
 584
 585   if (!Decls.empty())
 586     ProcessDeclGroup(Decls);
 587
 588   if (Indent)
 589     Indentation -= Policy.Indentation;
 590 }
 591
 592 void DeclPrinter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
 593   VisitDeclContext(D, false);
 594 }
 595
 596 void DeclPrinter::VisitTypedefDecl(TypedefDecl *D) {
 597   if (!Policy.SuppressSpecifiers) {
 598     Out << "typedef ";
 599
 600     if (D->isModulePrivate())
 601       Out << "__module_private__ ";
 602   }
 603   QualType Ty = D->getTypeSourceInfo()->getType();
 604   Ty.print(Out, Policy, D->getName(), Indentation);
 605   prettyPrintAttributes(D);
 606 }
 607
 608 void DeclPrinter::VisitTypeAliasDecl(TypeAliasDecl *D) {
 609   Out << "using " << *D;
 610   prettyPrintAttributes(D);
 611   Out << " = " << D->getTypeSourceInfo()->getType().getAsString(Policy);
 612 }
 613
 614 void DeclPrinter::VisitEnumDecl(EnumDecl *D) {
 615   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
 616     Out << "__module_private__ ";
 617   Out << "enum";
 618   if (D->isScoped()) {
 619     if (D->isScopedUsingClassTag())
 620       Out << " class";
 621     else
 622       Out << " struct";
 623   }
 624
 625   prettyPrintAttributes(D);
 626
 627   if (D->getDeclName())
 628     Out << ' ' << D->getDeclName();
 629
 630   if (D->isFixed())
 631     Out << " : " << D->getIntegerType().stream(Policy);
 632
 633   if (D->isCompleteDefinition()) {
 634     Out << " {\n";
 635     VisitDeclContext(D);
 636     Indent() << "}";
 637   }
 638 }
 639
 640 void DeclPrinter::VisitRecordDecl(RecordDecl *D) {
 641   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
 642     Out << "__module_private__ ";
 643   Out << D->getKindName();
 644
 645   prettyPrintAttributes(D);
 646
 647   if (D->getIdentifier())
 648     Out << ' ' << *D;
 649
 650   if (D->isCompleteDefinition()) {
 651     Out << " {\n";
 652     VisitDeclContext(D);
 653     Indent() << "}";
 654   }
 655 }
 656
 657 void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) {
 658   Out << *D;
 659   prettyPrintAttributes(D);
 660   if (Expr *Init = D->getInitExpr()) {
 661     Out << " = ";
 662     Init->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
 663   }
 664 }
 665
 666 static void printExplicitSpecifier(ExplicitSpecifier ES, llvm::raw_ostream &Out,
 667                                    PrintingPolicy &Policy, unsigned Indentation,
 668                                    const ASTContext &Context) {
 669   std::string Proto = "explicit";
 670   llvm::raw_string_ostream EOut(Proto);
 671   if (ES.getExpr()) {
 672     EOut << "(";
 673     ES.getExpr()->printPretty(EOut, nullptr, Policy, Indentation, "\n",
 674                               &Context);
 675     EOut << ")";
 676   }
 677   EOut << " ";
 678   EOut.flush();
 679   Out << Proto;
 680 }
 681
 682 void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
 683   if (!D->getDescribedFunctionTemplate() &&
 684       !D->isFunctionTemplateSpecialization())
 685     prettyPrintPragmas(D);
 686
 687   if (D->isFunctionTemplateSpecialization())
 688     Out << "template<> ";
 689   else if (!D->getDescribedFunctionTemplate()) {
 690     for (unsigned I = 0, NumTemplateParams = D->getNumTemplateParameterLists();
 691          I < NumTemplateParams; ++I)
 692       printTemplateParameters(D->getTemplateParameterList(I));
 693   }
 694
 695   std::string LeftsideAttrs;
 696   llvm::raw_string_ostream LSAS(LeftsideAttrs);
 697
 698   prettyPrintAttributes(D, LSAS, AttrPrintLoc::Left);
 699
 700   // prettyPrintAttributes print a space on left side of the attribute.
 701   if (LeftsideAttrs[0] == ' ') {
 702     // Skip the space prettyPrintAttributes generated.
 703     LeftsideAttrs.erase(0, LeftsideAttrs.find_first_not_of(' '));
 704
 705     // Add a single space between the attribute and the Decl name.
 706     LSAS << ' ';
 707   }
 708
 709   Out << LeftsideAttrs;
 710
 711   CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D);
 712   CXXConversionDecl *ConversionDecl = dyn_cast<CXXConversionDecl>(D);
 713   CXXDeductionGuideDecl *GuideDecl = dyn_cast<CXXDeductionGuideDecl>(D);
 714   if (!Policy.SuppressSpecifiers) {
 715     switch (D->getStorageClass()) {
 716     case SC_None: break;
 717     case SC_Extern: Out << "extern "; break;
 718     case SC_Static: Out << "static "; break;
 719     case SC_PrivateExtern: Out << "__private_extern__ "; break;
 720     case SC_Auto: case SC_Register:
 721       llvm_unreachable("invalid for functions");
 722     }
 723
 724     if (D->isInlineSpecified())  Out << "inline ";
 725     if (D->isVirtualAsWritten()) Out << "virtual ";
 726     if (D->isModulePrivate())    Out << "__module_private__ ";
 727     if (D->isConstexprSpecified() && !D->isExplicitlyDefaulted())
 728       Out << "constexpr ";
 729     if (D->isConsteval())        Out << "consteval ";
 730     else if (D->isImmediateFunction())
 731       Out << "immediate ";
 732     ExplicitSpecifier ExplicitSpec = ExplicitSpecifier::getFromDecl(D);
 733     if (ExplicitSpec.isSpecified())
 734       printExplicitSpecifier(ExplicitSpec, Out, Policy, Indentation, Context);
 735   }
 736
 737   PrintingPolicy SubPolicy(Policy);
 738   SubPolicy.SuppressSpecifiers = false;
 739   std::string Proto;
 740
 741   if (Policy.FullyQualifiedName) {
 742     Proto += D->getQualifiedNameAsString();
 743   } else {
 744     llvm::raw_string_ostream OS(Proto);
 745     if (!Policy.SuppressScope) {
 746       if (const NestedNameSpecifier *NS = D->getQualifier()) {
 747         NS->print(OS, Policy);
 748       }
 749     }
 750     D->getNameInfo().printName(OS, Policy);
 751   }
 752
 753   if (GuideDecl)
 754     Proto = GuideDecl->getDeducedTemplate()->getDeclName().getAsString();
 755   if (D->isFunctionTemplateSpecialization()) {
 756     llvm::raw_string_ostream POut(Proto);
 757     DeclPrinter TArgPrinter(POut, SubPolicy, Context, Indentation);
 758     const auto *TArgAsWritten = D->getTemplateSpecializationArgsAsWritten();
 759     if (TArgAsWritten && !Policy.PrintCanonicalTypes)
 760       TArgPrinter.printTemplateArguments(TArgAsWritten->arguments(), nullptr);
 761     else if (const TemplateArgumentList *TArgs =
 762                  D->getTemplateSpecializationArgs())
 763       TArgPrinter.printTemplateArguments(TArgs->asArray(), nullptr);
 764   }
 765
 766   QualType Ty = D->getType();
 767   while (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
 768     Proto = '(' + Proto + ')';
 769     Ty = PT->getInnerType();
 770   }
 771
 772   if (const FunctionType *AFT = Ty->getAs<FunctionType>()) {
 773     const FunctionProtoType *FT = nullptr;
 774     if (D->hasWrittenPrototype())
 775       FT = dyn_cast<FunctionProtoType>(AFT);
 776
 777     Proto += "(";
 778     if (FT) {
 779       llvm::raw_string_ostream POut(Proto);
 780       DeclPrinter ParamPrinter(POut, SubPolicy, Context, Indentation);
 781       for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
 782         if (i) POut << ", ";
 783         ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
 784       }
 785
 786       if (FT->isVariadic()) {
 787         if (D->getNumParams()) POut << ", ";
 788         POut << "...";
 789       } else if (!D->getNumParams() && !Context.getLangOpts().CPlusPlus) {
 790         // The function has a prototype, so it needs to retain the prototype
 791         // in C.
 792         POut << "void";
 793       }
 794     } else if (D->doesThisDeclarationHaveABody() && !D->hasPrototype()) {
 795       for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
 796         if (i)
 797           Proto += ", ";
 798         Proto += D->getParamDecl(i)->getNameAsString();
 799       }
 800     }
 801
 802     Proto += ")";
 803
 804     if (FT) {
 805       if (FT->isConst())
 806         Proto += " const";
 807       if (FT->isVolatile())
 808         Proto += " volatile";
 809       if (FT->isRestrict())
 810         Proto += " restrict";
 811
 812       switch (FT->getRefQualifier()) {
 813       case RQ_None:
 814         break;
 815       case RQ_LValue:
 816         Proto += " &";
 817         break;
 818       case RQ_RValue:
 819         Proto += " &&";
 820         break;
 821       }
 822     }
 823
 824     if (FT && FT->hasDynamicExceptionSpec()) {
 825       Proto += " throw(";
 826       if (FT->getExceptionSpecType() == EST_MSAny)
 827         Proto += "...";
 828       else
 829         for (unsigned I = 0, N = FT->getNumExceptions(); I != N; ++I) {
 830           if (I)
 831             Proto += ", ";
 832
 833           Proto += FT->getExceptionType(I).getAsString(SubPolicy);
 834         }
 835       Proto += ")";
 836     } else if (FT && isNoexceptExceptionSpec(FT->getExceptionSpecType())) {
 837       Proto += " noexcept";
 838       if (isComputedNoexcept(FT->getExceptionSpecType())) {
 839         Proto += "(";
 840         llvm::raw_string_ostream EOut(Proto);
 841         FT->getNoexceptExpr()->printPretty(EOut, nullptr, SubPolicy,
 842                                            Indentation, "\n", &Context);
 843         EOut.flush();
 844         Proto += ")";
 845       }
 846     }
 847
 848     if (CDecl) {
 849       if (!Policy.TerseOutput)
 850         PrintConstructorInitializers(CDecl, Proto);
 851     } else if (!ConversionDecl && !isa<CXXDestructorDecl>(D)) {
 852       if (FT && FT->hasTrailingReturn()) {
 853         if (!GuideDecl)
 854           Out << "auto ";
 855         Out << Proto << " -> ";
 856         Proto.clear();
 857       }
 858       AFT->getReturnType().print(Out, Policy, Proto);
 859       Proto.clear();
 860     }
 861     Out << Proto;
 862
 863     if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause()) {
 864       Out << " requires ";
 865       TrailingRequiresClause->printPretty(Out, nullptr, SubPolicy, Indentation,
 866                                           "\n", &Context);
 867     }
 868   } else {
 869     Ty.print(Out, Policy, Proto);
 870   }
 871
 872   prettyPrintAttributes(D, Out, AttrPrintLoc::Right);
 873
 874   if (D->isPure())
 875     Out << " = 0";
 876   else if (D->isDeletedAsWritten())
 877     Out << " = delete";
 878   else if (D->isExplicitlyDefaulted())
 879     Out << " = default";
 880   else if (D->doesThisDeclarationHaveABody()) {
 881     if (!Policy.TerseOutput) {
 882       if (!D->hasPrototype() && D->getNumParams()) {
 883         // This is a K&R function definition, so we need to print the
 884         // parameters.
 885         Out << '\n';
 886         DeclPrinter ParamPrinter(Out, SubPolicy, Context, Indentation);
 887         Indentation += Policy.Indentation;
 888         for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
 889           Indent();
 890           ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
 891           Out << ";\n";
 892         }
 893         Indentation -= Policy.Indentation;
 894       }
 895
 896       if (D->getBody())
 897         D->getBody()->printPrettyControlled(Out, nullptr, SubPolicy, Indentation, "\n",
 898                                   &Context);
 899     } else {
 900       if (!Policy.TerseOutput && isa<CXXConstructorDecl>(*D))
 901         Out << " {}";
 902     }
 903   }
 904 }
 905
 906 void DeclPrinter::VisitFriendDecl(FriendDecl *D) {
 907   if (TypeSourceInfo *TSI = D->getFriendType()) {
 908     unsigned NumTPLists = D->getFriendTypeNumTemplateParameterLists();
 909     for (unsigned i = 0; i < NumTPLists; ++i)
 910       printTemplateParameters(D->getFriendTypeTemplateParameterList(i));
 911     Out << "friend ";
 912     Out << " " << TSI->getType().getAsString(Policy);
 913   }
 914   else if (FunctionDecl *FD =
 915       dyn_cast<FunctionDecl>(D->getFriendDecl())) {
 916     Out << "friend ";
 917     VisitFunctionDecl(FD);
 918   }
 919   else if (FunctionTemplateDecl *FTD =
 920            dyn_cast<FunctionTemplateDecl>(D->getFriendDecl())) {
 921     Out << "friend ";
 922     VisitFunctionTemplateDecl(FTD);
 923   }
 924   else if (ClassTemplateDecl *CTD =
 925            dyn_cast<ClassTemplateDecl>(D->getFriendDecl())) {
 926     Out << "friend ";
 927     VisitRedeclarableTemplateDecl(CTD);
 928   }
 929 }
 930
 931 void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
 932   // FIXME: add printing of pragma attributes if required.
 933   if (!Policy.SuppressSpecifiers && D->isMutable())
 934     Out << "mutable ";
 935   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
 936     Out << "__module_private__ ";
 937
 938   Out << D->getASTContext().getUnqualifiedObjCPointerType(D->getType()).
 939          stream(Policy, D->getName(), Indentation);
 940
 941   if (D->isBitField()) {
 942     Out << " : ";
 943     D->getBitWidth()->printPretty(Out, nullptr, Policy, Indentation, "\n",
 944                                   &Context);
 945   }
 946
 947   Expr *Init = D->getInClassInitializer();
 948   if (!Policy.SuppressInitializers && Init) {
 949     if (D->getInClassInitStyle() == ICIS_ListInit)
 950       Out << " ";
 951     else
 952       Out << " = ";
 953     Init->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
 954   }
 955   prettyPrintAttributes(D);
 956 }
 957
 958 void DeclPrinter::VisitLabelDecl(LabelDecl *D) {
 959   Out << *D << ":";
 960 }
 961
 962 void DeclPrinter::VisitVarDecl(VarDecl *D) {
 963   prettyPrintPragmas(D);
 964
 965   if (const auto *Param = dyn_cast<ParmVarDecl>(D);
 966       Param && Param->isExplicitObjectParameter())
 967     Out << "this ";
 968
 969   std::string LeftSide;
 970   llvm::raw_string_ostream LeftSideStream(LeftSide);
 971
 972   // Print attributes that should be placed on the left, such as __declspec.
 973   prettyPrintAttributes(D, LeftSideStream, AttrPrintLoc::Left);
 974
 975   // prettyPrintAttributes print a space on left side of the attribute.
 976   if (LeftSide[0] == ' ') {
 977     // Skip the space prettyPrintAttributes generated.
 978     LeftSide.erase(0, LeftSide.find_first_not_of(' '));
 979
 980     // Add a single space between the attribute and the Decl name.
 981     LeftSideStream << ' ';
 982   }
 983
 984   Out << LeftSide;
 985
 986   QualType T = D->getTypeSourceInfo()
 987     ? D->getTypeSourceInfo()->getType()
 988     : D->getASTContext().getUnqualifiedObjCPointerType(D->getType());
 989
 990   if (!Policy.SuppressSpecifiers) {
 991     StorageClass SC = D->getStorageClass();
 992     if (SC != SC_None)
 993       Out << VarDecl::getStorageClassSpecifierString(SC) << " ";
 994
 995     switch (D->getTSCSpec()) {
 996     case TSCS_unspecified:
 997       break;
 998     case TSCS___thread:
 999       Out << "__thread ";
1000       break;
1001     case TSCS__Thread_local:
1002       Out << "_Thread_local ";
1003       break;
1004     case TSCS_thread_local:
1005       Out << "thread_local ";
1006       break;
1007     }
1008
1009     if (D->isModulePrivate())
1010       Out << "__module_private__ ";
1011
1012     if (D->isConstexpr()) {
1013       Out << "constexpr ";
1014       T.removeLocalConst();
1015     }
1016   }
1017
1018   StringRef Name;
1019
1020   Name = (isa<ParmVarDecl>(D) && Policy.CleanUglifiedParameters &&
1021           D->getIdentifier())
1022              ? D->getIdentifier()->deuglifiedName()
1023              : D->getName();
1024
1025   printDeclType(T, Name);
1026
1027   // Print the attributes that should be placed right before the end of the
1028   // decl.
1029   prettyPrintAttributes(D, Out, AttrPrintLoc::Right);
1030
1031   Expr *Init = D->getInit();
1032   if (!Policy.SuppressInitializers && Init) {
1033     bool ImplicitInit = false;
1034     if (D->isCXXForRangeDecl()) {
1035       // FIXME: We should print the range expression instead.
1036       ImplicitInit = true;
1037     } else if (CXXConstructExpr *Construct =
1038                    dyn_cast<CXXConstructExpr>(Init->IgnoreImplicit())) {
1039       if (D->getInitStyle() == VarDecl::CallInit &&
1040           !Construct->isListInitialization()) {
1041         ImplicitInit = Construct->getNumArgs() == 0 ||
1042                        Construct->getArg(0)->isDefaultArgument();
1043       }
1044     }
1045     if (!ImplicitInit) {
1046       if ((D->getInitStyle() == VarDecl::CallInit) && !isa<ParenListExpr>(Init))
1047         Out << "(";
1048       else if (D->getInitStyle() == VarDecl::CInit) {
1049         Out << " = ";
1050       }
1051       PrintingPolicy SubPolicy(Policy);
1052       SubPolicy.SuppressSpecifiers = false;
1053       SubPolicy.IncludeTagDefinition = false;
1054       Init->printPretty(Out, nullptr, SubPolicy, Indentation, "\n", &Context);
1055       if ((D->getInitStyle() == VarDecl::CallInit) && !isa<ParenListExpr>(Init))
1056         Out << ")";
1057     }
1058   }
1059 }
1060
1061 void DeclPrinter::VisitParmVarDecl(ParmVarDecl *D) {
1062   VisitVarDecl(D);
1063 }
1064
1065 void DeclPrinter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
1066   Out << "__asm (";
1067   D->getAsmString()->printPretty(Out, nullptr, Policy, Indentation, "\n",
1068                                  &Context);
1069   Out << ")";
1070 }
1071
1072 void DeclPrinter::VisitTopLevelStmtDecl(TopLevelStmtDecl *D) {
1073   assert(D->getStmt());
1074   D->getStmt()->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
1075 }
1076
1077 void DeclPrinter::VisitImportDecl(ImportDecl *D) {
1078   Out << "@import " << D->getImportedModule()->getFullModuleName()
1079       << ";\n";
1080 }
1081
1082 void DeclPrinter::VisitStaticAssertDecl(StaticAssertDecl *D) {
1083   Out << "static_assert(";
1084   D->getAssertExpr()->printPretty(Out, nullptr, Policy, Indentation, "\n",
1085                                   &Context);
1086   if (Expr *E = D->getMessage()) {
1087     Out << ", ";
1088     E->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
1089   }
1090   Out << ")";
1091 }
1092
1093 //----------------------------------------------------------------------------
1094 // C++ declarations
1095 //----------------------------------------------------------------------------
1096 void DeclPrinter::VisitNamespaceDecl(NamespaceDecl *D) {
1097   if (D->isInline())
1098     Out << "inline ";
1099
1100   Out << "namespace ";
1101   if (D->getDeclName())
1102     Out << D->getDeclName() << ' ';
1103   Out << "{\n";
1104
1105   VisitDeclContext(D);
1106   Indent() << "}";
1107 }
1108
1109 void DeclPrinter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
1110   Out << "using namespace ";
1111   if (D->getQualifier())
1112     D->getQualifier()->print(Out, Policy);
1113   Out << *D->getNominatedNamespaceAsWritten();
1114 }
1115
1116 void DeclPrinter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
1117   Out << "namespace " << *D << " = ";
1118   if (D->getQualifier())
1119     D->getQualifier()->print(Out, Policy);
1120   Out << *D->getAliasedNamespace();
1121 }
1122
1123 void DeclPrinter::VisitEmptyDecl(EmptyDecl *D) {
1124   prettyPrintAttributes(D);
1125 }
1126
1127 void DeclPrinter::VisitCXXRecordDecl(CXXRecordDecl *D) {
1128   // FIXME: add printing of pragma attributes if required.
1129   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
1130     Out << "__module_private__ ";
1131   Out << D->getKindName();
1132
1133   prettyPrintAttributes(D);
1134
1135   if (D->getIdentifier()) {
1136     Out << ' ';
1137     if (auto *NNS = D->getQualifier())
1138       NNS->print(Out, Policy);
1139     Out << *D;
1140
1141     if (auto S = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
1142       ArrayRef<TemplateArgument> Args = S->getTemplateArgs().asArray();
1143       if (!Policy.PrintCanonicalTypes)
1144         if (const auto* TSI = S->getTypeAsWritten())
1145           if (const auto *TST =
1146                   dyn_cast<TemplateSpecializationType>(TSI->getType()))
1147             Args = TST->template_arguments();
1148       printTemplateArguments(
1149           Args, S->getSpecializedTemplate()->getTemplateParameters());
1150     }
1151   }
1152
1153   if (D->hasDefinition()) {
1154     if (D->hasAttr<FinalAttr>()) {
1155       Out << " final";
1156     }
1157   }
1158
1159   if (D->isCompleteDefinition()) {
1160     // Print the base classes
1161     if (D->getNumBases()) {
1162       Out << " : ";
1163       for (CXXRecordDecl::base_class_iterator Base = D->bases_begin(),
1164              BaseEnd = D->bases_end(); Base != BaseEnd; ++Base) {
1165         if (Base != D->bases_begin())
1166           Out << ", ";
1167
1168         if (Base->isVirtual())
1169           Out << "virtual ";
1170
1171         AccessSpecifier AS = Base->getAccessSpecifierAsWritten();
1172         if (AS != AS_none) {
1173           Print(AS);
1174           Out << " ";
1175         }
1176         Out << Base->getType().getAsString(Policy);
1177
1178         if (Base->isPackExpansion())
1179           Out << "...";
1180       }
1181     }
1182
1183     // Print the class definition
1184     // FIXME: Doesn't print access specifiers, e.g., "public:"
1185     if (Policy.TerseOutput) {
1186       Out << " {}";
1187     } else {
1188       Out << " {\n";
1189       VisitDeclContext(D);
1190       Indent() << "}";
1191     }
1192   }
1193 }
1194
1195 void DeclPrinter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
1196   const char *l;
1197   if (D->getLanguage() == LinkageSpecLanguageIDs::C)
1198     l = "C";
1199   else {
1200     assert(D->getLanguage() == LinkageSpecLanguageIDs::CXX &&
1201            "unknown language in linkage specification");
1202     l = "C++";
1203   }
1204
1205   Out << "extern \"" << l << "\" ";
1206   if (D->hasBraces()) {
1207     Out << "{\n";
1208     VisitDeclContext(D);
1209     Indent() << "}";
1210   } else
1211     Visit(*D->decls_begin());
1212 }
1213
1214 void DeclPrinter::printTemplateParameters(const TemplateParameterList *Params,
1215                                           bool OmitTemplateKW) {
1216   assert(Params);
1217
1218   if (!OmitTemplateKW)
1219     Out << "template ";
1220   Out << '<';
1221
1222   bool NeedComma = false;
1223   for (const Decl *Param : *Params) {
1224     if (Param->isImplicit())
1225       continue;
1226
1227     if (NeedComma)
1228       Out << ", ";
1229     else
1230       NeedComma = true;
1231
1232     if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
1233       VisitTemplateTypeParmDecl(TTP);
1234     } else if (auto NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
1235       VisitNonTypeTemplateParmDecl(NTTP);
1236     } else if (auto TTPD = dyn_cast<TemplateTemplateParmDecl>(Param)) {
1237       VisitTemplateDecl(TTPD);
1238       // FIXME: print the default argument, if present.
1239     }
1240   }
1241
1242   Out << '>';
1243   if (!OmitTemplateKW)
1244     Out << ' ';
1245 }
1246
1247 void DeclPrinter::printTemplateArguments(ArrayRef<TemplateArgument> Args,
1248                                          const TemplateParameterList *Params) {
1249   Out << "<";
1250   for (size_t I = 0, E = Args.size(); I < E; ++I) {
1251     if (I)
1252       Out << ", ";
1253     if (!Params)
1254       Args[I].print(Policy, Out, /*IncludeType*/ true);
1255     else
1256       Args[I].print(Policy, Out,
1257                     TemplateParameterList::shouldIncludeTypeForArgument(
1258                         Policy, Params, I));
1259   }
1260   Out << ">";
1261 }
1262
1263 void DeclPrinter::printTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
1264                                          const TemplateParameterList *Params) {
1265   Out << "<";
1266   for (size_t I = 0, E = Args.size(); I < E; ++I) {
1267     if (I)
1268       Out << ", ";
1269     if (!Params)
1270       Args[I].getArgument().print(Policy, Out, /*IncludeType*/ true);
1271     else
1272       Args[I].getArgument().print(
1273           Policy, Out,
1274           TemplateParameterList::shouldIncludeTypeForArgument(Policy, Params,
1275                                                               I));
1276   }
1277   Out << ">";
1278 }
1279
1280 void DeclPrinter::VisitTemplateDecl(const TemplateDecl *D) {
1281   printTemplateParameters(D->getTemplateParameters());
1282
1283   if (const TemplateTemplateParmDecl *TTP =
1284         dyn_cast<TemplateTemplateParmDecl>(D)) {
1285     Out << "class";
1286
1287     if (TTP->isParameterPack())
1288       Out << " ...";
1289     else if (TTP->getDeclName())
1290       Out << ' ';
1291
1292     if (TTP->getDeclName()) {
1293       if (Policy.CleanUglifiedParameters && TTP->getIdentifier())
1294         Out << TTP->getIdentifier()->deuglifiedName();
1295       else
1296         Out << TTP->getDeclName();
1297     }
1298   } else if (auto *TD = D->getTemplatedDecl())
1299     Visit(TD);
1300   else if (const auto *Concept = dyn_cast<ConceptDecl>(D)) {
1301     Out << "concept " << Concept->getName() << " = " ;
1302     Concept->getConstraintExpr()->printPretty(Out, nullptr, Policy, Indentation,
1303                                               "\n", &Context);
1304   }
1305 }
1306
1307 void DeclPrinter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
1308   prettyPrintPragmas(D->getTemplatedDecl());
1309   // Print any leading template parameter lists.
1310   if (const FunctionDecl *FD = D->getTemplatedDecl()) {
1311     for (unsigned I = 0, NumTemplateParams = FD->getNumTemplateParameterLists();
1312          I < NumTemplateParams; ++I)
1313       printTemplateParameters(FD->getTemplateParameterList(I));
1314   }
1315   VisitRedeclarableTemplateDecl(D);
1316   // Declare target attribute is special one, natural spelling for the pragma
1317   // assumes "ending" construct so print it here.
1318   if (D->getTemplatedDecl()->hasAttr<OMPDeclareTargetDeclAttr>())
1319     Out << "#pragma omp end declare target\n";
1320
1321   // Never print "instantiations" for deduction guides (they don't really
1322   // have them).
1323   if (PrintInstantiation &&
1324       !isa<CXXDeductionGuideDecl>(D->getTemplatedDecl())) {
1325     FunctionDecl *PrevDecl = D->getTemplatedDecl();
1326     const FunctionDecl *Def;
1327     if (PrevDecl->isDefined(Def) && Def != PrevDecl)
1328       return;
1329     for (auto *I : D->specializations())
1330       if (I->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) {
1331         if (!PrevDecl->isThisDeclarationADefinition())
1332           Out << ";\n";
1333         Indent();
1334         prettyPrintPragmas(I);
1335         Visit(I);
1336       }
1337   }
1338 }
1339
1340 void DeclPrinter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
1341   VisitRedeclarableTemplateDecl(D);
1342
1343   if (PrintInstantiation) {
1344     for (auto *I : D->specializations())
1345       if (I->getSpecializationKind() == TSK_ImplicitInstantiation) {
1346         if (D->isThisDeclarationADefinition())
1347           Out << ";";
1348         Out << "\n";
1349         Indent();
1350         Visit(I);
1351       }
1352   }
1353 }
1354
1355 void DeclPrinter::VisitClassTemplateSpecializationDecl(
1356                                            ClassTemplateSpecializationDecl *D) {
1357   Out << "template<> ";
1358   VisitCXXRecordDecl(D);
1359 }
1360
1361 void DeclPrinter::VisitClassTemplatePartialSpecializationDecl(
1362                                     ClassTemplatePartialSpecializationDecl *D) {
1363   printTemplateParameters(D->getTemplateParameters());
1364   VisitCXXRecordDecl(D);
1365 }
1366
1367 //----------------------------------------------------------------------------
1368 // Objective-C declarations
1369 //----------------------------------------------------------------------------
1370
1371 void DeclPrinter::PrintObjCMethodType(ASTContext &Ctx,
1372                                       Decl::ObjCDeclQualifier Quals,
1373                                       QualType T) {
1374   Out << '(';
1375   if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_In)
1376     Out << "in ";
1377   if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Inout)
1378     Out << "inout ";
1379   if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Out)
1380     Out << "out ";
1381   if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Bycopy)
1382     Out << "bycopy ";
1383   if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Byref)
1384     Out << "byref ";
1385   if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_Oneway)
1386     Out << "oneway ";
1387   if (Quals & Decl::ObjCDeclQualifier::OBJC_TQ_CSNullability) {
1388     if (auto nullability = AttributedType::stripOuterNullability(T))
1389       Out << getNullabilitySpelling(*nullability, true) << ' ';
1390   }
1391
1392   Out << Ctx.getUnqualifiedObjCPointerType(T).getAsString(Policy);
1393   Out << ')';
1394 }
1395
1396 void DeclPrinter::PrintObjCTypeParams(ObjCTypeParamList *Params) {
1397   Out << "<";
1398   unsigned First = true;
1399   for (auto *Param : *Params) {
1400     if (First) {
1401       First = false;
1402     } else {
1403       Out << ", ";
1404     }
1405
1406     switch (Param->getVariance()) {
1407     case ObjCTypeParamVariance::Invariant:
1408       break;
1409
1410     case ObjCTypeParamVariance::Covariant:
1411       Out << "__covariant ";
1412       break;
1413
1414     case ObjCTypeParamVariance::Contravariant:
1415       Out << "__contravariant ";
1416       break;
1417     }
1418
1419     Out << Param->getDeclName();
1420
1421     if (Param->hasExplicitBound()) {
1422       Out << " : " << Param->getUnderlyingType().getAsString(Policy);
1423     }
1424   }
1425   Out << ">";
1426 }
1427
1428 void DeclPrinter::VisitObjCMethodDecl(ObjCMethodDecl *OMD) {
1429   if (OMD->isInstanceMethod())
1430     Out << "- ";
1431   else
1432     Out << "+ ";
1433   if (!OMD->getReturnType().isNull()) {
1434     PrintObjCMethodType(OMD->getASTContext(), OMD->getObjCDeclQualifier(),
1435                         OMD->getReturnType());
1436   }
1437
1438   std::string name = OMD->getSelector().getAsString();
1439   std::string::size_type pos, lastPos = 0;
1440   for (const auto *PI : OMD->parameters()) {
1441     // FIXME: selector is missing here!
1442     pos = name.find_first_of(':', lastPos);
1443     if (lastPos != 0)
1444       Out << " ";
1445     Out << name.substr(lastPos, pos - lastPos) << ':';
1446     PrintObjCMethodType(OMD->getASTContext(),
1447                         PI->getObjCDeclQualifier(),
1448                         PI->getType());
1449     Out << *PI;
1450     lastPos = pos + 1;
1451   }
1452
1453   if (OMD->param_begin() == OMD->param_end())
1454     Out << name;
1455
1456   if (OMD->isVariadic())
1457       Out << ", ...";
1458
1459   prettyPrintAttributes(OMD);
1460
1461   if (OMD->getBody() && !Policy.TerseOutput) {
1462     Out << ' ';
1463     OMD->getBody()->printPretty(Out, nullptr, Policy, Indentation, "\n",
1464                                 &Context);
1465   }
1466   else if (Policy.PolishForDeclaration)
1467     Out << ';';
1468 }
1469
1470 void DeclPrinter::VisitObjCImplementationDecl(ObjCImplementationDecl *OID) {
1471   std::string I = OID->getNameAsString();
1472   ObjCInterfaceDecl *SID = OID->getSuperClass();
1473
1474   bool eolnOut = false;
1475   if (SID)
1476     Out << "@implementation " << I << " : " << *SID;
1477   else
1478     Out << "@implementation " << I;
1479
1480   if (OID->ivar_size() > 0) {
1481     Out << "{\n";
1482     eolnOut = true;
1483     Indentation += Policy.Indentation;
1484     for (const auto *I : OID->ivars()) {
1485       Indent() << I->getASTContext().getUnqualifiedObjCPointerType(I->getType()).
1486                     getAsString(Policy) << ' ' << *I << ";\n";
1487     }
1488     Indentation -= Policy.Indentation;
1489     Out << "}\n";
1490   }
1491   else if (SID || (OID->decls_begin() != OID->decls_end())) {
1492     Out << "\n";
1493     eolnOut = true;
1494   }
1495   VisitDeclContext(OID, false);
1496   if (!eolnOut)
1497     Out << "\n";
1498   Out << "@end";
1499 }
1500
1501 void DeclPrinter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *OID) {
1502   std::string I = OID->getNameAsString();
1503   ObjCInterfaceDecl *SID = OID->getSuperClass();
1504
1505   if (!OID->isThisDeclarationADefinition()) {
1506     Out << "@class " << I;
1507
1508     if (auto TypeParams = OID->getTypeParamListAsWritten()) {
1509       PrintObjCTypeParams(TypeParams);
1510     }
1511
1512     Out << ";";
1513     return;
1514   }
1515   bool eolnOut = false;
1516   Out << "@interface " << I;
1517
1518   if (auto TypeParams = OID->getTypeParamListAsWritten()) {
1519     PrintObjCTypeParams(TypeParams);
1520   }
1521
1522   if (SID)
1523     Out << " : " << QualType(OID->getSuperClassType(), 0).getAsString(Policy);
1524
1525   // Protocols?
1526   const ObjCList<ObjCProtocolDecl> &Protocols = OID->getReferencedProtocols();
1527   if (!Protocols.empty()) {
1528     for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
1529          E = Protocols.end(); I != E; ++I)
1530       Out << (I == Protocols.begin() ? '<' : ',') << **I;
1531     Out << "> ";
1532   }
1533
1534   if (OID->ivar_size() > 0) {
1535     Out << "{\n";
1536     eolnOut = true;
1537     Indentation += Policy.Indentation;
1538     for (const auto *I : OID->ivars()) {
1539       Indent() << I->getASTContext()
1540                       .getUnqualifiedObjCPointerType(I->getType())
1541                       .getAsString(Policy) << ' ' << *I << ";\n";
1542     }
1543     Indentation -= Policy.Indentation;
1544     Out << "}\n";
1545   }
1546   else if (SID || (OID->decls_begin() != OID->decls_end())) {
1547     Out << "\n";
1548     eolnOut = true;
1549   }
1550
1551   VisitDeclContext(OID, false);
1552   if (!eolnOut)
1553     Out << "\n";
1554   Out << "@end";
1555   // FIXME: implement the rest...
1556 }
1557
1558 void DeclPrinter::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
1559   if (!PID->isThisDeclarationADefinition()) {
1560     Out << "@protocol " << *PID << ";\n";
1561     return;
1562   }
1563   // Protocols?
1564   const ObjCList<ObjCProtocolDecl> &Protocols = PID->getReferencedProtocols();
1565   if (!Protocols.empty()) {
1566     Out << "@protocol " << *PID;
1567     for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
1568          E = Protocols.end(); I != E; ++I)
1569       Out << (I == Protocols.begin() ? '<' : ',') << **I;
1570     Out << ">\n";
1571   } else
1572     Out << "@protocol " << *PID << '\n';
1573   VisitDeclContext(PID, false);
1574   Out << "@end";
1575 }
1576
1577 void DeclPrinter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *PID) {
1578   Out << "@implementation ";
1579   if (const auto *CID = PID->getClassInterface())
1580     Out << *CID;
1581   else
1582     Out << "<<error-type>>";
1583   Out << '(' << *PID << ")\n";
1584
1585   VisitDeclContext(PID, false);
1586   Out << "@end";
1587   // FIXME: implement the rest...
1588 }
1589
1590 void DeclPrinter::VisitObjCCategoryDecl(ObjCCategoryDecl *PID) {
1591   Out << "@interface ";
1592   if (const auto *CID = PID->getClassInterface())
1593     Out << *CID;
1594   else
1595     Out << "<<error-type>>";
1596   if (auto TypeParams = PID->getTypeParamList()) {
1597     PrintObjCTypeParams(TypeParams);
1598   }
1599   Out << "(" << *PID << ")\n";
1600   if (PID->ivar_size() > 0) {
1601     Out << "{\n";
1602     Indentation += Policy.Indentation;
1603     for (const auto *I : PID->ivars())
1604       Indent() << I->getASTContext().getUnqualifiedObjCPointerType(I->getType()).
1605                     getAsString(Policy) << ' ' << *I << ";\n";
1606     Indentation -= Policy.Indentation;
1607     Out << "}\n";
1608   }
1609
1610   VisitDeclContext(PID, false);
1611   Out << "@end";
1612
1613   // FIXME: implement the rest...
1614 }
1615
1616 void DeclPrinter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *AID) {
1617   Out << "@compatibility_alias " << *AID
1618       << ' ' << *AID->getClassInterface() << ";\n";
1619 }
1620
1621 /// PrintObjCPropertyDecl - print a property declaration.
1622 ///
1623 /// Print attributes in the following order:
1624 /// - class
1625 /// - nonatomic | atomic
1626 /// - assign | retain | strong | copy | weak | unsafe_unretained
1627 /// - readwrite | readonly
1628 /// - getter & setter
1629 /// - nullability
1630 void DeclPrinter::VisitObjCPropertyDecl(ObjCPropertyDecl *PDecl) {
1631   if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Required)
1632     Out << "@required\n";
1633   else if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Optional)
1634     Out << "@optional\n";
1635
1636   QualType T = PDecl->getType();
1637
1638   Out << "@property";
1639   if (PDecl->getPropertyAttributes() != ObjCPropertyAttribute::kind_noattr) {
1640     bool first = true;
1641     Out << "(";
1642     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_class) {
1643       Out << (first ? "" : ", ") << "class";
1644       first = false;
1645     }
1646
1647     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_direct) {
1648       Out << (first ? "" : ", ") << "direct";
1649       first = false;
1650     }
1651
1652     if (PDecl->getPropertyAttributes() &
1653         ObjCPropertyAttribute::kind_nonatomic) {
1654       Out << (first ? "" : ", ") << "nonatomic";
1655       first = false;
1656     }
1657     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_atomic) {
1658       Out << (first ? "" : ", ") << "atomic";
1659       first = false;
1660     }
1661
1662     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_assign) {
1663       Out << (first ? "" : ", ") << "assign";
1664       first = false;
1665     }
1666     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_retain) {
1667       Out << (first ? "" : ", ") << "retain";
1668       first = false;
1669     }
1670
1671     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_strong) {
1672       Out << (first ? "" : ", ") << "strong";
1673       first = false;
1674     }
1675     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_copy) {
1676       Out << (first ? "" : ", ") << "copy";
1677       first = false;
1678     }
1679     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_weak) {
1680       Out << (first ? "" : ", ") << "weak";
1681       first = false;
1682     }
1683     if (PDecl->getPropertyAttributes() &
1684         ObjCPropertyAttribute::kind_unsafe_unretained) {
1685       Out << (first ? "" : ", ") << "unsafe_unretained";
1686       first = false;
1687     }
1688
1689     if (PDecl->getPropertyAttributes() &
1690         ObjCPropertyAttribute::kind_readwrite) {
1691       Out << (first ? "" : ", ") << "readwrite";
1692       first = false;
1693     }
1694     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_readonly) {
1695       Out << (first ? "" : ", ") << "readonly";
1696       first = false;
1697     }
1698
1699     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_getter) {
1700       Out << (first ? "" : ", ") << "getter = ";
1701       PDecl->getGetterName().print(Out);
1702       first = false;
1703     }
1704     if (PDecl->getPropertyAttributes() & ObjCPropertyAttribute::kind_setter) {
1705       Out << (first ? "" : ", ") << "setter = ";
1706       PDecl->getSetterName().print(Out);
1707       first = false;
1708     }
1709
1710     if (PDecl->getPropertyAttributes() &
1711         ObjCPropertyAttribute::kind_nullability) {
1712       if (auto nullability = AttributedType::stripOuterNullability(T)) {
1713         if (*nullability == NullabilityKind::Unspecified &&
1714             (PDecl->getPropertyAttributes() &
1715              ObjCPropertyAttribute::kind_null_resettable)) {
1716           Out << (first ? "" : ", ") << "null_resettable";
1717         } else {
1718           Out << (first ? "" : ", ")
1719               << getNullabilitySpelling(*nullability, true);
1720         }
1721         first = false;
1722       }
1723     }
1724
1725     (void) first; // Silence dead store warning due to idiomatic code.
1726     Out << ")";
1727   }
1728   std::string TypeStr = PDecl->getASTContext().getUnqualifiedObjCPointerType(T).
1729       getAsString(Policy);
1730   Out << ' ' << TypeStr;
1731   if (!StringRef(TypeStr).endswith("*"))
1732     Out << ' ';
1733   Out << *PDecl;
1734   if (Policy.PolishForDeclaration)
1735     Out << ';';
1736 }
1737
1738 void DeclPrinter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PID) {
1739   if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
1740     Out << "@synthesize ";
1741   else
1742     Out << "@dynamic ";
1743   Out << *PID->getPropertyDecl();
1744   if (PID->getPropertyIvarDecl())
1745     Out << '=' << *PID->getPropertyIvarDecl();
1746 }
1747
1748 void DeclPrinter::VisitUsingDecl(UsingDecl *D) {
1749   if (!D->isAccessDeclaration())
1750     Out << "using ";
1751   if (D->hasTypename())
1752     Out << "typename ";
1753   D->getQualifier()->print(Out, Policy);
1754
1755   // Use the correct record name when the using declaration is used for
1756   // inheriting constructors.
1757   for (const auto *Shadow : D->shadows()) {
1758     if (const auto *ConstructorShadow =
1759             dyn_cast<ConstructorUsingShadowDecl>(Shadow)) {
1760       assert(Shadow->getDeclContext() == ConstructorShadow->getDeclContext());
1761       Out << *ConstructorShadow->getNominatedBaseClass();
1762       return;
1763     }
1764   }
1765   Out << *D;
1766 }
1767
1768 void DeclPrinter::VisitUsingEnumDecl(UsingEnumDecl *D) {
1769   Out << "using enum " << D->getEnumDecl();
1770 }
1771
1772 void
1773 DeclPrinter::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
1774   Out << "using typename ";
1775   D->getQualifier()->print(Out, Policy);
1776   Out << D->getDeclName();
1777 }
1778
1779 void DeclPrinter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
1780   if (!D->isAccessDeclaration())
1781     Out << "using ";
1782   D->getQualifier()->print(Out, Policy);
1783   Out << D->getDeclName();
1784 }
1785
1786 void DeclPrinter::VisitUsingShadowDecl(UsingShadowDecl *D) {
1787   // ignore
1788 }
1789
1790 void DeclPrinter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
1791   Out << "#pragma omp threadprivate";
1792   if (!D->varlist_empty()) {
1793     for (OMPThreadPrivateDecl::varlist_iterator I = D->varlist_begin(),
1794                                                 E = D->varlist_end();
1795                                                 I != E; ++I) {
1796       Out << (I == D->varlist_begin() ? '(' : ',');
1797       NamedDecl *ND = cast<DeclRefExpr>(*I)->getDecl();
1798       ND->printQualifiedName(Out);
1799     }
1800     Out << ")";
1801   }
1802 }
1803
1804 void DeclPrinter::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
1805   if (D->isCBuffer())
1806     Out << "cbuffer ";
1807   else
1808     Out << "tbuffer ";
1809
1810   Out << *D;
1811
1812   prettyPrintAttributes(D);
1813
1814   Out << " {\n";
1815   VisitDeclContext(D);
1816   Indent() << "}";
1817 }
1818
1819 void DeclPrinter::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
1820   Out << "#pragma omp allocate";
1821   if (!D->varlist_empty()) {
1822     for (OMPAllocateDecl::varlist_iterator I = D->varlist_begin(),
1823                                            E = D->varlist_end();
1824          I != E; ++I) {
1825       Out << (I == D->varlist_begin() ? '(' : ',');
1826       NamedDecl *ND = cast<DeclRefExpr>(*I)->getDecl();
1827       ND->printQualifiedName(Out);
1828     }
1829     Out << ")";
1830   }
1831   if (!D->clauselist_empty()) {
1832     OMPClausePrinter Printer(Out, Policy);
1833     for (OMPClause *C : D->clauselists()) {
1834       Out << " ";
1835       Printer.Visit(C);
1836     }
1837   }
1838 }
1839
1840 void DeclPrinter::VisitOMPRequiresDecl(OMPRequiresDecl *D) {
1841   Out << "#pragma omp requires ";
1842   if (!D->clauselist_empty()) {
1843     OMPClausePrinter Printer(Out, Policy);
1844     for (auto I = D->clauselist_begin(), E = D->clauselist_end(); I != E; ++I)
1845       Printer.Visit(*I);
1846   }
1847 }
1848
1849 void DeclPrinter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
1850   if (!D->isInvalidDecl()) {
1851     Out << "#pragma omp declare reduction (";
1852     if (D->getDeclName().getNameKind() == DeclarationName::CXXOperatorName) {
1853       const char *OpName =
1854           getOperatorSpelling(D->getDeclName().getCXXOverloadedOperator());
1855       assert(OpName && "not an overloaded operator");
1856       Out << OpName;
1857     } else {
1858       assert(D->getDeclName().isIdentifier());
1859       D->printName(Out, Policy);
1860     }
1861     Out << " : ";
1862     D->getType().print(Out, Policy);
1863     Out << " : ";
1864     D->getCombiner()->printPretty(Out, nullptr, Policy, 0, "\n", &Context);
1865     Out << ")";
1866     if (auto *Init = D->getInitializer()) {
1867       Out << " initializer(";
1868       switch (D->getInitializerKind()) {
1869       case OMPDeclareReductionInitKind::Direct:
1870         Out << "omp_priv(";
1871         break;
1872       case OMPDeclareReductionInitKind::Copy:
1873         Out << "omp_priv = ";
1874         break;
1875       case OMPDeclareReductionInitKind::Call:
1876         break;
1877       }
1878       Init->printPretty(Out, nullptr, Policy, 0, "\n", &Context);
1879       if (D->getInitializerKind() == OMPDeclareReductionInitKind::Direct)
1880         Out << ")";
1881       Out << ")";
1882     }
1883   }
1884 }
1885
1886 void DeclPrinter::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
1887   if (!D->isInvalidDecl()) {
1888     Out << "#pragma omp declare mapper (";
1889     D->printName(Out, Policy);
1890     Out << " : ";
1891     D->getType().print(Out, Policy);
1892     Out << " ";
1893     Out << D->getVarName();
1894     Out << ")";
1895     if (!D->clauselist_empty()) {
1896       OMPClausePrinter Printer(Out, Policy);
1897       for (auto *C : D->clauselists()) {
1898         Out << " ";
1899         Printer.Visit(C);
1900       }
1901     }
1902   }
1903 }
1904
1905 void DeclPrinter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
1906   D->getInit()->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
1907 }
1908
1909 void DeclPrinter::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP) {
1910   if (const TypeConstraint *TC = TTP->getTypeConstraint())
1911     TC->print(Out, Policy);
1912   else if (TTP->wasDeclaredWithTypename())
1913     Out << "typename";
1914   else
1915     Out << "class";
1916
1917   if (TTP->isParameterPack())
1918     Out << " ...";
1919   else if (TTP->getDeclName())
1920     Out << ' ';
1921
1922   if (TTP->getDeclName()) {
1923     if (Policy.CleanUglifiedParameters && TTP->getIdentifier())
1924       Out << TTP->getIdentifier()->deuglifiedName();
1925     else
1926       Out << TTP->getDeclName();
1927   }
1928
1929   if (TTP->hasDefaultArgument()) {
1930     Out << " = ";
1931     Out << TTP->getDefaultArgument().getAsString(Policy);
1932   }
1933 }
1934
1935 void DeclPrinter::VisitNonTypeTemplateParmDecl(
1936     const NonTypeTemplateParmDecl *NTTP) {
1937   StringRef Name;
1938   if (IdentifierInfo *II = NTTP->getIdentifier())
1939     Name =
1940         Policy.CleanUglifiedParameters ? II->deuglifiedName() : II->getName();
1941   printDeclType(NTTP->getType(), Name, NTTP->isParameterPack());
1942
1943   if (NTTP->hasDefaultArgument()) {
1944     Out << " = ";
1945     NTTP->getDefaultArgument()->printPretty(Out, nullptr, Policy, Indentation,
1946                                             "\n", &Context);
1947   }
1948 }