DeclPrinter.cpp revision 8920eb7a957f3b0bc4a8213ecdaec9a7fcd139ea
1//===--- DeclPrinter.cpp - Printing implementation for Decl ASTs ----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Decl::dump method, which pretty print the 11// AST back out to C/Objective-C/C++/Objective-C++ code. 12// 13//===----------------------------------------------------------------------===// 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/Attr.h" 16#include "clang/AST/Decl.h" 17#include "clang/AST/DeclCXX.h" 18#include "clang/AST/DeclObjC.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" 25using namespace clang; 26 27namespace { 28 class DeclPrinter : public DeclVisitor<DeclPrinter> { 29 raw_ostream &Out; 30 PrintingPolicy Policy; 31 unsigned Indentation; 32 bool PrintInstantiation; 33 34 raw_ostream& Indent() { return Indent(Indentation); } 35 raw_ostream& Indent(unsigned Indentation); 36 void ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls); 37 38 void Print(AccessSpecifier AS); 39 40 public: 41 DeclPrinter(raw_ostream &Out, const PrintingPolicy &Policy, 42 unsigned Indentation = 0, bool PrintInstantiation = false) 43 : Out(Out), Policy(Policy), Indentation(Indentation), 44 PrintInstantiation(PrintInstantiation) { } 45 46 void VisitDeclContext(DeclContext *DC, bool Indent = true); 47 48 void VisitTranslationUnitDecl(TranslationUnitDecl *D); 49 void VisitTypedefDecl(TypedefDecl *D); 50 void VisitTypeAliasDecl(TypeAliasDecl *D); 51 void VisitEnumDecl(EnumDecl *D); 52 void VisitRecordDecl(RecordDecl *D); 53 void VisitEnumConstantDecl(EnumConstantDecl *D); 54 void VisitFunctionDecl(FunctionDecl *D); 55 void VisitFriendDecl(FriendDecl *D); 56 void VisitFieldDecl(FieldDecl *D); 57 void VisitVarDecl(VarDecl *D); 58 void VisitLabelDecl(LabelDecl *D); 59 void VisitParmVarDecl(ParmVarDecl *D); 60 void VisitFileScopeAsmDecl(FileScopeAsmDecl *D); 61 void VisitImportDecl(ImportDecl *D); 62 void VisitStaticAssertDecl(StaticAssertDecl *D); 63 void VisitNamespaceDecl(NamespaceDecl *D); 64 void VisitUsingDirectiveDecl(UsingDirectiveDecl *D); 65 void VisitNamespaceAliasDecl(NamespaceAliasDecl *D); 66 void VisitCXXRecordDecl(CXXRecordDecl *D); 67 void VisitLinkageSpecDecl(LinkageSpecDecl *D); 68 void VisitTemplateDecl(const TemplateDecl *D); 69 void VisitFunctionTemplateDecl(FunctionTemplateDecl *D); 70 void VisitClassTemplateDecl(ClassTemplateDecl *D); 71 void VisitObjCMethodDecl(ObjCMethodDecl *D); 72 void VisitObjCImplementationDecl(ObjCImplementationDecl *D); 73 void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D); 74 void VisitObjCProtocolDecl(ObjCProtocolDecl *D); 75 void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D); 76 void VisitObjCCategoryDecl(ObjCCategoryDecl *D); 77 void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D); 78 void VisitObjCPropertyDecl(ObjCPropertyDecl *D); 79 void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); 80 void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D); 81 void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D); 82 void VisitUsingDecl(UsingDecl *D); 83 void VisitUsingShadowDecl(UsingShadowDecl *D); 84 85 void PrintTemplateParameters(const TemplateParameterList *Params, 86 const TemplateArgumentList *Args); 87 void prettyPrintAttributes(Decl *D); 88 }; 89} 90 91void Decl::print(raw_ostream &Out, unsigned Indentation, 92 bool PrintInstantiation) const { 93 print(Out, getASTContext().getPrintingPolicy(), Indentation, PrintInstantiation); 94} 95 96void Decl::print(raw_ostream &Out, const PrintingPolicy &Policy, 97 unsigned Indentation, bool PrintInstantiation) const { 98 DeclPrinter Printer(Out, Policy, Indentation, PrintInstantiation); 99 Printer.Visit(const_cast<Decl*>(this)); 100} 101 102static QualType GetBaseType(QualType T) { 103 // FIXME: This should be on the Type class! 104 QualType BaseType = T; 105 while (!BaseType->isSpecifierType()) { 106 if (isa<TypedefType>(BaseType)) 107 break; 108 else if (const PointerType* PTy = BaseType->getAs<PointerType>()) 109 BaseType = PTy->getPointeeType(); 110 else if (const BlockPointerType *BPy = BaseType->getAs<BlockPointerType>()) 111 BaseType = BPy->getPointeeType(); 112 else if (const ArrayType* ATy = dyn_cast<ArrayType>(BaseType)) 113 BaseType = ATy->getElementType(); 114 else if (const FunctionType* FTy = BaseType->getAs<FunctionType>()) 115 BaseType = FTy->getResultType(); 116 else if (const VectorType *VTy = BaseType->getAs<VectorType>()) 117 BaseType = VTy->getElementType(); 118 else if (const ReferenceType *RTy = BaseType->getAs<ReferenceType>()) 119 BaseType = RTy->getPointeeType(); 120 else 121 llvm_unreachable("Unknown declarator!"); 122 } 123 return BaseType; 124} 125 126static QualType getDeclType(Decl* D) { 127 if (TypedefNameDecl* TDD = dyn_cast<TypedefNameDecl>(D)) 128 return TDD->getUnderlyingType(); 129 if (ValueDecl* VD = dyn_cast<ValueDecl>(D)) 130 return VD->getType(); 131 return QualType(); 132} 133 134void Decl::printGroup(Decl** Begin, unsigned NumDecls, 135 raw_ostream &Out, const PrintingPolicy &Policy, 136 unsigned Indentation) { 137 if (NumDecls == 1) { 138 (*Begin)->print(Out, Policy, Indentation); 139 return; 140 } 141 142 Decl** End = Begin + NumDecls; 143 TagDecl* TD = dyn_cast<TagDecl>(*Begin); 144 if (TD) 145 ++Begin; 146 147 PrintingPolicy SubPolicy(Policy); 148 if (TD && TD->isCompleteDefinition()) { 149 TD->print(Out, Policy, Indentation); 150 Out << " "; 151 SubPolicy.SuppressTag = true; 152 } 153 154 bool isFirst = true; 155 for ( ; Begin != End; ++Begin) { 156 if (isFirst) { 157 SubPolicy.SuppressSpecifiers = false; 158 isFirst = false; 159 } else { 160 if (!isFirst) Out << ", "; 161 SubPolicy.SuppressSpecifiers = true; 162 } 163 164 (*Begin)->print(Out, SubPolicy, Indentation); 165 } 166} 167 168void DeclContext::dumpDeclContext() const { 169 // Get the translation unit 170 const DeclContext *DC = this; 171 while (!DC->isTranslationUnit()) 172 DC = DC->getParent(); 173 174 ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext(); 175 DeclPrinter Printer(llvm::errs(), Ctx.getPrintingPolicy(), 0); 176 Printer.VisitDeclContext(const_cast<DeclContext *>(this), /*Indent=*/false); 177} 178 179void Decl::dump() const { 180 dump(llvm::errs()); 181} 182 183void Decl::dump(raw_ostream &Out) const { 184 PrintingPolicy Policy = getASTContext().getPrintingPolicy(); 185 Policy.DumpSourceManager = &getASTContext().getSourceManager(); 186 print(Out, Policy, /*Indentation*/ 0, /*PrintInstantiation*/ true); 187} 188 189raw_ostream& DeclPrinter::Indent(unsigned Indentation) { 190 for (unsigned i = 0; i != Indentation; ++i) 191 Out << " "; 192 return Out; 193} 194 195void DeclPrinter::prettyPrintAttributes(Decl *D) { 196 if (Policy.SuppressAttributes) 197 return; 198 199 if (D->hasAttrs()) { 200 AttrVec &Attrs = D->getAttrs(); 201 for (AttrVec::const_iterator i=Attrs.begin(), e=Attrs.end(); i!=e; ++i) { 202 Attr *A = *i; 203 A->printPretty(Out, Policy); 204 } 205 } 206} 207 208void DeclPrinter::ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls) { 209 this->Indent(); 210 Decl::printGroup(Decls.data(), Decls.size(), Out, Policy, Indentation); 211 Out << ";\n"; 212 Decls.clear(); 213 214} 215 216void DeclPrinter::Print(AccessSpecifier AS) { 217 switch(AS) { 218 case AS_none: llvm_unreachable("No access specifier!"); 219 case AS_public: Out << "public"; break; 220 case AS_protected: Out << "protected"; break; 221 case AS_private: Out << "private"; break; 222 } 223} 224 225//---------------------------------------------------------------------------- 226// Common C declarations 227//---------------------------------------------------------------------------- 228 229void DeclPrinter::VisitDeclContext(DeclContext *DC, bool Indent) { 230 if (Policy.TerseOutput) 231 return; 232 233 if (Indent) 234 Indentation += Policy.Indentation; 235 236 SmallVector<Decl*, 2> Decls; 237 for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end(); 238 D != DEnd; ++D) { 239 240 // Don't print ObjCIvarDecls, as they are printed when visiting the 241 // containing ObjCInterfaceDecl. 242 if (isa<ObjCIvarDecl>(*D)) 243 continue; 244 245 if (!Policy.DumpSourceManager) { 246 // Skip over implicit declarations in pretty-printing mode. 247 if (D->isImplicit()) continue; 248 // FIXME: Ugly hack so we don't pretty-print the builtin declaration 249 // of __builtin_va_list or __[u]int128_t. There should be some other way 250 // to check that. 251 if (NamedDecl *ND = dyn_cast<NamedDecl>(*D)) { 252 if (IdentifierInfo *II = ND->getIdentifier()) { 253 if (II->isStr("__builtin_va_list") || 254 II->isStr("__int128_t") || II->isStr("__uint128_t")) 255 continue; 256 } 257 } 258 } 259 260 // The next bits of code handles stuff like "struct {int x;} a,b"; we're 261 // forced to merge the declarations because there's no other way to 262 // refer to the struct in question. This limited merging is safe without 263 // a bunch of other checks because it only merges declarations directly 264 // referring to the tag, not typedefs. 265 // 266 // Check whether the current declaration should be grouped with a previous 267 // unnamed struct. 268 QualType CurDeclType = getDeclType(*D); 269 if (!Decls.empty() && !CurDeclType.isNull()) { 270 QualType BaseType = GetBaseType(CurDeclType); 271 if (!BaseType.isNull() && isa<TagType>(BaseType) && 272 cast<TagType>(BaseType)->getDecl() == Decls[0]) { 273 Decls.push_back(*D); 274 continue; 275 } 276 } 277 278 // If we have a merged group waiting to be handled, handle it now. 279 if (!Decls.empty()) 280 ProcessDeclGroup(Decls); 281 282 // If the current declaration is an unnamed tag type, save it 283 // so we can merge it with the subsequent declaration(s) using it. 284 if (isa<TagDecl>(*D) && !cast<TagDecl>(*D)->getIdentifier()) { 285 Decls.push_back(*D); 286 continue; 287 } 288 289 if (isa<AccessSpecDecl>(*D)) { 290 Indentation -= Policy.Indentation; 291 this->Indent(); 292 Print(D->getAccess()); 293 Out << ":\n"; 294 Indentation += Policy.Indentation; 295 continue; 296 } 297 298 this->Indent(); 299 Visit(*D); 300 301 // FIXME: Need to be able to tell the DeclPrinter when 302 const char *Terminator = 0; 303 if (isa<FunctionDecl>(*D) && 304 cast<FunctionDecl>(*D)->isThisDeclarationADefinition()) 305 Terminator = 0; 306 else if (isa<ObjCMethodDecl>(*D) && cast<ObjCMethodDecl>(*D)->getBody()) 307 Terminator = 0; 308 else if (isa<NamespaceDecl>(*D) || isa<LinkageSpecDecl>(*D) || 309 isa<ObjCImplementationDecl>(*D) || 310 isa<ObjCInterfaceDecl>(*D) || 311 isa<ObjCProtocolDecl>(*D) || 312 isa<ObjCCategoryImplDecl>(*D) || 313 isa<ObjCCategoryDecl>(*D)) 314 Terminator = 0; 315 else if (isa<EnumConstantDecl>(*D)) { 316 DeclContext::decl_iterator Next = D; 317 ++Next; 318 if (Next != DEnd) 319 Terminator = ","; 320 } else 321 Terminator = ";"; 322 323 if (Terminator) 324 Out << Terminator; 325 Out << "\n"; 326 } 327 328 if (!Decls.empty()) 329 ProcessDeclGroup(Decls); 330 331 if (Indent) 332 Indentation -= Policy.Indentation; 333} 334 335void DeclPrinter::VisitTranslationUnitDecl(TranslationUnitDecl *D) { 336 VisitDeclContext(D, false); 337} 338 339void DeclPrinter::VisitTypedefDecl(TypedefDecl *D) { 340 if (!Policy.SuppressSpecifiers) { 341 Out << "typedef "; 342 343 if (D->isModulePrivate()) 344 Out << "__module_private__ "; 345 } 346 D->getUnderlyingType().print(Out, Policy, D->getName()); 347 prettyPrintAttributes(D); 348} 349 350void DeclPrinter::VisitTypeAliasDecl(TypeAliasDecl *D) { 351 Out << "using " << *D << " = " << D->getUnderlyingType().getAsString(Policy); 352} 353 354void DeclPrinter::VisitEnumDecl(EnumDecl *D) { 355 if (!Policy.SuppressSpecifiers && D->isModulePrivate()) 356 Out << "__module_private__ "; 357 Out << "enum "; 358 if (D->isScoped()) { 359 if (D->isScopedUsingClassTag()) 360 Out << "class "; 361 else 362 Out << "struct "; 363 } 364 Out << *D; 365 366 if (D->isFixed()) 367 Out << " : " << D->getIntegerType().stream(Policy); 368 369 if (D->isCompleteDefinition()) { 370 Out << " {\n"; 371 VisitDeclContext(D); 372 Indent() << "}"; 373 } 374 prettyPrintAttributes(D); 375} 376 377void DeclPrinter::VisitRecordDecl(RecordDecl *D) { 378 if (!Policy.SuppressSpecifiers && D->isModulePrivate()) 379 Out << "__module_private__ "; 380 Out << D->getKindName(); 381 if (D->getIdentifier()) 382 Out << ' ' << *D; 383 384 if (D->isCompleteDefinition()) { 385 Out << " {\n"; 386 VisitDeclContext(D); 387 Indent() << "}"; 388 } 389} 390 391void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) { 392 Out << *D; 393 if (Expr *Init = D->getInitExpr()) { 394 Out << " = "; 395 Init->printPretty(Out, 0, Policy, Indentation); 396 } 397} 398 399void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) { 400 if (!Policy.SuppressSpecifiers) { 401 switch (D->getStorageClassAsWritten()) { 402 case SC_None: break; 403 case SC_Extern: Out << "extern "; break; 404 case SC_Static: Out << "static "; break; 405 case SC_PrivateExtern: Out << "__private_extern__ "; break; 406 case SC_Auto: case SC_Register: case SC_OpenCLWorkGroupLocal: 407 llvm_unreachable("invalid for functions"); 408 } 409 410 if (D->isInlineSpecified()) Out << "inline "; 411 if (D->isVirtualAsWritten()) Out << "virtual "; 412 if (D->isModulePrivate()) Out << "__module_private__ "; 413 } 414 415 PrintingPolicy SubPolicy(Policy); 416 SubPolicy.SuppressSpecifiers = false; 417 std::string Proto = D->getNameInfo().getAsString(); 418 419 QualType Ty = D->getType(); 420 while (const ParenType *PT = dyn_cast<ParenType>(Ty)) { 421 Proto = '(' + Proto + ')'; 422 Ty = PT->getInnerType(); 423 } 424 425 if (isa<FunctionType>(Ty)) { 426 const FunctionType *AFT = Ty->getAs<FunctionType>(); 427 const FunctionProtoType *FT = 0; 428 if (D->hasWrittenPrototype()) 429 FT = dyn_cast<FunctionProtoType>(AFT); 430 431 Proto += "("; 432 if (FT) { 433 llvm::raw_string_ostream POut(Proto); 434 DeclPrinter ParamPrinter(POut, SubPolicy, Indentation); 435 for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) { 436 if (i) POut << ", "; 437 ParamPrinter.VisitParmVarDecl(D->getParamDecl(i)); 438 } 439 440 if (FT->isVariadic()) { 441 if (D->getNumParams()) POut << ", "; 442 POut << "..."; 443 } 444 } else if (D->doesThisDeclarationHaveABody() && !D->hasPrototype()) { 445 for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) { 446 if (i) 447 Proto += ", "; 448 Proto += D->getParamDecl(i)->getNameAsString(); 449 } 450 } 451 452 Proto += ")"; 453 454 if (FT) { 455 if (FT->isConst()) 456 Proto += " const"; 457 if (FT->isVolatile()) 458 Proto += " volatile"; 459 if (FT->isRestrict()) 460 Proto += " restrict"; 461 } 462 463 if (FT && FT->hasDynamicExceptionSpec()) { 464 Proto += " throw("; 465 if (FT->getExceptionSpecType() == EST_MSAny) 466 Proto += "..."; 467 else 468 for (unsigned I = 0, N = FT->getNumExceptions(); I != N; ++I) { 469 if (I) 470 Proto += ", "; 471 472 Proto += FT->getExceptionType(I).getAsString(SubPolicy); 473 } 474 Proto += ")"; 475 } else if (FT && isNoexceptExceptionSpec(FT->getExceptionSpecType())) { 476 Proto += " noexcept"; 477 if (FT->getExceptionSpecType() == EST_ComputedNoexcept) { 478 Proto += "("; 479 llvm::raw_string_ostream EOut(Proto); 480 FT->getNoexceptExpr()->printPretty(EOut, 0, SubPolicy, 481 Indentation); 482 EOut.flush(); 483 Proto += EOut.str(); 484 Proto += ")"; 485 } 486 } 487 488 if (CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D)) { 489 bool HasInitializerList = false; 490 for (CXXConstructorDecl::init_const_iterator B = CDecl->init_begin(), 491 E = CDecl->init_end(); 492 B != E; ++B) { 493 CXXCtorInitializer * BMInitializer = (*B); 494 if (BMInitializer->isInClassMemberInitializer()) 495 continue; 496 497 if (!HasInitializerList) { 498 Proto += " : "; 499 Out << Proto; 500 Proto.clear(); 501 HasInitializerList = true; 502 } else 503 Out << ", "; 504 505 if (BMInitializer->isAnyMemberInitializer()) { 506 FieldDecl *FD = BMInitializer->getAnyMember(); 507 Out << *FD; 508 } else { 509 Out << QualType(BMInitializer->getBaseClass(), 0).getAsString(Policy); 510 } 511 512 Out << "("; 513 if (!BMInitializer->getInit()) { 514 // Nothing to print 515 } else { 516 Expr *Init = BMInitializer->getInit(); 517 if (ExprWithCleanups *Tmp = dyn_cast<ExprWithCleanups>(Init)) 518 Init = Tmp->getSubExpr(); 519 520 Init = Init->IgnoreParens(); 521 522 Expr *SimpleInit = 0; 523 Expr **Args = 0; 524 unsigned NumArgs = 0; 525 if (ParenListExpr *ParenList = dyn_cast<ParenListExpr>(Init)) { 526 Args = ParenList->getExprs(); 527 NumArgs = ParenList->getNumExprs(); 528 } else if (CXXConstructExpr *Construct 529 = dyn_cast<CXXConstructExpr>(Init)) { 530 Args = Construct->getArgs(); 531 NumArgs = Construct->getNumArgs(); 532 } else 533 SimpleInit = Init; 534 535 if (SimpleInit) 536 SimpleInit->printPretty(Out, 0, Policy, Indentation); 537 else { 538 for (unsigned I = 0; I != NumArgs; ++I) { 539 if (isa<CXXDefaultArgExpr>(Args[I])) 540 break; 541 542 if (I) 543 Out << ", "; 544 Args[I]->printPretty(Out, 0, Policy, Indentation); 545 } 546 } 547 } 548 Out << ")"; 549 } 550 } 551 else 552 AFT->getResultType().print(Out, Policy, Proto); 553 } else { 554 Ty.print(Out, Policy, Proto); 555 } 556 557 prettyPrintAttributes(D); 558 559 if (D->isPure()) 560 Out << " = 0"; 561 else if (D->isDeletedAsWritten()) 562 Out << " = delete"; 563 else if (D->doesThisDeclarationHaveABody() && !Policy.TerseOutput) { 564 if (!D->hasPrototype() && D->getNumParams()) { 565 // This is a K&R function definition, so we need to print the 566 // parameters. 567 Out << '\n'; 568 DeclPrinter ParamPrinter(Out, SubPolicy, Indentation); 569 Indentation += Policy.Indentation; 570 for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) { 571 Indent(); 572 ParamPrinter.VisitParmVarDecl(D->getParamDecl(i)); 573 Out << ";\n"; 574 } 575 Indentation -= Policy.Indentation; 576 } else 577 Out << ' '; 578 579 D->getBody()->printPretty(Out, 0, SubPolicy, Indentation); 580 Out << '\n'; 581 } 582} 583 584void DeclPrinter::VisitFriendDecl(FriendDecl *D) { 585 if (TypeSourceInfo *TSI = D->getFriendType()) { 586 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl()) { 587 Out << "friend "; 588 VisitCXXRecordDecl(FriendD); 589 } 590 } 591 else if (FunctionDecl *FD = 592 dyn_cast<FunctionDecl>(D->getFriendDecl())) { 593 Out << "friend "; 594 VisitFunctionDecl(FD); 595 } 596 else if (FunctionTemplateDecl *FTD = 597 dyn_cast<FunctionTemplateDecl>(D->getFriendDecl())) { 598 Out << "friend "; 599 VisitFunctionTemplateDecl(FTD); 600 } 601 else if (ClassTemplateDecl *CTD = 602 dyn_cast<ClassTemplateDecl>(D->getFriendDecl())) { 603 Out << "friend "; 604 VisitClassTemplateDecl(CTD); 605 } 606} 607 608void DeclPrinter::VisitFieldDecl(FieldDecl *D) { 609 if (!Policy.SuppressSpecifiers && D->isMutable()) 610 Out << "mutable "; 611 if (!Policy.SuppressSpecifiers && D->isModulePrivate()) 612 Out << "__module_private__ "; 613 614 Out << D->getType().stream(Policy, D->getName()); 615 616 if (D->isBitField()) { 617 Out << " : "; 618 D->getBitWidth()->printPretty(Out, 0, Policy, Indentation); 619 } 620 621 Expr *Init = D->getInClassInitializer(); 622 if (!Policy.SuppressInitializers && Init) { 623 if (D->getInClassInitStyle() == ICIS_ListInit) 624 Out << " "; 625 else 626 Out << " = "; 627 Init->printPretty(Out, 0, Policy, Indentation); 628 } 629 prettyPrintAttributes(D); 630} 631 632void DeclPrinter::VisitLabelDecl(LabelDecl *D) { 633 Out << *D << ":"; 634} 635 636 637void DeclPrinter::VisitVarDecl(VarDecl *D) { 638 StorageClass SCAsWritten = D->getStorageClassAsWritten(); 639 if (!Policy.SuppressSpecifiers && SCAsWritten != SC_None) 640 Out << VarDecl::getStorageClassSpecifierString(SCAsWritten) << " "; 641 642 if (!Policy.SuppressSpecifiers && D->isThreadSpecified()) 643 Out << "__thread "; 644 if (!Policy.SuppressSpecifiers && D->isModulePrivate()) 645 Out << "__module_private__ "; 646 647 QualType T = D->getType(); 648 if (ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) 649 T = Parm->getOriginalType(); 650 T.print(Out, Policy, D->getName()); 651 Expr *Init = D->getInit(); 652 if (!Policy.SuppressInitializers && Init) { 653 bool ImplicitInit = false; 654 if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init)) 655 ImplicitInit = D->getInitStyle() == VarDecl::CallInit && 656 Construct->getNumArgs() == 0 && !Construct->isListInitialization(); 657 if (!ImplicitInit) { 658 if ((D->getInitStyle() == VarDecl::CallInit) && !isa<ParenListExpr>(Init)) 659 Out << "("; 660 else if (D->getInitStyle() == VarDecl::CInit) { 661 Out << " = "; 662 } 663 Init->printPretty(Out, 0, Policy, Indentation); 664 if ((D->getInitStyle() == VarDecl::CallInit) && !isa<ParenListExpr>(Init)) 665 Out << ")"; 666 } 667 } 668 prettyPrintAttributes(D); 669} 670 671void DeclPrinter::VisitParmVarDecl(ParmVarDecl *D) { 672 VisitVarDecl(D); 673} 674 675void DeclPrinter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { 676 Out << "__asm ("; 677 D->getAsmString()->printPretty(Out, 0, Policy, Indentation); 678 Out << ")"; 679} 680 681void DeclPrinter::VisitImportDecl(ImportDecl *D) { 682 Out << "@__experimental_modules_import " << D->getImportedModule()->getFullModuleName() 683 << ";\n"; 684} 685 686void DeclPrinter::VisitStaticAssertDecl(StaticAssertDecl *D) { 687 Out << "static_assert("; 688 D->getAssertExpr()->printPretty(Out, 0, Policy, Indentation); 689 Out << ", "; 690 D->getMessage()->printPretty(Out, 0, Policy, Indentation); 691 Out << ")"; 692} 693 694//---------------------------------------------------------------------------- 695// C++ declarations 696//---------------------------------------------------------------------------- 697void DeclPrinter::VisitNamespaceDecl(NamespaceDecl *D) { 698 if (D->isInline()) 699 Out << "inline "; 700 Out << "namespace " << *D << " {\n"; 701 VisitDeclContext(D); 702 Indent() << "}"; 703} 704 705void DeclPrinter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) { 706 Out << "using namespace "; 707 if (D->getQualifier()) 708 D->getQualifier()->print(Out, Policy); 709 Out << *D->getNominatedNamespaceAsWritten(); 710} 711 712void DeclPrinter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) { 713 Out << "namespace " << *D << " = "; 714 if (D->getQualifier()) 715 D->getQualifier()->print(Out, Policy); 716 Out << *D->getAliasedNamespace(); 717} 718 719void DeclPrinter::VisitCXXRecordDecl(CXXRecordDecl *D) { 720 if (!Policy.SuppressSpecifiers && D->isModulePrivate()) 721 Out << "__module_private__ "; 722 Out << D->getKindName(); 723 if (D->getIdentifier()) 724 Out << ' ' << *D; 725 726 if (D->isCompleteDefinition()) { 727 // Print the base classes 728 if (D->getNumBases()) { 729 Out << " : "; 730 for (CXXRecordDecl::base_class_iterator Base = D->bases_begin(), 731 BaseEnd = D->bases_end(); Base != BaseEnd; ++Base) { 732 if (Base != D->bases_begin()) 733 Out << ", "; 734 735 if (Base->isVirtual()) 736 Out << "virtual "; 737 738 AccessSpecifier AS = Base->getAccessSpecifierAsWritten(); 739 if (AS != AS_none) 740 Print(AS); 741 Out << " " << Base->getType().getAsString(Policy); 742 743 if (Base->isPackExpansion()) 744 Out << "..."; 745 } 746 } 747 748 // Print the class definition 749 // FIXME: Doesn't print access specifiers, e.g., "public:" 750 Out << " {\n"; 751 VisitDeclContext(D); 752 Indent() << "}"; 753 } 754} 755 756void DeclPrinter::VisitLinkageSpecDecl(LinkageSpecDecl *D) { 757 const char *l; 758 if (D->getLanguage() == LinkageSpecDecl::lang_c) 759 l = "C"; 760 else { 761 assert(D->getLanguage() == LinkageSpecDecl::lang_cxx && 762 "unknown language in linkage specification"); 763 l = "C++"; 764 } 765 766 Out << "extern \"" << l << "\" "; 767 if (D->hasBraces()) { 768 Out << "{\n"; 769 VisitDeclContext(D); 770 Indent() << "}"; 771 } else 772 Visit(*D->decls_begin()); 773} 774 775void DeclPrinter::PrintTemplateParameters( 776 const TemplateParameterList *Params, const TemplateArgumentList *Args = 0) { 777 assert(Params); 778 assert(!Args || Params->size() == Args->size()); 779 780 Out << "template <"; 781 782 for (unsigned i = 0, e = Params->size(); i != e; ++i) { 783 if (i != 0) 784 Out << ", "; 785 786 const Decl *Param = Params->getParam(i); 787 if (const TemplateTypeParmDecl *TTP = 788 dyn_cast<TemplateTypeParmDecl>(Param)) { 789 790 if (TTP->wasDeclaredWithTypename()) 791 Out << "typename "; 792 else 793 Out << "class "; 794 795 if (TTP->isParameterPack()) 796 Out << "... "; 797 798 Out << *TTP; 799 800 if (Args) { 801 Out << " = "; 802 Args->get(i).print(Policy, Out); 803 } else if (TTP->hasDefaultArgument()) { 804 Out << " = "; 805 Out << TTP->getDefaultArgument().getAsString(Policy); 806 }; 807 } else if (const NonTypeTemplateParmDecl *NTTP = 808 dyn_cast<NonTypeTemplateParmDecl>(Param)) { 809 Out << NTTP->getType().getAsString(Policy); 810 811 if (NTTP->isParameterPack() && !isa<PackExpansionType>(NTTP->getType())) 812 Out << "..."; 813 814 if (IdentifierInfo *Name = NTTP->getIdentifier()) { 815 Out << ' '; 816 Out << Name->getName(); 817 } 818 819 if (Args) { 820 Out << " = "; 821 Args->get(i).print(Policy, Out); 822 } else if (NTTP->hasDefaultArgument()) { 823 Out << " = "; 824 NTTP->getDefaultArgument()->printPretty(Out, 0, Policy, Indentation); 825 } 826 } else if (const TemplateTemplateParmDecl *TTPD = 827 dyn_cast<TemplateTemplateParmDecl>(Param)) { 828 VisitTemplateDecl(TTPD); 829 // FIXME: print the default argument, if present. 830 } 831 } 832 833 Out << "> "; 834} 835 836void DeclPrinter::VisitTemplateDecl(const TemplateDecl *D) { 837 PrintTemplateParameters(D->getTemplateParameters()); 838 839 if (const TemplateTemplateParmDecl *TTP = 840 dyn_cast<TemplateTemplateParmDecl>(D)) { 841 Out << "class "; 842 if (TTP->isParameterPack()) 843 Out << "..."; 844 Out << D->getName(); 845 } else { 846 Visit(D->getTemplatedDecl()); 847 } 848} 849 850void DeclPrinter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { 851 if (PrintInstantiation) { 852 TemplateParameterList *Params = D->getTemplateParameters(); 853 for (FunctionTemplateDecl::spec_iterator I = D->spec_begin(), E = D->spec_end(); 854 I != E; ++I) { 855 PrintTemplateParameters(Params, (*I)->getTemplateSpecializationArgs()); 856 Visit(*I); 857 } 858 } 859 860 return VisitRedeclarableTemplateDecl(D); 861} 862 863void DeclPrinter::VisitClassTemplateDecl(ClassTemplateDecl *D) { 864 if (PrintInstantiation) { 865 TemplateParameterList *Params = D->getTemplateParameters(); 866 for (ClassTemplateDecl::spec_iterator I = D->spec_begin(), E = D->spec_end(); 867 I != E; ++I) { 868 PrintTemplateParameters(Params, &(*I)->getTemplateArgs()); 869 Visit(*I); 870 Out << '\n'; 871 } 872 } 873 874 return VisitRedeclarableTemplateDecl(D); 875} 876 877//---------------------------------------------------------------------------- 878// Objective-C declarations 879//---------------------------------------------------------------------------- 880 881void DeclPrinter::VisitObjCMethodDecl(ObjCMethodDecl *OMD) { 882 if (OMD->isInstanceMethod()) 883 Out << "- "; 884 else 885 Out << "+ "; 886 if (!OMD->getResultType().isNull()) 887 Out << '(' << OMD->getResultType().getAsString(Policy) << ")"; 888 889 std::string name = OMD->getSelector().getAsString(); 890 std::string::size_type pos, lastPos = 0; 891 for (ObjCMethodDecl::param_iterator PI = OMD->param_begin(), 892 E = OMD->param_end(); PI != E; ++PI) { 893 // FIXME: selector is missing here! 894 pos = name.find_first_of(':', lastPos); 895 Out << " " << name.substr(lastPos, pos - lastPos); 896 Out << ":(" << (*PI)->getType().getAsString(Policy) << ')' << **PI; 897 lastPos = pos + 1; 898 } 899 900 if (OMD->param_begin() == OMD->param_end()) 901 Out << " " << name; 902 903 if (OMD->isVariadic()) 904 Out << ", ..."; 905 906 if (OMD->getBody() && !Policy.TerseOutput) { 907 Out << ' '; 908 OMD->getBody()->printPretty(Out, 0, Policy); 909 Out << '\n'; 910 } 911} 912 913void DeclPrinter::VisitObjCImplementationDecl(ObjCImplementationDecl *OID) { 914 std::string I = OID->getNameAsString(); 915 ObjCInterfaceDecl *SID = OID->getSuperClass(); 916 917 if (SID) 918 Out << "@implementation " << I << " : " << *SID; 919 else 920 Out << "@implementation " << I; 921 922 if (OID->ivar_size() > 0) { 923 Out << "{\n"; 924 Indentation += Policy.Indentation; 925 for (ObjCImplementationDecl::ivar_iterator I = OID->ivar_begin(), 926 E = OID->ivar_end(); I != E; ++I) { 927 Indent() << I->getType().getAsString(Policy) << ' ' << **I << ";\n"; 928 } 929 Indentation -= Policy.Indentation; 930 Out << "}\n"; 931 } 932 VisitDeclContext(OID, false); 933 Out << "@end"; 934} 935 936void DeclPrinter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *OID) { 937 std::string I = OID->getNameAsString(); 938 ObjCInterfaceDecl *SID = OID->getSuperClass(); 939 940 if (!OID->isThisDeclarationADefinition()) { 941 Out << "@class " << I << ";"; 942 return; 943 } 944 945 if (SID) 946 Out << "@interface " << I << " : " << *SID; 947 else 948 Out << "@interface " << I; 949 950 // Protocols? 951 const ObjCList<ObjCProtocolDecl> &Protocols = OID->getReferencedProtocols(); 952 if (!Protocols.empty()) { 953 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 954 E = Protocols.end(); I != E; ++I) 955 Out << (I == Protocols.begin() ? '<' : ',') << **I; 956 } 957 958 if (!Protocols.empty()) 959 Out << "> "; 960 961 if (OID->ivar_size() > 0) { 962 Out << "{\n"; 963 Indentation += Policy.Indentation; 964 for (ObjCInterfaceDecl::ivar_iterator I = OID->ivar_begin(), 965 E = OID->ivar_end(); I != E; ++I) { 966 Indent() << I->getType().getAsString(Policy) << ' ' << **I << ";\n"; 967 } 968 Indentation -= Policy.Indentation; 969 Out << "}\n"; 970 } 971 972 VisitDeclContext(OID, false); 973 Out << "@end"; 974 // FIXME: implement the rest... 975} 976 977void DeclPrinter::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) { 978 if (!PID->isThisDeclarationADefinition()) { 979 Out << "@protocol " << PID->getIdentifier() << ";\n"; 980 return; 981 } 982 983 Out << "@protocol " << *PID << '\n'; 984 VisitDeclContext(PID, false); 985 Out << "@end"; 986} 987 988void DeclPrinter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *PID) { 989 Out << "@implementation " << *PID->getClassInterface() << '(' << *PID <<")\n"; 990 991 VisitDeclContext(PID, false); 992 Out << "@end"; 993 // FIXME: implement the rest... 994} 995 996void DeclPrinter::VisitObjCCategoryDecl(ObjCCategoryDecl *PID) { 997 Out << "@interface " << *PID->getClassInterface() << '(' << *PID << ")\n"; 998 if (PID->ivar_size() > 0) { 999 Out << "{\n"; 1000 Indentation += Policy.Indentation; 1001 for (ObjCCategoryDecl::ivar_iterator I = PID->ivar_begin(), 1002 E = PID->ivar_end(); I != E; ++I) { 1003 Indent() << I->getType().getAsString(Policy) << ' ' << **I << ";\n"; 1004 } 1005 Indentation -= Policy.Indentation; 1006 Out << "}\n"; 1007 } 1008 1009 VisitDeclContext(PID, false); 1010 Out << "@end"; 1011 1012 // FIXME: implement the rest... 1013} 1014 1015void DeclPrinter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *AID) { 1016 Out << "@compatibility_alias " << *AID 1017 << ' ' << *AID->getClassInterface() << ";\n"; 1018} 1019 1020/// PrintObjCPropertyDecl - print a property declaration. 1021/// 1022void DeclPrinter::VisitObjCPropertyDecl(ObjCPropertyDecl *PDecl) { 1023 if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Required) 1024 Out << "@required\n"; 1025 else if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Optional) 1026 Out << "@optional\n"; 1027 1028 Out << "@property"; 1029 if (PDecl->getPropertyAttributes() != ObjCPropertyDecl::OBJC_PR_noattr) { 1030 bool first = true; 1031 Out << " ("; 1032 if (PDecl->getPropertyAttributes() & 1033 ObjCPropertyDecl::OBJC_PR_readonly) { 1034 Out << (first ? ' ' : ',') << "readonly"; 1035 first = false; 1036 } 1037 1038 if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 1039 Out << (first ? ' ' : ',') << "getter = " 1040 << PDecl->getGetterName().getAsString(); 1041 first = false; 1042 } 1043 if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 1044 Out << (first ? ' ' : ',') << "setter = " 1045 << PDecl->getSetterName().getAsString(); 1046 first = false; 1047 } 1048 1049 if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_assign) { 1050 Out << (first ? ' ' : ',') << "assign"; 1051 first = false; 1052 } 1053 1054 if (PDecl->getPropertyAttributes() & 1055 ObjCPropertyDecl::OBJC_PR_readwrite) { 1056 Out << (first ? ' ' : ',') << "readwrite"; 1057 first = false; 1058 } 1059 1060 if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_retain) { 1061 Out << (first ? ' ' : ',') << "retain"; 1062 first = false; 1063 } 1064 1065 if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_strong) { 1066 Out << (first ? ' ' : ',') << "strong"; 1067 first = false; 1068 } 1069 1070 if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_copy) { 1071 Out << (first ? ' ' : ',') << "copy"; 1072 first = false; 1073 } 1074 1075 if (PDecl->getPropertyAttributes() & 1076 ObjCPropertyDecl::OBJC_PR_nonatomic) { 1077 Out << (first ? ' ' : ',') << "nonatomic"; 1078 first = false; 1079 } 1080 if (PDecl->getPropertyAttributes() & 1081 ObjCPropertyDecl::OBJC_PR_atomic) { 1082 Out << (first ? ' ' : ',') << "atomic"; 1083 first = false; 1084 } 1085 1086 (void) first; // Silence dead store warning due to idiomatic code. 1087 Out << " )"; 1088 } 1089 Out << ' ' << PDecl->getType().getAsString(Policy) << ' ' << *PDecl; 1090} 1091 1092void DeclPrinter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PID) { 1093 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) 1094 Out << "@synthesize "; 1095 else 1096 Out << "@dynamic "; 1097 Out << *PID->getPropertyDecl(); 1098 if (PID->getPropertyIvarDecl()) 1099 Out << '=' << *PID->getPropertyIvarDecl(); 1100} 1101 1102void DeclPrinter::VisitUsingDecl(UsingDecl *D) { 1103 Out << "using "; 1104 D->getQualifier()->print(Out, Policy); 1105 Out << *D; 1106} 1107 1108void 1109DeclPrinter::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) { 1110 Out << "using typename "; 1111 D->getQualifier()->print(Out, Policy); 1112 Out << D->getDeclName(); 1113} 1114 1115void DeclPrinter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) { 1116 Out << "using "; 1117 D->getQualifier()->print(Out, Policy); 1118 Out << D->getDeclName(); 1119} 1120 1121void DeclPrinter::VisitUsingShadowDecl(UsingShadowDecl *D) { 1122 // ignore 1123} 1124