Home | History | Annotate | Download | only in AST 
      1 //===--- TypePrinter.cpp - Pretty-Print Clang Types -----------------------===//
      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 contains code to print types from Clang's type system.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "clang/AST/Decl.h"
     15 #include "clang/AST/DeclObjC.h"
     16 #include "clang/AST/DeclTemplate.h"
     17 #include "clang/AST/Expr.h"
     18 #include "clang/AST/Type.h"
     19 #include "clang/AST/PrettyPrinter.h"
     20 #include "clang/Basic/LangOptions.h"
     21 #include "clang/Basic/SourceManager.h"
     22 #include "llvm/ADT/StringExtras.h"
     23 #include "llvm/Support/raw_ostream.h"
     24 using namespace clang;
     25 
     26 namespace {
     27   /// \brief RAII object that enables printing of the ARC __strong lifetime
     28   /// qualifier.
     29   class IncludeStrongLifetimeRAII {
     30     PrintingPolicy &Policy;
     31     bool Old;
     32 
     33   public:
     34     explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
     35       : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
     36       Policy.SuppressStrongLifetime = false;
     37     }
     38 
     39     ~IncludeStrongLifetimeRAII() {
     40       Policy.SuppressStrongLifetime = Old;
     41     }
     42   };
     43 
     44   class TypePrinter {
     45     PrintingPolicy Policy;
     46 
     47   public:
     48     explicit TypePrinter(const PrintingPolicy &Policy) : Policy(Policy) { }
     49 
     50     void print(const Type *ty, Qualifiers qs, std::string &buffer);
     51     void print(QualType T, std::string &S);
     52     void AppendScope(DeclContext *DC, std::string &S);
     53     void printTag(TagDecl *T, std::string &S);
     54 #define ABSTRACT_TYPE(CLASS, PARENT)
     55 #define TYPE(CLASS, PARENT) \
     56     void print##CLASS(const CLASS##Type *T, std::string &S);
     57 #include "clang/AST/TypeNodes.def"
     58   };
     59 }
     60 
     61 static void AppendTypeQualList(std::string &S, unsigned TypeQuals) {
     62   if (TypeQuals & Qualifiers::Const) {
     63     if (!S.empty()) S += ' ';
     64     S += "const";
     65   }
     66   if (TypeQuals & Qualifiers::Volatile) {
     67     if (!S.empty()) S += ' ';
     68     S += "volatile";
     69   }
     70   if (TypeQuals & Qualifiers::Restrict) {
     71     if (!S.empty()) S += ' ';
     72     S += "restrict";
     73   }
     74 }
     75 
     76 void TypePrinter::print(QualType t, std::string &buffer) {
     77   SplitQualType split = t.split();
     78   print(split.first, split.second, buffer);
     79 }
     80 
     81 void TypePrinter::print(const Type *T, Qualifiers Quals, std::string &buffer) {
     82   if (!T) {
     83     buffer += "NULL TYPE";
     84     return;
     85   }
     86 
     87   if (Policy.SuppressSpecifiers && T->isSpecifierType())
     88     return;
     89 
     90   // Print qualifiers as appropriate.
     91 
     92   // CanPrefixQualifiers - We prefer to print type qualifiers before the type,
     93   // so that we get "const int" instead of "int const", but we can't do this if
     94   // the type is complex.  For example if the type is "int*", we *must* print
     95   // "int * const", printing "const int *" is different.  Only do this when the
     96   // type expands to a simple string.
     97   bool CanPrefixQualifiers = false;
     98   bool NeedARCStrongQualifier = false;
     99   Type::TypeClass TC = T->getTypeClass();
    100   if (const AutoType *AT = dyn_cast<AutoType>(T))
    101     TC = AT->desugar()->getTypeClass();
    102   if (const SubstTemplateTypeParmType *Subst
    103                                       = dyn_cast<SubstTemplateTypeParmType>(T))
    104     TC = Subst->getReplacementType()->getTypeClass();
    105 
    106   switch (TC) {
    107     case Type::Builtin:
    108     case Type::Complex:
    109     case Type::UnresolvedUsing:
    110     case Type::Typedef:
    111     case Type::TypeOfExpr:
    112     case Type::TypeOf:
    113     case Type::Decltype:
    114     case Type::UnaryTransform:
    115     case Type::Record:
    116     case Type::Enum:
    117     case Type::Elaborated:
    118     case Type::TemplateTypeParm:
    119     case Type::SubstTemplateTypeParmPack:
    120     case Type::TemplateSpecialization:
    121     case Type::InjectedClassName:
    122     case Type::DependentName:
    123     case Type::DependentTemplateSpecialization:
    124     case Type::ObjCObject:
    125     case Type::ObjCInterface:
    126     case Type::Atomic:
    127       CanPrefixQualifiers = true;
    128       break;
    129 
    130     case Type::ObjCObjectPointer:
    131       CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
    132         T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType();
    133       break;
    134 
    135     case Type::ConstantArray:
    136     case Type::IncompleteArray:
    137     case Type::VariableArray:
    138     case Type::DependentSizedArray:
    139       NeedARCStrongQualifier = true;
    140       // Fall through
    141 
    142     case Type::Pointer:
    143     case Type::BlockPointer:
    144     case Type::LValueReference:
    145     case Type::RValueReference:
    146     case Type::MemberPointer:
    147     case Type::DependentSizedExtVector:
    148     case Type::Vector:
    149     case Type::ExtVector:
    150     case Type::FunctionProto:
    151     case Type::FunctionNoProto:
    152     case Type::Paren:
    153     case Type::Attributed:
    154     case Type::PackExpansion:
    155     case Type::SubstTemplateTypeParm:
    156     case Type::Auto:
    157       CanPrefixQualifiers = false;
    158       break;
    159   }
    160 
    161   if (!CanPrefixQualifiers && !Quals.empty()) {
    162     std::string qualsBuffer;
    163     if (NeedARCStrongQualifier) {
    164       IncludeStrongLifetimeRAII Strong(Policy);
    165       Quals.getAsStringInternal(qualsBuffer, Policy);
    166     } else {
    167       Quals.getAsStringInternal(qualsBuffer, Policy);
    168     }
    169 
    170     if (!qualsBuffer.empty()) {
    171       if (!buffer.empty()) {
    172         qualsBuffer += ' ';
    173         qualsBuffer += buffer;
    174       }
    175       std::swap(buffer, qualsBuffer);
    176     }
    177   }
    178 
    179   switch (T->getTypeClass()) {
    180 #define ABSTRACT_TYPE(CLASS, PARENT)
    181 #define TYPE(CLASS, PARENT) case Type::CLASS: \
    182     print##CLASS(cast<CLASS##Type>(T), buffer); \
    183     break;
    184 #include "clang/AST/TypeNodes.def"
    185   }
    186 
    187   // If we're adding the qualifiers as a prefix, do it now.
    188   if (CanPrefixQualifiers && !Quals.empty()) {
    189     std::string qualsBuffer;
    190     if (NeedARCStrongQualifier) {
    191       IncludeStrongLifetimeRAII Strong(Policy);
    192       Quals.getAsStringInternal(qualsBuffer, Policy);
    193     } else {
    194       Quals.getAsStringInternal(qualsBuffer, Policy);
    195     }
    196 
    197     if (!qualsBuffer.empty()) {
    198       if (!buffer.empty()) {
    199         qualsBuffer += ' ';
    200         qualsBuffer += buffer;
    201       }
    202       std::swap(buffer, qualsBuffer);
    203     }
    204   }
    205 }
    206 
    207 void TypePrinter::printBuiltin(const BuiltinType *T, std::string &S) {
    208   if (S.empty()) {
    209     S = T->getName(Policy);
    210   } else {
    211     // Prefix the basic type, e.g. 'int X'.
    212     S = ' ' + S;
    213     S = T->getName(Policy) + S;
    214   }
    215 }
    216 
    217 void TypePrinter::printComplex(const ComplexType *T, std::string &S) {
    218   print(T->getElementType(), S);
    219   S = "_Complex " + S;
    220 }
    221 
    222 void TypePrinter::printPointer(const PointerType *T, std::string &S) {
    223   S = '*' + S;
    224 
    225   // Handle things like 'int (*A)[4];' correctly.
    226   // FIXME: this should include vectors, but vectors use attributes I guess.
    227   if (isa<ArrayType>(T->getPointeeType()))
    228     S = '(' + S + ')';
    229 
    230   IncludeStrongLifetimeRAII Strong(Policy);
    231   print(T->getPointeeType(), S);
    232 }
    233 
    234 void TypePrinter::printBlockPointer(const BlockPointerType *T, std::string &S) {
    235   S = '^' + S;
    236   print(T->getPointeeType(), S);
    237 }
    238 
    239 void TypePrinter::printLValueReference(const LValueReferenceType *T,
    240                                        std::string &S) {
    241   S = '&' + S;
    242 
    243   // Handle things like 'int (&A)[4];' correctly.
    244   // FIXME: this should include vectors, but vectors use attributes I guess.
    245   if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
    246     S = '(' + S + ')';
    247 
    248   IncludeStrongLifetimeRAII Strong(Policy);
    249   print(T->getPointeeTypeAsWritten(), S);
    250 }
    251 
    252 void TypePrinter::printRValueReference(const RValueReferenceType *T,
    253                                        std::string &S) {
    254   S = "&&" + S;
    255 
    256   // Handle things like 'int (&&A)[4];' correctly.
    257   // FIXME: this should include vectors, but vectors use attributes I guess.
    258   if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
    259     S = '(' + S + ')';
    260 
    261   IncludeStrongLifetimeRAII Strong(Policy);
    262   print(T->getPointeeTypeAsWritten(), S);
    263 }
    264 
    265 void TypePrinter::printMemberPointer(const MemberPointerType *T,
    266                                      std::string &S) {
    267   std::string C;
    268   print(QualType(T->getClass(), 0), C);
    269   C += "::*";
    270   S = C + S;
    271 
    272   // Handle things like 'int (Cls::*A)[4];' correctly.
    273   // FIXME: this should include vectors, but vectors use attributes I guess.
    274   if (isa<ArrayType>(T->getPointeeType()))
    275     S = '(' + S + ')';
    276 
    277   IncludeStrongLifetimeRAII Strong(Policy);
    278   print(T->getPointeeType(), S);
    279 }
    280 
    281 void TypePrinter::printConstantArray(const ConstantArrayType *T,
    282                                      std::string &S) {
    283   S += '[';
    284   S += llvm::utostr(T->getSize().getZExtValue());
    285   S += ']';
    286 
    287   IncludeStrongLifetimeRAII Strong(Policy);
    288   print(T->getElementType(), S);
    289 }
    290 
    291 void TypePrinter::printIncompleteArray(const IncompleteArrayType *T,
    292                                        std::string &S) {
    293   S += "[]";
    294   IncludeStrongLifetimeRAII Strong(Policy);
    295   print(T->getElementType(), S);
    296 }
    297 
    298 void TypePrinter::printVariableArray(const VariableArrayType *T,
    299                                      std::string &S) {
    300   S += '[';
    301 
    302   if (T->getIndexTypeQualifiers().hasQualifiers()) {
    303     AppendTypeQualList(S, T->getIndexTypeCVRQualifiers());
    304     S += ' ';
    305   }
    306 
    307   if (T->getSizeModifier() == VariableArrayType::Static)
    308     S += "static";
    309   else if (T->getSizeModifier() == VariableArrayType::Star)
    310     S += '*';
    311 
    312   if (T->getSizeExpr()) {
    313     std::string SStr;
    314     llvm::raw_string_ostream s(SStr);
    315     T->getSizeExpr()->printPretty(s, 0, Policy);
    316     S += s.str();
    317   }
    318   S += ']';
    319 
    320   IncludeStrongLifetimeRAII Strong(Policy);
    321   print(T->getElementType(), S);
    322 }
    323 
    324 void TypePrinter::printDependentSizedArray(const DependentSizedArrayType *T,
    325                                            std::string &S) {
    326   S += '[';
    327 
    328   if (T->getSizeExpr()) {
    329     std::string SStr;
    330     llvm::raw_string_ostream s(SStr);
    331     T->getSizeExpr()->printPretty(s, 0, Policy);
    332     S += s.str();
    333   }
    334   S += ']';
    335 
    336   IncludeStrongLifetimeRAII Strong(Policy);
    337   print(T->getElementType(), S);
    338 }
    339 
    340 void TypePrinter::printDependentSizedExtVector(
    341                                           const DependentSizedExtVectorType *T,
    342                                                std::string &S) {
    343   print(T->getElementType(), S);
    344 
    345   S += " __attribute__((ext_vector_type(";
    346   if (T->getSizeExpr()) {
    347     std::string SStr;
    348     llvm::raw_string_ostream s(SStr);
    349     T->getSizeExpr()->printPretty(s, 0, Policy);
    350     S += s.str();
    351   }
    352   S += ")))";
    353 }
    354 
    355 void TypePrinter::printVector(const VectorType *T, std::string &S) {
    356   switch (T->getVectorKind()) {
    357   case VectorType::AltiVecPixel:
    358     S = "__vector __pixel " + S;
    359     break;
    360   case VectorType::AltiVecBool:
    361     print(T->getElementType(), S);
    362     S = "__vector __bool " + S;
    363     break;
    364   case VectorType::AltiVecVector:
    365     print(T->getElementType(), S);
    366     S = "__vector " + S;
    367     break;
    368   case VectorType::NeonVector:
    369     print(T->getElementType(), S);
    370     S = ("__attribute__((neon_vector_type(" +
    371          llvm::utostr_32(T->getNumElements()) + "))) " + S);
    372     break;
    373   case VectorType::NeonPolyVector:
    374     print(T->getElementType(), S);
    375     S = ("__attribute__((neon_polyvector_type(" +
    376          llvm::utostr_32(T->getNumElements()) + "))) " + S);
    377     break;
    378   case VectorType::GenericVector: {
    379     // FIXME: We prefer to print the size directly here, but have no way
    380     // to get the size of the type.
    381     print(T->getElementType(), S);
    382     std::string V = "__attribute__((__vector_size__(";
    383     V += llvm::utostr_32(T->getNumElements()); // convert back to bytes.
    384     std::string ET;
    385     print(T->getElementType(), ET);
    386     V += " * sizeof(" + ET + ")))) ";
    387     S = V + S;
    388     break;
    389   }
    390   }
    391 }
    392 
    393 void TypePrinter::printExtVector(const ExtVectorType *T, std::string &S) {
    394   S += " __attribute__((ext_vector_type(";
    395   S += llvm::utostr_32(T->getNumElements());
    396   S += ")))";
    397   print(T->getElementType(), S);
    398 }
    399 
    400 void TypePrinter::printFunctionProto(const FunctionProtoType *T,
    401                                      std::string &S) {
    402   // If needed for precedence reasons, wrap the inner part in grouping parens.
    403   if (!S.empty())
    404     S = "(" + S + ")";
    405 
    406   S += "(";
    407   std::string Tmp;
    408   PrintingPolicy ParamPolicy(Policy);
    409   ParamPolicy.SuppressSpecifiers = false;
    410   for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) {
    411     if (i) S += ", ";
    412     print(T->getArgType(i), Tmp);
    413     S += Tmp;
    414     Tmp.clear();
    415   }
    416 
    417   if (T->isVariadic()) {
    418     if (T->getNumArgs())
    419       S += ", ";
    420     S += "...";
    421   } else if (T->getNumArgs() == 0 && !Policy.LangOpts.CPlusPlus) {
    422     // Do not emit int() if we have a proto, emit 'int(void)'.
    423     S += "void";
    424   }
    425 
    426   S += ")";
    427 
    428   FunctionType::ExtInfo Info = T->getExtInfo();
    429   switch(Info.getCC()) {
    430   case CC_Default:
    431   default: break;
    432   case CC_C:
    433     S += " __attribute__((cdecl))";
    434     break;
    435   case CC_X86StdCall:
    436     S += " __attribute__((stdcall))";
    437     break;
    438   case CC_X86FastCall:
    439     S += " __attribute__((fastcall))";
    440     break;
    441   case CC_X86ThisCall:
    442     S += " __attribute__((thiscall))";
    443     break;
    444   case CC_X86Pascal:
    445     S += " __attribute__((pascal))";
    446     break;
    447   case CC_AAPCS:
    448     S += " __attribute__((pcs(\"aapcs\")))";
    449     break;
    450   case CC_AAPCS_VFP:
    451     S += " __attribute__((pcs(\"aapcs-vfp\")))";
    452     break;
    453   }
    454   if (Info.getNoReturn())
    455     S += " __attribute__((noreturn))";
    456   if (Info.getRegParm())
    457     S += " __attribute__((regparm (" +
    458         llvm::utostr_32(Info.getRegParm()) + ")))";
    459 
    460   AppendTypeQualList(S, T->getTypeQuals());
    461 
    462   switch (T->getRefQualifier()) {
    463   case RQ_None:
    464     break;
    465 
    466   case RQ_LValue:
    467     S += " &";
    468     break;
    469 
    470   case RQ_RValue:
    471     S += " &&";
    472     break;
    473   }
    474 
    475   if (T->hasDynamicExceptionSpec()) {
    476     S += " throw(";
    477     if (T->getExceptionSpecType() == EST_MSAny)
    478       S += "...";
    479     else
    480       for (unsigned I = 0, N = T->getNumExceptions(); I != N; ++I) {
    481         if (I)
    482           S += ", ";
    483 
    484         std::string ExceptionType;
    485         print(T->getExceptionType(I), ExceptionType);
    486         S += ExceptionType;
    487       }
    488     S += ")";
    489   } else if (isNoexceptExceptionSpec(T->getExceptionSpecType())) {
    490     S += " noexcept";
    491     if (T->getExceptionSpecType() == EST_ComputedNoexcept) {
    492       S += "(";
    493       llvm::raw_string_ostream EOut(S);
    494       T->getNoexceptExpr()->printPretty(EOut, 0, Policy);
    495       EOut.flush();
    496       S += EOut.str();
    497       S += ")";
    498     }
    499   }
    500 
    501   print(T->getResultType(), S);
    502 }
    503 
    504 void TypePrinter::printFunctionNoProto(const FunctionNoProtoType *T,
    505                                        std::string &S) {
    506   // If needed for precedence reasons, wrap the inner part in grouping parens.
    507   if (!S.empty())
    508     S = "(" + S + ")";
    509 
    510   S += "()";
    511   if (T->getNoReturnAttr())
    512     S += " __attribute__((noreturn))";
    513   print(T->getResultType(), S);
    514 }
    515 
    516 static void printTypeSpec(const NamedDecl *D, std::string &S) {
    517   IdentifierInfo *II = D->getIdentifier();
    518   if (S.empty())
    519     S = II->getName().str();
    520   else
    521     S = II->getName().str() + ' ' + S;
    522 }
    523 
    524 void TypePrinter::printUnresolvedUsing(const UnresolvedUsingType *T,
    525                                        std::string &S) {
    526   printTypeSpec(T->getDecl(), S);
    527 }
    528 
    529 void TypePrinter::printTypedef(const TypedefType *T, std::string &S) {
    530   printTypeSpec(T->getDecl(), S);
    531 }
    532 
    533 void TypePrinter::printTypeOfExpr(const TypeOfExprType *T, std::string &S) {
    534   if (!S.empty())    // Prefix the basic type, e.g. 'typeof(e) X'.
    535     S = ' ' + S;
    536   std::string Str;
    537   llvm::raw_string_ostream s(Str);
    538   T->getUnderlyingExpr()->printPretty(s, 0, Policy);
    539   S = "typeof " + s.str() + S;
    540 }
    541 
    542 void TypePrinter::printTypeOf(const TypeOfType *T, std::string &S) {
    543   if (!S.empty())    // Prefix the basic type, e.g. 'typeof(t) X'.
    544     S = ' ' + S;
    545   std::string Tmp;
    546   print(T->getUnderlyingType(), Tmp);
    547   S = "typeof(" + Tmp + ")" + S;
    548 }
    549 
    550 void TypePrinter::printDecltype(const DecltypeType *T, std::string &S) {
    551   if (!S.empty())    // Prefix the basic type, e.g. 'decltype(t) X'.
    552     S = ' ' + S;
    553   std::string Str;
    554   llvm::raw_string_ostream s(Str);
    555   T->getUnderlyingExpr()->printPretty(s, 0, Policy);
    556   S = "decltype(" + s.str() + ")" + S;
    557 }
    558 
    559 void TypePrinter::printUnaryTransform(const UnaryTransformType *T,
    560                                            std::string &S) {
    561   if (!S.empty())
    562     S = ' ' + S;
    563   std::string Str;
    564   IncludeStrongLifetimeRAII Strong(Policy);
    565   print(T->getBaseType(), Str);
    566 
    567   switch (T->getUTTKind()) {
    568     case UnaryTransformType::EnumUnderlyingType:
    569       S = "__underlying_type(" + Str + ")" + S;
    570       break;
    571   }
    572 }
    573 
    574 void TypePrinter::printAuto(const AutoType *T, std::string &S) {
    575   // If the type has been deduced, do not print 'auto'.
    576   if (T->isDeduced()) {
    577     print(T->getDeducedType(), S);
    578   } else {
    579     if (!S.empty())    // Prefix the basic type, e.g. 'auto X'.
    580       S = ' ' + S;
    581     S = "auto" + S;
    582   }
    583 }
    584 
    585 void TypePrinter::printAtomic(const AtomicType *T, std::string &S) {
    586   if (!S.empty())
    587     S = ' ' + S;
    588   std::string Str;
    589   IncludeStrongLifetimeRAII Strong(Policy);
    590   print(T->getValueType(), Str);
    591 
    592   S = "_Atomic(" + Str + ")" + S;
    593 }
    594 
    595 /// Appends the given scope to the end of a string.
    596 void TypePrinter::AppendScope(DeclContext *DC, std::string &Buffer) {
    597   if (DC->isTranslationUnit()) return;
    598   AppendScope(DC->getParent(), Buffer);
    599 
    600   unsigned OldSize = Buffer.size();
    601 
    602   if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) {
    603     if (NS->getIdentifier())
    604       Buffer += NS->getNameAsString();
    605     else
    606       Buffer += "<anonymous>";
    607   } else if (ClassTemplateSpecializationDecl *Spec
    608                = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
    609     IncludeStrongLifetimeRAII Strong(Policy);
    610     const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
    611     std::string TemplateArgsStr
    612       = TemplateSpecializationType::PrintTemplateArgumentList(
    613                                             TemplateArgs.data(),
    614                                             TemplateArgs.size(),
    615                                             Policy);
    616     Buffer += Spec->getIdentifier()->getName();
    617     Buffer += TemplateArgsStr;
    618   } else if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) {
    619     if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
    620       Buffer += Typedef->getIdentifier()->getName();
    621     else if (Tag->getIdentifier())
    622       Buffer += Tag->getIdentifier()->getName();
    623   }
    624 
    625   if (Buffer.size() != OldSize)
    626     Buffer += "::";
    627 }
    628 
    629 void TypePrinter::printTag(TagDecl *D, std::string &InnerString) {
    630   if (Policy.SuppressTag)
    631     return;
    632 
    633   std::string Buffer;
    634   bool HasKindDecoration = false;
    635 
    636   // bool SuppressTagKeyword
    637   //   = Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword;
    638 
    639   // We don't print tags unless this is an elaborated type.
    640   // In C, we just assume every RecordType is an elaborated type.
    641   if (!(Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword ||
    642         D->getTypedefNameForAnonDecl())) {
    643     HasKindDecoration = true;
    644     Buffer += D->getKindName();
    645     Buffer += ' ';
    646   }
    647 
    648   // Compute the full nested-name-specifier for this type.
    649   // In C, this will always be empty except when the type
    650   // being printed is anonymous within other Record.
    651   if (!Policy.SuppressScope)
    652     AppendScope(D->getDeclContext(), Buffer);
    653 
    654   if (const IdentifierInfo *II = D->getIdentifier())
    655     Buffer += II->getNameStart();
    656   else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
    657     assert(Typedef->getIdentifier() && "Typedef without identifier?");
    658     Buffer += Typedef->getIdentifier()->getNameStart();
    659   } else {
    660     // Make an unambiguous representation for anonymous types, e.g.
    661     //   <anonymous enum at /usr/include/string.h:120:9>
    662     llvm::raw_string_ostream OS(Buffer);
    663     OS << "<anonymous";
    664 
    665     if (Policy.AnonymousTagLocations) {
    666       // Suppress the redundant tag keyword if we just printed one.
    667       // We don't have to worry about ElaboratedTypes here because you can't
    668       // refer to an anonymous type with one.
    669       if (!HasKindDecoration)
    670         OS << " " << D->getKindName();
    671 
    672       PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
    673           D->getLocation());
    674       if (PLoc.isValid()) {
    675         OS << " at " << PLoc.getFilename()
    676            << ':' << PLoc.getLine()
    677            << ':' << PLoc.getColumn();
    678       }
    679     }
    680 
    681     OS << '>';
    682   }
    683 
    684   // If this is a class template specialization, print the template
    685   // arguments.
    686   if (ClassTemplateSpecializationDecl *Spec
    687         = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
    688     const TemplateArgument *Args;
    689     unsigned NumArgs;
    690     if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
    691       const TemplateSpecializationType *TST =
    692         cast<TemplateSpecializationType>(TAW->getType());
    693       Args = TST->getArgs();
    694       NumArgs = TST->getNumArgs();
    695     } else {
    696       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
    697       Args = TemplateArgs.data();
    698       NumArgs = TemplateArgs.size();
    699     }
    700     IncludeStrongLifetimeRAII Strong(Policy);
    701     Buffer += TemplateSpecializationType::PrintTemplateArgumentList(Args,
    702                                                                     NumArgs,
    703                                                                     Policy);
    704   }
    705 
    706   if (!InnerString.empty()) {
    707     Buffer += ' ';
    708     Buffer += InnerString;
    709   }
    710 
    711   std::swap(Buffer, InnerString);
    712 }
    713 
    714 void TypePrinter::printRecord(const RecordType *T, std::string &S) {
    715   printTag(T->getDecl(), S);
    716 }
    717 
    718 void TypePrinter::printEnum(const EnumType *T, std::string &S) {
    719   printTag(T->getDecl(), S);
    720 }
    721 
    722 void TypePrinter::printTemplateTypeParm(const TemplateTypeParmType *T,
    723                                         std::string &S) {
    724   if (!S.empty())    // Prefix the basic type, e.g. 'parmname X'.
    725     S = ' ' + S;
    726 
    727   if (IdentifierInfo *Id = T->getIdentifier())
    728     S = Id->getName().str() + S;
    729   else
    730     S = "type-parameter-" + llvm::utostr_32(T->getDepth()) + '-' +
    731         llvm::utostr_32(T->getIndex()) + S;
    732 }
    733 
    734 void TypePrinter::printSubstTemplateTypeParm(const SubstTemplateTypeParmType *T,
    735                                              std::string &S) {
    736   IncludeStrongLifetimeRAII Strong(Policy);
    737   print(T->getReplacementType(), S);
    738 }
    739 
    740 void TypePrinter::printSubstTemplateTypeParmPack(
    741                                         const SubstTemplateTypeParmPackType *T,
    742                                              std::string &S) {
    743   IncludeStrongLifetimeRAII Strong(Policy);
    744   printTemplateTypeParm(T->getReplacedParameter(), S);
    745 }
    746 
    747 void TypePrinter::printTemplateSpecialization(
    748                                             const TemplateSpecializationType *T,
    749                                               std::string &S) {
    750   IncludeStrongLifetimeRAII Strong(Policy);
    751   std::string SpecString;
    752 
    753   {
    754     llvm::raw_string_ostream OS(SpecString);
    755     T->getTemplateName().print(OS, Policy);
    756   }
    757 
    758   SpecString += TemplateSpecializationType::PrintTemplateArgumentList(
    759                                                                   T->getArgs(),
    760                                                                 T->getNumArgs(),
    761                                                                       Policy);
    762   if (S.empty())
    763     S.swap(SpecString);
    764   else
    765     S = SpecString + ' ' + S;
    766 }
    767 
    768 void TypePrinter::printInjectedClassName(const InjectedClassNameType *T,
    769                                          std::string &S) {
    770   printTemplateSpecialization(T->getInjectedTST(), S);
    771 }
    772 
    773 void TypePrinter::printElaborated(const ElaboratedType *T, std::string &S) {
    774   std::string MyString;
    775 
    776   {
    777     llvm::raw_string_ostream OS(MyString);
    778     OS << TypeWithKeyword::getKeywordName(T->getKeyword());
    779     if (T->getKeyword() != ETK_None)
    780       OS << " ";
    781     NestedNameSpecifier* Qualifier = T->getQualifier();
    782     if (Qualifier)
    783       Qualifier->print(OS, Policy);
    784   }
    785 
    786   std::string TypeStr;
    787   PrintingPolicy InnerPolicy(Policy);
    788   InnerPolicy.SuppressTagKeyword = true;
    789   InnerPolicy.SuppressScope = true;
    790   TypePrinter(InnerPolicy).print(T->getNamedType(), TypeStr);
    791 
    792   MyString += TypeStr;
    793   if (S.empty())
    794     S.swap(MyString);
    795   else
    796     S = MyString + ' ' + S;
    797 }
    798 
    799 void TypePrinter::printParen(const ParenType *T, std::string &S) {
    800   if (!S.empty() && !isa<FunctionType>(T->getInnerType()))
    801     S = '(' + S + ')';
    802   print(T->getInnerType(), S);
    803 }
    804 
    805 void TypePrinter::printDependentName(const DependentNameType *T, std::string &S) {
    806   std::string MyString;
    807 
    808   {
    809     llvm::raw_string_ostream OS(MyString);
    810     OS << TypeWithKeyword::getKeywordName(T->getKeyword());
    811     if (T->getKeyword() != ETK_None)
    812       OS << " ";
    813 
    814     T->getQualifier()->print(OS, Policy);
    815 
    816     OS << T->getIdentifier()->getName();
    817   }
    818 
    819   if (S.empty())
    820     S.swap(MyString);
    821   else
    822     S = MyString + ' ' + S;
    823 }
    824 
    825 void TypePrinter::printDependentTemplateSpecialization(
    826         const DependentTemplateSpecializationType *T, std::string &S) {
    827   IncludeStrongLifetimeRAII Strong(Policy);
    828   std::string MyString;
    829   {
    830     llvm::raw_string_ostream OS(MyString);
    831 
    832     OS << TypeWithKeyword::getKeywordName(T->getKeyword());
    833     if (T->getKeyword() != ETK_None)
    834       OS << " ";
    835 
    836     if (T->getQualifier())
    837       T->getQualifier()->print(OS, Policy);
    838     OS << T->getIdentifier()->getName();
    839     OS << TemplateSpecializationType::PrintTemplateArgumentList(
    840                                                             T->getArgs(),
    841                                                             T->getNumArgs(),
    842                                                             Policy);
    843   }
    844 
    845   if (S.empty())
    846     S.swap(MyString);
    847   else
    848     S = MyString + ' ' + S;
    849 }
    850 
    851 void TypePrinter::printPackExpansion(const PackExpansionType *T,
    852                                      std::string &S) {
    853   print(T->getPattern(), S);
    854   S += "...";
    855 }
    856 
    857 void TypePrinter::printAttributed(const AttributedType *T,
    858                                   std::string &S) {
    859   // Prefer the macro forms of the GC and ownership qualifiers.
    860   if (T->getAttrKind() == AttributedType::attr_objc_gc ||
    861       T->getAttrKind() == AttributedType::attr_objc_ownership)
    862     return print(T->getEquivalentType(), S);
    863 
    864   print(T->getModifiedType(), S);
    865 
    866   // TODO: not all attributes are GCC-style attributes.
    867   S += " __attribute__((";
    868   switch (T->getAttrKind()) {
    869   case AttributedType::attr_address_space:
    870     S += "address_space(";
    871     S += T->getEquivalentType().getAddressSpace();
    872     S += ")";
    873     break;
    874 
    875   case AttributedType::attr_vector_size: {
    876     S += "__vector_size__(";
    877     if (const VectorType *vector =T->getEquivalentType()->getAs<VectorType>()) {
    878       S += vector->getNumElements();
    879       S += " * sizeof(";
    880 
    881       std::string tmp;
    882       print(vector->getElementType(), tmp);
    883       S += tmp;
    884       S += ")";
    885     }
    886     S += ")";
    887     break;
    888   }
    889 
    890   case AttributedType::attr_neon_vector_type:
    891   case AttributedType::attr_neon_polyvector_type: {
    892     if (T->getAttrKind() == AttributedType::attr_neon_vector_type)
    893       S += "neon_vector_type(";
    894     else
    895       S += "neon_polyvector_type(";
    896     const VectorType *vector = T->getEquivalentType()->getAs<VectorType>();
    897     S += llvm::utostr_32(vector->getNumElements());
    898     S += ")";
    899     break;
    900   }
    901 
    902   case AttributedType::attr_regparm: {
    903     S += "regparm(";
    904     QualType t = T->getEquivalentType();
    905     while (!t->isFunctionType())
    906       t = t->getPointeeType();
    907     S += t->getAs<FunctionType>()->getRegParmType();
    908     S += ")";
    909     break;
    910   }
    911 
    912   case AttributedType::attr_objc_gc: {
    913     S += "objc_gc(";
    914 
    915     QualType tmp = T->getEquivalentType();
    916     while (tmp.getObjCGCAttr() == Qualifiers::GCNone) {
    917       QualType next = tmp->getPointeeType();
    918       if (next == tmp) break;
    919       tmp = next;
    920     }
    921 
    922     if (tmp.isObjCGCWeak())
    923       S += "weak";
    924     else
    925       S += "strong";
    926     S += ")";
    927     break;
    928   }
    929 
    930   case AttributedType::attr_objc_ownership:
    931     S += "objc_ownership(";
    932     switch (T->getEquivalentType().getObjCLifetime()) {
    933     case Qualifiers::OCL_None: llvm_unreachable("no ownership!"); break;
    934     case Qualifiers::OCL_ExplicitNone: S += "none"; break;
    935     case Qualifiers::OCL_Strong: S += "strong"; break;
    936     case Qualifiers::OCL_Weak: S += "weak"; break;
    937     case Qualifiers::OCL_Autoreleasing: S += "autoreleasing"; break;
    938     }
    939     S += ")";
    940     break;
    941 
    942   case AttributedType::attr_noreturn: S += "noreturn"; break;
    943   case AttributedType::attr_cdecl: S += "cdecl"; break;
    944   case AttributedType::attr_fastcall: S += "fastcall"; break;
    945   case AttributedType::attr_stdcall: S += "stdcall"; break;
    946   case AttributedType::attr_thiscall: S += "thiscall"; break;
    947   case AttributedType::attr_pascal: S += "pascal"; break;
    948   case AttributedType::attr_pcs: {
    949    S += "pcs(";
    950    QualType t = T->getEquivalentType();
    951    while (!t->isFunctionType())
    952      t = t->getPointeeType();
    953    S += (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ?
    954          "\"aapcs\"" : "\"aapcs-vfp\"");
    955    S += ")";
    956    break;
    957   }
    958   }
    959   S += "))";
    960 }
    961 
    962 void TypePrinter::printObjCInterface(const ObjCInterfaceType *T,
    963                                      std::string &S) {
    964   if (!S.empty())    // Prefix the basic type, e.g. 'typedefname X'.
    965     S = ' ' + S;
    966 
    967   std::string ObjCQIString = T->getDecl()->getNameAsString();
    968   S = ObjCQIString + S;
    969 }
    970 
    971 void TypePrinter::printObjCObject(const ObjCObjectType *T,
    972                                   std::string &S) {
    973   if (T->qual_empty())
    974     return print(T->getBaseType(), S);
    975 
    976   std::string tmp;
    977   print(T->getBaseType(), tmp);
    978   tmp += '<';
    979   bool isFirst = true;
    980   for (ObjCObjectType::qual_iterator
    981          I = T->qual_begin(), E = T->qual_end(); I != E; ++I) {
    982     if (isFirst)
    983       isFirst = false;
    984     else
    985       tmp += ',';
    986     tmp += (*I)->getNameAsString();
    987   }
    988   tmp += '>';
    989 
    990   if (!S.empty()) {
    991     tmp += ' ';
    992     tmp += S;
    993   }
    994   std::swap(tmp, S);
    995 }
    996 
    997 void TypePrinter::printObjCObjectPointer(const ObjCObjectPointerType *T,
    998                                          std::string &S) {
    999   std::string ObjCQIString;
   1000 
   1001   T->getPointeeType().getLocalQualifiers().getAsStringInternal(ObjCQIString,
   1002                                                                Policy);
   1003   if (!ObjCQIString.empty())
   1004     ObjCQIString += ' ';
   1005 
   1006   if (T->isObjCIdType() || T->isObjCQualifiedIdType())
   1007     ObjCQIString += "id";
   1008   else if (T->isObjCClassType() || T->isObjCQualifiedClassType())
   1009     ObjCQIString += "Class";
   1010   else if (T->isObjCSelType())
   1011     ObjCQIString += "SEL";
   1012   else
   1013     ObjCQIString += T->getInterfaceDecl()->getNameAsString();
   1014 
   1015   if (!T->qual_empty()) {
   1016     ObjCQIString += '<';
   1017     for (ObjCObjectPointerType::qual_iterator I = T->qual_begin(),
   1018                                               E = T->qual_end();
   1019          I != E; ++I) {
   1020       ObjCQIString += (*I)->getNameAsString();
   1021       if (I+1 != E)
   1022         ObjCQIString += ',';
   1023     }
   1024     ObjCQIString += '>';
   1025   }
   1026 
   1027   if (!T->isObjCIdType() && !T->isObjCQualifiedIdType())
   1028     ObjCQIString += " *"; // Don't forget the implicit pointer.
   1029   else if (!S.empty()) // Prefix the basic type, e.g. 'typedefname X'.
   1030     S = ' ' + S;
   1031 
   1032   S = ObjCQIString + S;
   1033 }
   1034 
   1035 std::string TemplateSpecializationType::
   1036   PrintTemplateArgumentList(const TemplateArgumentListInfo &Args,
   1037                             const PrintingPolicy &Policy) {
   1038   return PrintTemplateArgumentList(Args.getArgumentArray(),
   1039                                    Args.size(),
   1040                                    Policy);
   1041 }
   1042 
   1043 std::string
   1044 TemplateSpecializationType::PrintTemplateArgumentList(
   1045                                                 const TemplateArgument *Args,
   1046                                                 unsigned NumArgs,
   1047                                                   const PrintingPolicy &Policy,
   1048                                                       bool SkipBrackets) {
   1049   std::string SpecString;
   1050   if (!SkipBrackets)
   1051     SpecString += '<';
   1052 
   1053   for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
   1054     if (SpecString.size() > unsigned(!SkipBrackets))
   1055       SpecString += ", ";
   1056 
   1057     // Print the argument into a string.
   1058     std::string ArgString;
   1059     if (Args[Arg].getKind() == TemplateArgument::Pack) {
   1060       ArgString = PrintTemplateArgumentList(Args[Arg].pack_begin(),
   1061                                             Args[Arg].pack_size(),
   1062                                             Policy, true);
   1063     } else {
   1064       llvm::raw_string_ostream ArgOut(ArgString);
   1065       Args[Arg].print(Policy, ArgOut);
   1066     }
   1067 
   1068     // If this is the first argument and its string representation
   1069     // begins with the global scope specifier ('::foo'), add a space
   1070     // to avoid printing the diagraph '<:'.
   1071     if (!Arg && !ArgString.empty() && ArgString[0] == ':')
   1072       SpecString += ' ';
   1073 
   1074     SpecString += ArgString;
   1075   }
   1076 
   1077   // If the last character of our string is '>', add another space to
   1078   // keep the two '>''s separate tokens. We don't *have* to do this in
   1079   // C++0x, but it's still good hygiene.
   1080   if (!SpecString.empty() && SpecString[SpecString.size() - 1] == '>')
   1081     SpecString += ' ';
   1082 
   1083   if (!SkipBrackets)
   1084     SpecString += '>';
   1085 
   1086   return SpecString;
   1087 }
   1088 
   1089 // Sadly, repeat all that with TemplateArgLoc.
   1090 std::string TemplateSpecializationType::
   1091 PrintTemplateArgumentList(const TemplateArgumentLoc *Args, unsigned NumArgs,
   1092                           const PrintingPolicy &Policy) {
   1093   std::string SpecString;
   1094   SpecString += '<';
   1095   for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
   1096     if (SpecString.size() > 1)
   1097       SpecString += ", ";
   1098 
   1099     // Print the argument into a string.
   1100     std::string ArgString;
   1101     if (Args[Arg].getArgument().getKind() == TemplateArgument::Pack) {
   1102       ArgString = PrintTemplateArgumentList(
   1103                                            Args[Arg].getArgument().pack_begin(),
   1104                                             Args[Arg].getArgument().pack_size(),
   1105                                             Policy, true);
   1106     } else {
   1107       llvm::raw_string_ostream ArgOut(ArgString);
   1108       Args[Arg].getArgument().print(Policy, ArgOut);
   1109     }
   1110 
   1111     // If this is the first argument and its string representation
   1112     // begins with the global scope specifier ('::foo'), add a space
   1113     // to avoid printing the diagraph '<:'.
   1114     if (!Arg && !ArgString.empty() && ArgString[0] == ':')
   1115       SpecString += ' ';
   1116 
   1117     SpecString += ArgString;
   1118   }
   1119 
   1120   // If the last character of our string is '>', add another space to
   1121   // keep the two '>''s separate tokens. We don't *have* to do this in
   1122   // C++0x, but it's still good hygiene.
   1123   if (SpecString[SpecString.size() - 1] == '>')
   1124     SpecString += ' ';
   1125 
   1126   SpecString += '>';
   1127 
   1128   return SpecString;
   1129 }
   1130 
   1131 void QualType::dump(const char *msg) const {
   1132   std::string R = "identifier";
   1133   LangOptions LO;
   1134   getAsStringInternal(R, PrintingPolicy(LO));
   1135   if (msg)
   1136     llvm::errs() << msg << ": ";
   1137   llvm::errs() << R << "\n";
   1138 }
   1139 void QualType::dump() const {
   1140   dump("");
   1141 }
   1142 
   1143 void Type::dump() const {
   1144   QualType(this, 0).dump();
   1145 }
   1146 
   1147 std::string Qualifiers::getAsString() const {
   1148   LangOptions LO;
   1149   return getAsString(PrintingPolicy(LO));
   1150 }
   1151 
   1152 // Appends qualifiers to the given string, separated by spaces.  Will
   1153 // prefix a space if the string is non-empty.  Will not append a final
   1154 // space.
   1155 void Qualifiers::getAsStringInternal(std::string &S,
   1156                                      const PrintingPolicy& Policy) const {
   1157   AppendTypeQualList(S, getCVRQualifiers());
   1158   if (unsigned addrspace = getAddressSpace()) {
   1159     if (!S.empty()) S += ' ';
   1160     S += "__attribute__((address_space(";
   1161     S += llvm::utostr_32(addrspace);
   1162     S += ")))";
   1163   }
   1164   if (Qualifiers::GC gc = getObjCGCAttr()) {
   1165     if (!S.empty()) S += ' ';
   1166     if (gc == Qualifiers::Weak)
   1167       S += "__weak";
   1168     else
   1169       S += "__strong";
   1170   }
   1171   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
   1172     if (!S.empty() &&
   1173         !(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
   1174       S += ' ';
   1175 
   1176     switch (lifetime) {
   1177     case Qualifiers::OCL_None: llvm_unreachable("none but true");
   1178     case Qualifiers::OCL_ExplicitNone: S += "__unsafe_unretained"; break;
   1179     case Qualifiers::OCL_Strong:
   1180       if (!Policy.SuppressStrongLifetime)
   1181         S += "__strong";
   1182       break;
   1183 
   1184     case Qualifiers::OCL_Weak: S += "__weak"; break;
   1185     case Qualifiers::OCL_Autoreleasing: S += "__autoreleasing"; break;
   1186     }
   1187   }
   1188 }
   1189 
   1190 std::string QualType::getAsString(const Type *ty, Qualifiers qs) {
   1191   std::string buffer;
   1192   LangOptions options;
   1193   getAsStringInternal(ty, qs, buffer, PrintingPolicy(options));
   1194   return buffer;
   1195 }
   1196 
   1197 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
   1198                                    std::string &buffer,
   1199                                    const PrintingPolicy &policy) {
   1200   TypePrinter(policy).print(ty, qs, buffer);
   1201 }
   1202