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