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     ASTContext &Context;
     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, ASTContext &Context,
     42                 const PrintingPolicy &Policy,
     43                 unsigned Indentation = 0,
     44                 bool PrintInstantiation = false)
     45       : Out(Out), Context(Context), Policy(Policy), Indentation(Indentation),
     46         PrintInstantiation(PrintInstantiation) { }
     47 
     48     void VisitDeclContext(DeclContext *DC, bool Indent = true);
     49 
     50     void VisitTranslationUnitDecl(TranslationUnitDecl *D);
     51     void VisitTypedefDecl(TypedefDecl *D);
     52     void VisitTypeAliasDecl(TypeAliasDecl *D);
     53     void VisitEnumDecl(EnumDecl *D);
     54     void VisitRecordDecl(RecordDecl *D);
     55     void VisitEnumConstantDecl(EnumConstantDecl *D);
     56     void VisitFunctionDecl(FunctionDecl *D);
     57     void VisitFieldDecl(FieldDecl *D);
     58     void VisitVarDecl(VarDecl *D);
     59     void VisitLabelDecl(LabelDecl *D);
     60     void VisitParmVarDecl(ParmVarDecl *D);
     61     void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
     62     void VisitImportDecl(ImportDecl *D);
     63     void VisitStaticAssertDecl(StaticAssertDecl *D);
     64     void VisitNamespaceDecl(NamespaceDecl *D);
     65     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
     66     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
     67     void VisitCXXRecordDecl(CXXRecordDecl *D);
     68     void VisitLinkageSpecDecl(LinkageSpecDecl *D);
     69     void VisitTemplateDecl(const TemplateDecl *D);
     70     void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
     71     void VisitClassTemplateDecl(ClassTemplateDecl *D);
     72     void VisitObjCMethodDecl(ObjCMethodDecl *D);
     73     void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
     74     void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
     75     void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
     76     void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
     77     void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
     78     void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
     79     void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
     80     void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
     81     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
     82     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
     83     void VisitUsingDecl(UsingDecl *D);
     84     void VisitUsingShadowDecl(UsingShadowDecl *D);
     85 
     86     void PrintTemplateParameters(const TemplateParameterList *Params,
     87                                  const TemplateArgumentList *Args);
     88     void prettyPrintAttributes(Decl *D);
     89   };
     90 }
     91 
     92 void Decl::print(raw_ostream &Out, unsigned Indentation,
     93                  bool PrintInstantiation) const {
     94   print(Out, getASTContext().getPrintingPolicy(), Indentation, PrintInstantiation);
     95 }
     96 
     97 void Decl::print(raw_ostream &Out, const PrintingPolicy &Policy,
     98                  unsigned Indentation, bool PrintInstantiation) const {
     99   DeclPrinter Printer(Out, getASTContext(), Policy, Indentation, PrintInstantiation);
    100   Printer.Visit(const_cast<Decl*>(this));
    101 }
    102 
    103 static QualType GetBaseType(QualType T) {
    104   // FIXME: This should be on the Type class!
    105   QualType BaseType = T;
    106   while (!BaseType->isSpecifierType()) {
    107     if (isa<TypedefType>(BaseType))
    108       break;
    109     else if (const PointerType* PTy = BaseType->getAs<PointerType>())
    110       BaseType = PTy->getPointeeType();
    111     else if (const ArrayType* ATy = dyn_cast<ArrayType>(BaseType))
    112       BaseType = ATy->getElementType();
    113     else if (const FunctionType* FTy = BaseType->getAs<FunctionType>())
    114       BaseType = FTy->getResultType();
    115     else if (const VectorType *VTy = BaseType->getAs<VectorType>())
    116       BaseType = VTy->getElementType();
    117     else
    118       llvm_unreachable("Unknown declarator!");
    119   }
    120   return BaseType;
    121 }
    122 
    123 static QualType getDeclType(Decl* D) {
    124   if (TypedefNameDecl* TDD = dyn_cast<TypedefNameDecl>(D))
    125     return TDD->getUnderlyingType();
    126   if (ValueDecl* VD = dyn_cast<ValueDecl>(D))
    127     return VD->getType();
    128   return QualType();
    129 }
    130 
    131 void Decl::printGroup(Decl** Begin, unsigned NumDecls,
    132                       raw_ostream &Out, const PrintingPolicy &Policy,
    133                       unsigned Indentation) {
    134   if (NumDecls == 1) {
    135     (*Begin)->print(Out, Policy, Indentation);
    136     return;
    137   }
    138 
    139   Decl** End = Begin + NumDecls;
    140   TagDecl* TD = dyn_cast<TagDecl>(*Begin);
    141   if (TD)
    142     ++Begin;
    143 
    144   PrintingPolicy SubPolicy(Policy);
    145   if (TD && TD->isCompleteDefinition()) {
    146     TD->print(Out, Policy, Indentation);
    147     Out << " ";
    148     SubPolicy.SuppressTag = true;
    149   }
    150 
    151   bool isFirst = true;
    152   for ( ; Begin != End; ++Begin) {
    153     if (isFirst) {
    154       SubPolicy.SuppressSpecifiers = false;
    155       isFirst = false;
    156     } else {
    157       if (!isFirst) Out << ", ";
    158       SubPolicy.SuppressSpecifiers = true;
    159     }
    160 
    161     (*Begin)->print(Out, SubPolicy, Indentation);
    162   }
    163 }
    164 
    165 void DeclContext::dumpDeclContext() const {
    166   // Get the translation unit
    167   const DeclContext *DC = this;
    168   while (!DC->isTranslationUnit())
    169     DC = DC->getParent();
    170 
    171   ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
    172   DeclPrinter Printer(llvm::errs(), Ctx, Ctx.getPrintingPolicy(), 0);
    173   Printer.VisitDeclContext(const_cast<DeclContext *>(this), /*Indent=*/false);
    174 }
    175 
    176 void Decl::dump() const {
    177   print(llvm::errs());
    178 }
    179 
    180 raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
    181   for (unsigned i = 0; i != Indentation; ++i)
    182     Out << "  ";
    183   return Out;
    184 }
    185 
    186 void DeclPrinter::prettyPrintAttributes(Decl *D) {
    187   if (D->hasAttrs()) {
    188     AttrVec &Attrs = D->getAttrs();
    189     for (AttrVec::const_iterator i=Attrs.begin(), e=Attrs.end(); i!=e; ++i) {
    190         Attr *A = *i;
    191         A->printPretty(Out, Context);
    192     }
    193   }
    194 }
    195 
    196 void DeclPrinter::ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls) {
    197   this->Indent();
    198   Decl::printGroup(Decls.data(), Decls.size(), Out, Policy, Indentation);
    199   Out << ";\n";
    200   Decls.clear();
    201 
    202 }
    203 
    204 void DeclPrinter::Print(AccessSpecifier AS) {
    205   switch(AS) {
    206   case AS_none:      llvm_unreachable("No access specifier!");
    207   case AS_public:    Out << "public"; break;
    208   case AS_protected: Out << "protected"; break;
    209   case AS_private:   Out << "private"; break;
    210   }
    211 }
    212 
    213 //----------------------------------------------------------------------------
    214 // Common C declarations
    215 //----------------------------------------------------------------------------
    216 
    217 void DeclPrinter::VisitDeclContext(DeclContext *DC, bool Indent) {
    218   if (Indent)
    219     Indentation += Policy.Indentation;
    220 
    221   SmallVector<Decl*, 2> Decls;
    222   for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end();
    223        D != DEnd; ++D) {
    224 
    225     // Don't print ObjCIvarDecls, as they are printed when visiting the
    226     // containing ObjCInterfaceDecl.
    227     if (isa<ObjCIvarDecl>(*D))
    228       continue;
    229 
    230     if (!Policy.Dump) {
    231       // Skip over implicit declarations in pretty-printing mode.
    232       if (D->isImplicit()) continue;
    233       // FIXME: Ugly hack so we don't pretty-print the builtin declaration
    234       // of __builtin_va_list or __[u]int128_t.  There should be some other way
    235       // to check that.
    236       if (NamedDecl *ND = dyn_cast<NamedDecl>(*D)) {
    237         if (IdentifierInfo *II = ND->getIdentifier()) {
    238           if (II->isStr("__builtin_va_list") ||
    239               II->isStr("__int128_t") || II->isStr("__uint128_t"))
    240             continue;
    241         }
    242       }
    243     }
    244 
    245     // The next bits of code handles stuff like "struct {int x;} a,b"; we're
    246     // forced to merge the declarations because there's no other way to
    247     // refer to the struct in question.  This limited merging is safe without
    248     // a bunch of other checks because it only merges declarations directly
    249     // referring to the tag, not typedefs.
    250     //
    251     // Check whether the current declaration should be grouped with a previous
    252     // unnamed struct.
    253     QualType CurDeclType = getDeclType(*D);
    254     if (!Decls.empty() && !CurDeclType.isNull()) {
    255       QualType BaseType = GetBaseType(CurDeclType);
    256       if (!BaseType.isNull() && isa<TagType>(BaseType) &&
    257           cast<TagType>(BaseType)->getDecl() == Decls[0]) {
    258         Decls.push_back(*D);
    259         continue;
    260       }
    261     }
    262 
    263     // If we have a merged group waiting to be handled, handle it now.
    264     if (!Decls.empty())
    265       ProcessDeclGroup(Decls);
    266 
    267     // If the current declaration is an unnamed tag type, save it
    268     // so we can merge it with the subsequent declaration(s) using it.
    269     if (isa<TagDecl>(*D) && !cast<TagDecl>(*D)->getIdentifier()) {
    270       Decls.push_back(*D);
    271       continue;
    272     }
    273 
    274     if (isa<AccessSpecDecl>(*D)) {
    275       Indentation -= Policy.Indentation;
    276       this->Indent();
    277       Print(D->getAccess());
    278       Out << ":\n";
    279       Indentation += Policy.Indentation;
    280       continue;
    281     }
    282 
    283     this->Indent();
    284     Visit(*D);
    285 
    286     // FIXME: Need to be able to tell the DeclPrinter when
    287     const char *Terminator = 0;
    288     if (isa<FunctionDecl>(*D) &&
    289         cast<FunctionDecl>(*D)->isThisDeclarationADefinition())
    290       Terminator = 0;
    291     else if (isa<ObjCMethodDecl>(*D) && cast<ObjCMethodDecl>(*D)->getBody())
    292       Terminator = 0;
    293     else if (isa<NamespaceDecl>(*D) || isa<LinkageSpecDecl>(*D) ||
    294              isa<ObjCImplementationDecl>(*D) ||
    295              isa<ObjCInterfaceDecl>(*D) ||
    296              isa<ObjCProtocolDecl>(*D) ||
    297              isa<ObjCCategoryImplDecl>(*D) ||
    298              isa<ObjCCategoryDecl>(*D))
    299       Terminator = 0;
    300     else if (isa<EnumConstantDecl>(*D)) {
    301       DeclContext::decl_iterator Next = D;
    302       ++Next;
    303       if (Next != DEnd)
    304         Terminator = ",";
    305     } else
    306       Terminator = ";";
    307 
    308     if (Terminator)
    309       Out << Terminator;
    310     Out << "\n";
    311   }
    312 
    313   if (!Decls.empty())
    314     ProcessDeclGroup(Decls);
    315 
    316   if (Indent)
    317     Indentation -= Policy.Indentation;
    318 }
    319 
    320 void DeclPrinter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
    321   VisitDeclContext(D, false);
    322 }
    323 
    324 void DeclPrinter::VisitTypedefDecl(TypedefDecl *D) {
    325   std::string S = D->getNameAsString();
    326   D->getUnderlyingType().getAsStringInternal(S, Policy);
    327   if (!Policy.SuppressSpecifiers) {
    328     Out << "typedef ";
    329 
    330     if (D->isModulePrivate())
    331       Out << "__module_private__ ";
    332   }
    333   Out << S;
    334   prettyPrintAttributes(D);
    335 }
    336 
    337 void DeclPrinter::VisitTypeAliasDecl(TypeAliasDecl *D) {
    338   Out << "using " << *D << " = " << D->getUnderlyingType().getAsString(Policy);
    339 }
    340 
    341 void DeclPrinter::VisitEnumDecl(EnumDecl *D) {
    342   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
    343     Out << "__module_private__ ";
    344   Out << "enum ";
    345   if (D->isScoped()) {
    346     if (D->isScopedUsingClassTag())
    347       Out << "class ";
    348     else
    349       Out << "struct ";
    350   }
    351   Out << *D;
    352 
    353   if (D->isFixed()) {
    354     std::string Underlying;
    355     D->getIntegerType().getAsStringInternal(Underlying, Policy);
    356     Out << " : " << Underlying;
    357   }
    358 
    359   if (D->isCompleteDefinition()) {
    360     Out << " {\n";
    361     VisitDeclContext(D);
    362     Indent() << "}";
    363   }
    364   prettyPrintAttributes(D);
    365 }
    366 
    367 void DeclPrinter::VisitRecordDecl(RecordDecl *D) {
    368   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
    369     Out << "__module_private__ ";
    370   Out << D->getKindName();
    371   if (D->getIdentifier())
    372     Out << ' ' << *D;
    373 
    374   if (D->isCompleteDefinition()) {
    375     Out << " {\n";
    376     VisitDeclContext(D);
    377     Indent() << "}";
    378   }
    379 }
    380 
    381 void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) {
    382   Out << *D;
    383   if (Expr *Init = D->getInitExpr()) {
    384     Out << " = ";
    385     Init->printPretty(Out, Context, 0, Policy, Indentation);
    386   }
    387 }
    388 
    389 void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
    390   if (!Policy.SuppressSpecifiers) {
    391     switch (D->getStorageClassAsWritten()) {
    392     case SC_None: break;
    393     case SC_Extern: Out << "extern "; break;
    394     case SC_Static: Out << "static "; break;
    395     case SC_PrivateExtern: Out << "__private_extern__ "; break;
    396     case SC_Auto: case SC_Register: case SC_OpenCLWorkGroupLocal:
    397       llvm_unreachable("invalid for functions");
    398     }
    399 
    400     if (D->isInlineSpecified())  Out << "inline ";
    401     if (D->isVirtualAsWritten()) Out << "virtual ";
    402     if (D->isModulePrivate())    Out << "__module_private__ ";
    403   }
    404 
    405   PrintingPolicy SubPolicy(Policy);
    406   SubPolicy.SuppressSpecifiers = false;
    407   std::string Proto = D->getNameInfo().getAsString();
    408 
    409   QualType Ty = D->getType();
    410   while (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
    411     Proto = '(' + Proto + ')';
    412     Ty = PT->getInnerType();
    413   }
    414 
    415   if (isa<FunctionType>(Ty)) {
    416     const FunctionType *AFT = Ty->getAs<FunctionType>();
    417     const FunctionProtoType *FT = 0;
    418     if (D->hasWrittenPrototype())
    419       FT = dyn_cast<FunctionProtoType>(AFT);
    420 
    421     Proto += "(";
    422     if (FT) {
    423       llvm::raw_string_ostream POut(Proto);
    424       DeclPrinter ParamPrinter(POut, Context, SubPolicy, Indentation);
    425       for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
    426         if (i) POut << ", ";
    427         ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
    428       }
    429 
    430       if (FT->isVariadic()) {
    431         if (D->getNumParams()) POut << ", ";
    432         POut << "...";
    433       }
    434     } else if (D->doesThisDeclarationHaveABody() && !D->hasPrototype()) {
    435       for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
    436         if (i)
    437           Proto += ", ";
    438         Proto += D->getParamDecl(i)->getNameAsString();
    439       }
    440     }
    441 
    442     Proto += ")";
    443 
    444     if (FT && FT->getTypeQuals()) {
    445       unsigned TypeQuals = FT->getTypeQuals();
    446       if (TypeQuals & Qualifiers::Const)
    447         Proto += " const";
    448       if (TypeQuals & Qualifiers::Volatile)
    449         Proto += " volatile";
    450       if (TypeQuals & Qualifiers::Restrict)
    451         Proto += " restrict";
    452     }
    453 
    454     if (FT && FT->hasDynamicExceptionSpec()) {
    455       Proto += " throw(";
    456       if (FT->getExceptionSpecType() == EST_MSAny)
    457         Proto += "...";
    458       else
    459         for (unsigned I = 0, N = FT->getNumExceptions(); I != N; ++I) {
    460           if (I)
    461             Proto += ", ";
    462 
    463           std::string ExceptionType;
    464           FT->getExceptionType(I).getAsStringInternal(ExceptionType, SubPolicy);
    465           Proto += ExceptionType;
    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, Context, 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, Context, 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, Context, 0, Policy, Indentation);
    538             }
    539           }
    540         }
    541         Out << ")";
    542       }
    543     }
    544     else
    545       AFT->getResultType().getAsStringInternal(Proto, Policy);
    546   } else {
    547     Ty.getAsStringInternal(Proto, Policy);
    548   }
    549 
    550   Out << Proto;
    551   prettyPrintAttributes(D);
    552 
    553   if (D->isPure())
    554     Out << " = 0";
    555   else if (D->isDeletedAsWritten())
    556     Out << " = delete";
    557   else if (D->doesThisDeclarationHaveABody()) {
    558     if (!D->hasPrototype() && D->getNumParams()) {
    559       // This is a K&R function definition, so we need to print the
    560       // parameters.
    561       Out << '\n';
    562       DeclPrinter ParamPrinter(Out, Context, SubPolicy, Indentation);
    563       Indentation += Policy.Indentation;
    564       for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
    565         Indent();
    566         ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
    567         Out << ";\n";
    568       }
    569       Indentation -= Policy.Indentation;
    570     } else
    571       Out << ' ';
    572 
    573     D->getBody()->printPretty(Out, Context, 0, SubPolicy, Indentation);
    574     Out << '\n';
    575   }
    576 }
    577 
    578 void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
    579   if (!Policy.SuppressSpecifiers && D->isMutable())
    580     Out << "mutable ";
    581   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
    582     Out << "__module_private__ ";
    583 
    584   std::string Name = D->getNameAsString();
    585   D->getType().getAsStringInternal(Name, Policy);
    586   Out << Name;
    587 
    588   if (D->isBitField()) {
    589     Out << " : ";
    590     D->getBitWidth()->printPretty(Out, Context, 0, Policy, Indentation);
    591   }
    592 
    593   Expr *Init = D->getInClassInitializer();
    594   if (!Policy.SuppressInitializers && Init) {
    595     Out << " = ";
    596     Init->printPretty(Out, Context, 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   std::string Name = D->getNameAsString();
    617   QualType T = D->getType();
    618   if (ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D))
    619     T = Parm->getOriginalType();
    620   T.getAsStringInternal(Name, Policy);
    621   Out << Name;
    622   Expr *Init = D->getInit();
    623   if (!Policy.SuppressInitializers && Init) {
    624     bool ImplicitInit = false;
    625     if (CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init))
    626       ImplicitInit = D->getInitStyle() == VarDecl::CallInit &&
    627           Construct->getNumArgs() == 0 && !Construct->isListInitialization();
    628     if (!ImplicitInit) {
    629       if (D->getInitStyle() == VarDecl::CallInit)
    630         Out << "(";
    631       else if (D->getInitStyle() == VarDecl::CInit) {
    632         Out << " = ";
    633       }
    634       Init->printPretty(Out, Context, 0, Policy, Indentation);
    635       if (D->getInitStyle() == VarDecl::CallInit)
    636         Out << ")";
    637     }
    638   }
    639   prettyPrintAttributes(D);
    640 }
    641 
    642 void DeclPrinter::VisitParmVarDecl(ParmVarDecl *D) {
    643   VisitVarDecl(D);
    644 }
    645 
    646 void DeclPrinter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
    647   Out << "__asm (";
    648   D->getAsmString()->printPretty(Out, Context, 0, Policy, Indentation);
    649   Out << ")";
    650 }
    651 
    652 void DeclPrinter::VisitImportDecl(ImportDecl *D) {
    653   Out << "@__experimental_modules_import " << D->getImportedModule()->getFullModuleName()
    654       << ";\n";
    655 }
    656 
    657 void DeclPrinter::VisitStaticAssertDecl(StaticAssertDecl *D) {
    658   Out << "static_assert(";
    659   D->getAssertExpr()->printPretty(Out, Context, 0, Policy, Indentation);
    660   Out << ", ";
    661   D->getMessage()->printPretty(Out, Context, 0, Policy, Indentation);
    662   Out << ")";
    663 }
    664 
    665 //----------------------------------------------------------------------------
    666 // C++ declarations
    667 //----------------------------------------------------------------------------
    668 void DeclPrinter::VisitNamespaceDecl(NamespaceDecl *D) {
    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, Context, 0, Policy,
    794                                                 Indentation);
    795       }
    796     } else if (const TemplateTemplateParmDecl *TTPD =
    797                  dyn_cast<TemplateTemplateParmDecl>(Param)) {
    798       VisitTemplateDecl(TTPD);
    799       // FIXME: print the default argument, if present.
    800     }
    801   }
    802 
    803   Out << "> ";
    804 }
    805 
    806 void DeclPrinter::VisitTemplateDecl(const TemplateDecl *D) {
    807   PrintTemplateParameters(D->getTemplateParameters());
    808 
    809   if (const TemplateTemplateParmDecl *TTP =
    810         dyn_cast<TemplateTemplateParmDecl>(D)) {
    811     Out << "class ";
    812     if (TTP->isParameterPack())
    813       Out << "...";
    814     Out << D->getName();
    815   } else {
    816     Visit(D->getTemplatedDecl());
    817   }
    818 }
    819 
    820 void DeclPrinter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
    821   if (PrintInstantiation) {
    822     TemplateParameterList *Params = D->getTemplateParameters();
    823     for (FunctionTemplateDecl::spec_iterator I = D->spec_begin(), E = D->spec_end();
    824          I != E; ++I) {
    825       PrintTemplateParameters(Params, (*I)->getTemplateSpecializationArgs());
    826       Visit(*I);
    827     }
    828   }
    829 
    830   return VisitRedeclarableTemplateDecl(D);
    831 }
    832 
    833 void DeclPrinter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
    834   if (PrintInstantiation) {
    835     TemplateParameterList *Params = D->getTemplateParameters();
    836     for (ClassTemplateDecl::spec_iterator I = D->spec_begin(), E = D->spec_end();
    837          I != E; ++I) {
    838       PrintTemplateParameters(Params, &(*I)->getTemplateArgs());
    839       Visit(*I);
    840       Out << '\n';
    841     }
    842   }
    843 
    844   return VisitRedeclarableTemplateDecl(D);
    845 }
    846 
    847 //----------------------------------------------------------------------------
    848 // Objective-C declarations
    849 //----------------------------------------------------------------------------
    850 
    851 void DeclPrinter::VisitObjCMethodDecl(ObjCMethodDecl *OMD) {
    852   if (OMD->isInstanceMethod())
    853     Out << "- ";
    854   else
    855     Out << "+ ";
    856   if (!OMD->getResultType().isNull())
    857     Out << '(' << OMD->getResultType().getAsString(Policy) << ")";
    858 
    859   std::string name = OMD->getSelector().getAsString();
    860   std::string::size_type pos, lastPos = 0;
    861   for (ObjCMethodDecl::param_iterator PI = OMD->param_begin(),
    862        E = OMD->param_end(); PI != E; ++PI) {
    863     // FIXME: selector is missing here!
    864     pos = name.find_first_of(':', lastPos);
    865     Out << " " << name.substr(lastPos, pos - lastPos);
    866     Out << ":(" << (*PI)->getType().getAsString(Policy) << ')' << **PI;
    867     lastPos = pos + 1;
    868   }
    869 
    870   if (OMD->param_begin() == OMD->param_end())
    871     Out << " " << name;
    872 
    873   if (OMD->isVariadic())
    874       Out << ", ...";
    875 
    876   if (OMD->getBody()) {
    877     Out << ' ';
    878     OMD->getBody()->printPretty(Out, Context, 0, Policy);
    879     Out << '\n';
    880   }
    881 }
    882 
    883 void DeclPrinter::VisitObjCImplementationDecl(ObjCImplementationDecl *OID) {
    884   std::string I = OID->getNameAsString();
    885   ObjCInterfaceDecl *SID = OID->getSuperClass();
    886 
    887   if (SID)
    888     Out << "@implementation " << I << " : " << *SID;
    889   else
    890     Out << "@implementation " << I;
    891   Out << "\n";
    892   VisitDeclContext(OID, false);
    893   Out << "@end";
    894 }
    895 
    896 void DeclPrinter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *OID) {
    897   std::string I = OID->getNameAsString();
    898   ObjCInterfaceDecl *SID = OID->getSuperClass();
    899 
    900   if (!OID->isThisDeclarationADefinition()) {
    901     Out << "@class " << I << ";";
    902     return;
    903   }
    904 
    905   if (SID)
    906     Out << "@interface " << I << " : " << *SID;
    907   else
    908     Out << "@interface " << I;
    909 
    910   // Protocols?
    911   const ObjCList<ObjCProtocolDecl> &Protocols = OID->getReferencedProtocols();
    912   if (!Protocols.empty()) {
    913     for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
    914          E = Protocols.end(); I != E; ++I)
    915       Out << (I == Protocols.begin() ? '<' : ',') << **I;
    916   }
    917 
    918   if (!Protocols.empty())
    919     Out << "> ";
    920 
    921   if (OID->ivar_size() > 0) {
    922     Out << "{\n";
    923     Indentation += Policy.Indentation;
    924     for (ObjCInterfaceDecl::ivar_iterator I = OID->ivar_begin(),
    925          E = OID->ivar_end(); I != E; ++I) {
    926       Indent() << (*I)->getType().getAsString(Policy) << ' ' << **I << ";\n";
    927     }
    928     Indentation -= Policy.Indentation;
    929     Out << "}\n";
    930   }
    931 
    932   VisitDeclContext(OID, false);
    933   Out << "@end";
    934   // FIXME: implement the rest...
    935 }
    936 
    937 void DeclPrinter::VisitObjCProtocolDecl(ObjCProtocolDecl *PID) {
    938   if (!PID->isThisDeclarationADefinition()) {
    939     Out << "@protocol " << PID->getIdentifier() << ";\n";
    940     return;
    941   }
    942 
    943   Out << "@protocol " << *PID << '\n';
    944   VisitDeclContext(PID, false);
    945   Out << "@end";
    946 }
    947 
    948 void DeclPrinter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *PID) {
    949   Out << "@implementation " << *PID->getClassInterface() << '(' << *PID <<")\n";
    950 
    951   VisitDeclContext(PID, false);
    952   Out << "@end";
    953   // FIXME: implement the rest...
    954 }
    955 
    956 void DeclPrinter::VisitObjCCategoryDecl(ObjCCategoryDecl *PID) {
    957   Out << "@interface " << *PID->getClassInterface() << '(' << *PID << ")\n";
    958   VisitDeclContext(PID, false);
    959   Out << "@end";
    960 
    961   // FIXME: implement the rest...
    962 }
    963 
    964 void DeclPrinter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *AID) {
    965   Out << "@compatibility_alias " << *AID
    966       << ' ' << *AID->getClassInterface() << ";\n";
    967 }
    968 
    969 /// PrintObjCPropertyDecl - print a property declaration.
    970 ///
    971 void DeclPrinter::VisitObjCPropertyDecl(ObjCPropertyDecl *PDecl) {
    972   if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Required)
    973     Out << "@required\n";
    974   else if (PDecl->getPropertyImplementation() == ObjCPropertyDecl::Optional)
    975     Out << "@optional\n";
    976 
    977   Out << "@property";
    978   if (PDecl->getPropertyAttributes() != ObjCPropertyDecl::OBJC_PR_noattr) {
    979     bool first = true;
    980     Out << " (";
    981     if (PDecl->getPropertyAttributes() &
    982         ObjCPropertyDecl::OBJC_PR_readonly) {
    983       Out << (first ? ' ' : ',') << "readonly";
    984       first = false;
    985     }
    986 
    987     if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
    988       Out << (first ? ' ' : ',') << "getter = "
    989           << PDecl->getGetterName().getAsString();
    990       first = false;
    991     }
    992     if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
    993       Out << (first ? ' ' : ',') << "setter = "
    994           << PDecl->getSetterName().getAsString();
    995       first = false;
    996     }
    997 
    998     if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_assign) {
    999       Out << (first ? ' ' : ',') << "assign";
   1000       first = false;
   1001     }
   1002 
   1003     if (PDecl->getPropertyAttributes() &
   1004         ObjCPropertyDecl::OBJC_PR_readwrite) {
   1005       Out << (first ? ' ' : ',') << "readwrite";
   1006       first = false;
   1007     }
   1008 
   1009     if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_retain) {
   1010       Out << (first ? ' ' : ',') << "retain";
   1011       first = false;
   1012     }
   1013 
   1014     if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_strong) {
   1015       Out << (first ? ' ' : ',') << "strong";
   1016       first = false;
   1017     }
   1018 
   1019     if (PDecl->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_copy) {
   1020       Out << (first ? ' ' : ',') << "copy";
   1021       first = false;
   1022     }
   1023 
   1024     if (PDecl->getPropertyAttributes() &
   1025         ObjCPropertyDecl::OBJC_PR_nonatomic) {
   1026       Out << (first ? ' ' : ',') << "nonatomic";
   1027       first = false;
   1028     }
   1029     if (PDecl->getPropertyAttributes() &
   1030         ObjCPropertyDecl::OBJC_PR_atomic) {
   1031       Out << (first ? ' ' : ',') << "atomic";
   1032       first = false;
   1033     }
   1034 
   1035     (void) first; // Silence dead store warning due to idiomatic code.
   1036     Out << " )";
   1037   }
   1038   Out << ' ' << PDecl->getType().getAsString(Policy) << ' ' << *PDecl;
   1039 }
   1040 
   1041 void DeclPrinter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PID) {
   1042   if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
   1043     Out << "@synthesize ";
   1044   else
   1045     Out << "@dynamic ";
   1046   Out << *PID->getPropertyDecl();
   1047   if (PID->getPropertyIvarDecl())
   1048     Out << '=' << *PID->getPropertyIvarDecl();
   1049 }
   1050 
   1051 void DeclPrinter::VisitUsingDecl(UsingDecl *D) {
   1052   Out << "using ";
   1053   D->getQualifier()->print(Out, Policy);
   1054   Out << *D;
   1055 }
   1056 
   1057 void
   1058 DeclPrinter::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
   1059   Out << "using typename ";
   1060   D->getQualifier()->print(Out, Policy);
   1061   Out << D->getDeclName();
   1062 }
   1063 
   1064 void DeclPrinter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
   1065   Out << "using ";
   1066   D->getQualifier()->print(Out, Policy);
   1067   Out << D->getDeclName();
   1068 }
   1069 
   1070 void DeclPrinter::VisitUsingShadowDecl(UsingShadowDecl *D) {
   1071   // ignore
   1072 }
   1073