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/PrettyPrinter.h"
     15 #include "clang/AST/ASTContext.h"
     16 #include "clang/AST/Decl.h"
     17 #include "clang/AST/DeclObjC.h"
     18 #include "clang/AST/DeclTemplate.h"
     19 #include "clang/AST/Expr.h"
     20 #include "clang/AST/Type.h"
     21 #include "clang/Basic/LangOptions.h"
     22 #include "clang/Basic/SourceManager.h"
     23 #include "llvm/ADT/SmallString.h"
     24 #include "llvm/ADT/StringExtras.h"
     25 #include "llvm/Support/SaveAndRestore.h"
     26 #include "llvm/Support/raw_ostream.h"
     27 using namespace clang;
     28 
     29 namespace {
     30   /// \brief RAII object that enables printing of the ARC __strong lifetime
     31   /// qualifier.
     32   class IncludeStrongLifetimeRAII {
     33     PrintingPolicy &Policy;
     34     bool Old;
     35 
     36   public:
     37     explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
     38       : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
     39       Policy.SuppressStrongLifetime = false;
     40     }
     41 
     42     ~IncludeStrongLifetimeRAII() {
     43       Policy.SuppressStrongLifetime = Old;
     44     }
     45   };
     46 
     47   class ParamPolicyRAII {
     48     PrintingPolicy &Policy;
     49     bool Old;
     50 
     51   public:
     52     explicit ParamPolicyRAII(PrintingPolicy &Policy)
     53       : Policy(Policy), Old(Policy.SuppressSpecifiers) {
     54       Policy.SuppressSpecifiers = false;
     55     }
     56 
     57     ~ParamPolicyRAII() {
     58       Policy.SuppressSpecifiers = Old;
     59     }
     60   };
     61 
     62   class ElaboratedTypePolicyRAII {
     63     PrintingPolicy &Policy;
     64     bool SuppressTagKeyword;
     65     bool SuppressScope;
     66 
     67   public:
     68     explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
     69       SuppressTagKeyword = Policy.SuppressTagKeyword;
     70       SuppressScope = Policy.SuppressScope;
     71       Policy.SuppressTagKeyword = true;
     72       Policy.SuppressScope = true;
     73     }
     74 
     75     ~ElaboratedTypePolicyRAII() {
     76       Policy.SuppressTagKeyword = SuppressTagKeyword;
     77       Policy.SuppressScope = SuppressScope;
     78     }
     79   };
     80 
     81   class TypePrinter {
     82     PrintingPolicy Policy;
     83     bool HasEmptyPlaceHolder;
     84 
     85   public:
     86     explicit TypePrinter(const PrintingPolicy &Policy)
     87       : Policy(Policy), HasEmptyPlaceHolder(false) { }
     88 
     89     void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
     90                StringRef PlaceHolder);
     91     void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);
     92 
     93     static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
     94     void spaceBeforePlaceHolder(raw_ostream &OS);
     95     void printTypeSpec(const NamedDecl *D, raw_ostream &OS);
     96 
     97     void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
     98     void printBefore(QualType T, raw_ostream &OS);
     99     void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
    100     void printAfter(QualType T, raw_ostream &OS);
    101     void AppendScope(DeclContext *DC, raw_ostream &OS);
    102     void printTag(TagDecl *T, raw_ostream &OS);
    103 #define ABSTRACT_TYPE(CLASS, PARENT)
    104 #define TYPE(CLASS, PARENT) \
    105     void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \
    106     void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS);
    107 #include "clang/AST/TypeNodes.def"
    108   };
    109 }
    110 
    111 static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals) {
    112   bool appendSpace = false;
    113   if (TypeQuals & Qualifiers::Const) {
    114     OS << "const";
    115     appendSpace = true;
    116   }
    117   if (TypeQuals & Qualifiers::Volatile) {
    118     if (appendSpace) OS << ' ';
    119     OS << "volatile";
    120     appendSpace = true;
    121   }
    122   if (TypeQuals & Qualifiers::Restrict) {
    123     if (appendSpace) OS << ' ';
    124     OS << "restrict";
    125   }
    126 }
    127 
    128 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
    129   if (!HasEmptyPlaceHolder)
    130     OS << ' ';
    131 }
    132 
    133 void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) {
    134   SplitQualType split = t.split();
    135   print(split.Ty, split.Quals, OS, PlaceHolder);
    136 }
    137 
    138 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
    139                         StringRef PlaceHolder) {
    140   if (!T) {
    141     OS << "NULL TYPE";
    142     return;
    143   }
    144 
    145   SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty());
    146 
    147   printBefore(T, Quals, OS);
    148   OS << PlaceHolder;
    149   printAfter(T, Quals, OS);
    150 }
    151 
    152 bool TypePrinter::canPrefixQualifiers(const Type *T,
    153                                       bool &NeedARCStrongQualifier) {
    154   // CanPrefixQualifiers - We prefer to print type qualifiers before the type,
    155   // so that we get "const int" instead of "int const", but we can't do this if
    156   // the type is complex.  For example if the type is "int*", we *must* print
    157   // "int * const", printing "const int *" is different.  Only do this when the
    158   // type expands to a simple string.
    159   bool CanPrefixQualifiers = false;
    160   NeedARCStrongQualifier = false;
    161   Type::TypeClass TC = T->getTypeClass();
    162   if (const AutoType *AT = dyn_cast<AutoType>(T))
    163     TC = AT->desugar()->getTypeClass();
    164   if (const SubstTemplateTypeParmType *Subst
    165                                       = dyn_cast<SubstTemplateTypeParmType>(T))
    166     TC = Subst->getReplacementType()->getTypeClass();
    167 
    168   switch (TC) {
    169     case Type::Builtin:
    170     case Type::Complex:
    171     case Type::UnresolvedUsing:
    172     case Type::Typedef:
    173     case Type::TypeOfExpr:
    174     case Type::TypeOf:
    175     case Type::Decltype:
    176     case Type::UnaryTransform:
    177     case Type::Record:
    178     case Type::Enum:
    179     case Type::Elaborated:
    180     case Type::TemplateTypeParm:
    181     case Type::SubstTemplateTypeParmPack:
    182     case Type::TemplateSpecialization:
    183     case Type::InjectedClassName:
    184     case Type::DependentName:
    185     case Type::DependentTemplateSpecialization:
    186     case Type::ObjCObject:
    187     case Type::ObjCInterface:
    188     case Type::Atomic:
    189       CanPrefixQualifiers = true;
    190       break;
    191 
    192     case Type::ObjCObjectPointer:
    193       CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
    194         T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType();
    195       break;
    196 
    197     case Type::ConstantArray:
    198     case Type::IncompleteArray:
    199     case Type::VariableArray:
    200     case Type::DependentSizedArray:
    201       NeedARCStrongQualifier = true;
    202       // Fall through
    203 
    204     case Type::Pointer:
    205     case Type::BlockPointer:
    206     case Type::LValueReference:
    207     case Type::RValueReference:
    208     case Type::MemberPointer:
    209     case Type::DependentSizedExtVector:
    210     case Type::Vector:
    211     case Type::ExtVector:
    212     case Type::FunctionProto:
    213     case Type::FunctionNoProto:
    214     case Type::Paren:
    215     case Type::Attributed:
    216     case Type::PackExpansion:
    217     case Type::SubstTemplateTypeParm:
    218     case Type::Auto:
    219       CanPrefixQualifiers = false;
    220       break;
    221   }
    222 
    223   return CanPrefixQualifiers;
    224 }
    225 
    226 void TypePrinter::printBefore(QualType T, raw_ostream &OS) {
    227   SplitQualType Split = T.split();
    228 
    229   // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2
    230   // at this level.
    231   Qualifiers Quals = Split.Quals;
    232   if (const SubstTemplateTypeParmType *Subst =
    233         dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
    234     Quals -= QualType(Subst, 0).getQualifiers();
    235 
    236   printBefore(Split.Ty, Quals, OS);
    237 }
    238 
    239 /// \brief Prints the part of the type string before an identifier, e.g. for
    240 /// "int foo[10]" it prints "int ".
    241 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
    242   if (Policy.SuppressSpecifiers && T->isSpecifierType())
    243     return;
    244 
    245   SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder);
    246 
    247   // Print qualifiers as appropriate.
    248 
    249   bool CanPrefixQualifiers = false;
    250   bool NeedARCStrongQualifier = false;
    251   CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier);
    252 
    253   if (CanPrefixQualifiers && !Quals.empty()) {
    254     if (NeedARCStrongQualifier) {
    255       IncludeStrongLifetimeRAII Strong(Policy);
    256       Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
    257     } else {
    258       Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
    259     }
    260   }
    261 
    262   bool hasAfterQuals = false;
    263   if (!CanPrefixQualifiers && !Quals.empty()) {
    264     hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy);
    265     if (hasAfterQuals)
    266       HasEmptyPlaceHolder = false;
    267   }
    268 
    269   switch (T->getTypeClass()) {
    270 #define ABSTRACT_TYPE(CLASS, PARENT)
    271 #define TYPE(CLASS, PARENT) case Type::CLASS: \
    272     print##CLASS##Before(cast<CLASS##Type>(T), OS); \
    273     break;
    274 #include "clang/AST/TypeNodes.def"
    275   }
    276 
    277   if (hasAfterQuals) {
    278     if (NeedARCStrongQualifier) {
    279       IncludeStrongLifetimeRAII Strong(Policy);
    280       Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
    281     } else {
    282       Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
    283     }
    284   }
    285 }
    286 
    287 void TypePrinter::printAfter(QualType t, raw_ostream &OS) {
    288   SplitQualType split = t.split();
    289   printAfter(split.Ty, split.Quals, OS);
    290 }
    291 
    292 /// \brief Prints the part of the type string after an identifier, e.g. for
    293 /// "int foo[10]" it prints "[10]".
    294 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
    295   switch (T->getTypeClass()) {
    296 #define ABSTRACT_TYPE(CLASS, PARENT)
    297 #define TYPE(CLASS, PARENT) case Type::CLASS: \
    298     print##CLASS##After(cast<CLASS##Type>(T), OS); \
    299     break;
    300 #include "clang/AST/TypeNodes.def"
    301   }
    302 }
    303 
    304 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
    305   OS << T->getName(Policy);
    306   spaceBeforePlaceHolder(OS);
    307 }
    308 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) { }
    309 
    310 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
    311   OS << "_Complex ";
    312   printBefore(T->getElementType(), OS);
    313 }
    314 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
    315   printAfter(T->getElementType(), OS);
    316 }
    317 
    318 void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) {
    319   IncludeStrongLifetimeRAII Strong(Policy);
    320   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    321   printBefore(T->getPointeeType(), OS);
    322   // Handle things like 'int (*A)[4];' correctly.
    323   // FIXME: this should include vectors, but vectors use attributes I guess.
    324   if (isa<ArrayType>(T->getPointeeType()))
    325     OS << '(';
    326   OS << '*';
    327 }
    328 void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) {
    329   IncludeStrongLifetimeRAII Strong(Policy);
    330   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    331   // Handle things like 'int (*A)[4];' correctly.
    332   // FIXME: this should include vectors, but vectors use attributes I guess.
    333   if (isa<ArrayType>(T->getPointeeType()))
    334     OS << ')';
    335   printAfter(T->getPointeeType(), OS);
    336 }
    337 
    338 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
    339                                           raw_ostream &OS) {
    340   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    341   printBefore(T->getPointeeType(), OS);
    342   OS << '^';
    343 }
    344 void TypePrinter::printBlockPointerAfter(const BlockPointerType *T,
    345                                           raw_ostream &OS) {
    346   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    347   printAfter(T->getPointeeType(), OS);
    348 }
    349 
    350 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
    351                                              raw_ostream &OS) {
    352   IncludeStrongLifetimeRAII Strong(Policy);
    353   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    354   printBefore(T->getPointeeTypeAsWritten(), OS);
    355   // Handle things like 'int (&A)[4];' correctly.
    356   // FIXME: this should include vectors, but vectors use attributes I guess.
    357   if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
    358     OS << '(';
    359   OS << '&';
    360 }
    361 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
    362                                             raw_ostream &OS) {
    363   IncludeStrongLifetimeRAII Strong(Policy);
    364   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    365   // Handle things like 'int (&A)[4];' correctly.
    366   // FIXME: this should include vectors, but vectors use attributes I guess.
    367   if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
    368     OS << ')';
    369   printAfter(T->getPointeeTypeAsWritten(), OS);
    370 }
    371 
    372 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
    373                                              raw_ostream &OS) {
    374   IncludeStrongLifetimeRAII Strong(Policy);
    375   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    376   printBefore(T->getPointeeTypeAsWritten(), OS);
    377   // Handle things like 'int (&&A)[4];' correctly.
    378   // FIXME: this should include vectors, but vectors use attributes I guess.
    379   if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
    380     OS << '(';
    381   OS << "&&";
    382 }
    383 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
    384                                             raw_ostream &OS) {
    385   IncludeStrongLifetimeRAII Strong(Policy);
    386   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    387   // Handle things like 'int (&&A)[4];' correctly.
    388   // FIXME: this should include vectors, but vectors use attributes I guess.
    389   if (isa<ArrayType>(T->getPointeeTypeAsWritten()))
    390     OS << ')';
    391   printAfter(T->getPointeeTypeAsWritten(), OS);
    392 }
    393 
    394 void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
    395                                            raw_ostream &OS) {
    396   IncludeStrongLifetimeRAII Strong(Policy);
    397   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    398   printBefore(T->getPointeeType(), OS);
    399   // Handle things like 'int (Cls::*A)[4];' correctly.
    400   // FIXME: this should include vectors, but vectors use attributes I guess.
    401   if (isa<ArrayType>(T->getPointeeType()))
    402     OS << '(';
    403 
    404   PrintingPolicy InnerPolicy(Policy);
    405   InnerPolicy.SuppressTag = false;
    406   TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef());
    407 
    408   OS << "::*";
    409 }
    410 void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
    411                                           raw_ostream &OS) {
    412   IncludeStrongLifetimeRAII Strong(Policy);
    413   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    414   // Handle things like 'int (Cls::*A)[4];' correctly.
    415   // FIXME: this should include vectors, but vectors use attributes I guess.
    416   if (isa<ArrayType>(T->getPointeeType()))
    417     OS << ')';
    418   printAfter(T->getPointeeType(), OS);
    419 }
    420 
    421 void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T,
    422                                            raw_ostream &OS) {
    423   IncludeStrongLifetimeRAII Strong(Policy);
    424   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    425   printBefore(T->getElementType(), OS);
    426 }
    427 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
    428                                           raw_ostream &OS) {
    429   OS << '[' << T->getSize().getZExtValue() << ']';
    430   printAfter(T->getElementType(), OS);
    431 }
    432 
    433 void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T,
    434                                              raw_ostream &OS) {
    435   IncludeStrongLifetimeRAII Strong(Policy);
    436   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    437   printBefore(T->getElementType(), OS);
    438 }
    439 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
    440                                             raw_ostream &OS) {
    441   OS << "[]";
    442   printAfter(T->getElementType(), OS);
    443 }
    444 
    445 void TypePrinter::printVariableArrayBefore(const VariableArrayType *T,
    446                                            raw_ostream &OS) {
    447   IncludeStrongLifetimeRAII Strong(Policy);
    448   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    449   printBefore(T->getElementType(), OS);
    450 }
    451 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
    452                                           raw_ostream &OS) {
    453   OS << '[';
    454   if (T->getIndexTypeQualifiers().hasQualifiers()) {
    455     AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers());
    456     OS << ' ';
    457   }
    458 
    459   if (T->getSizeModifier() == VariableArrayType::Static)
    460     OS << "static";
    461   else if (T->getSizeModifier() == VariableArrayType::Star)
    462     OS << '*';
    463 
    464   if (T->getSizeExpr())
    465     T->getSizeExpr()->printPretty(OS, 0, Policy);
    466   OS << ']';
    467 
    468   printAfter(T->getElementType(), OS);
    469 }
    470 
    471 void TypePrinter::printDependentSizedArrayBefore(
    472                                                const DependentSizedArrayType *T,
    473                                                raw_ostream &OS) {
    474   IncludeStrongLifetimeRAII Strong(Policy);
    475   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    476   printBefore(T->getElementType(), OS);
    477 }
    478 void TypePrinter::printDependentSizedArrayAfter(
    479                                                const DependentSizedArrayType *T,
    480                                                raw_ostream &OS) {
    481   OS << '[';
    482   if (T->getSizeExpr())
    483     T->getSizeExpr()->printPretty(OS, 0, Policy);
    484   OS << ']';
    485   printAfter(T->getElementType(), OS);
    486 }
    487 
    488 void TypePrinter::printDependentSizedExtVectorBefore(
    489                                           const DependentSizedExtVectorType *T,
    490                                           raw_ostream &OS) {
    491   printBefore(T->getElementType(), OS);
    492 }
    493 void TypePrinter::printDependentSizedExtVectorAfter(
    494                                           const DependentSizedExtVectorType *T,
    495                                           raw_ostream &OS) {
    496   OS << " __attribute__((ext_vector_type(";
    497   if (T->getSizeExpr())
    498     T->getSizeExpr()->printPretty(OS, 0, Policy);
    499   OS << ")))";
    500   printAfter(T->getElementType(), OS);
    501 }
    502 
    503 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
    504   switch (T->getVectorKind()) {
    505   case VectorType::AltiVecPixel:
    506     OS << "__vector __pixel ";
    507     break;
    508   case VectorType::AltiVecBool:
    509     OS << "__vector __bool ";
    510     printBefore(T->getElementType(), OS);
    511     break;
    512   case VectorType::AltiVecVector:
    513     OS << "__vector ";
    514     printBefore(T->getElementType(), OS);
    515     break;
    516   case VectorType::NeonVector:
    517     OS << "__attribute__((neon_vector_type("
    518        << T->getNumElements() << "))) ";
    519     printBefore(T->getElementType(), OS);
    520     break;
    521   case VectorType::NeonPolyVector:
    522     OS << "__attribute__((neon_polyvector_type(" <<
    523           T->getNumElements() << "))) ";
    524     printBefore(T->getElementType(), OS);
    525     break;
    526   case VectorType::GenericVector: {
    527     // FIXME: We prefer to print the size directly here, but have no way
    528     // to get the size of the type.
    529     OS << "__attribute__((__vector_size__("
    530        << T->getNumElements()
    531        << " * sizeof(";
    532     print(T->getElementType(), OS, StringRef());
    533     OS << ")))) ";
    534     printBefore(T->getElementType(), OS);
    535     break;
    536   }
    537   }
    538 }
    539 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
    540   printAfter(T->getElementType(), OS);
    541 }
    542 
    543 void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
    544                                        raw_ostream &OS) {
    545   printBefore(T->getElementType(), OS);
    546 }
    547 void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) {
    548   printAfter(T->getElementType(), OS);
    549   OS << " __attribute__((ext_vector_type(";
    550   OS << T->getNumElements();
    551   OS << ")))";
    552 }
    553 
    554 void
    555 FunctionProtoType::printExceptionSpecification(raw_ostream &OS,
    556                                                const PrintingPolicy &Policy)
    557                                                                          const {
    558 
    559   if (hasDynamicExceptionSpec()) {
    560     OS << " throw(";
    561     if (getExceptionSpecType() == EST_MSAny)
    562       OS << "...";
    563     else
    564       for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) {
    565         if (I)
    566           OS << ", ";
    567 
    568         OS << getExceptionType(I).stream(Policy);
    569       }
    570     OS << ')';
    571   } else if (isNoexceptExceptionSpec(getExceptionSpecType())) {
    572     OS << " noexcept";
    573     if (getExceptionSpecType() == EST_ComputedNoexcept) {
    574       OS << '(';
    575       getNoexceptExpr()->printPretty(OS, 0, Policy);
    576       OS << ')';
    577     }
    578   }
    579 }
    580 
    581 void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T,
    582                                            raw_ostream &OS) {
    583   if (T->hasTrailingReturn()) {
    584     OS << "auto ";
    585     if (!HasEmptyPlaceHolder)
    586       OS << '(';
    587   } else {
    588     // If needed for precedence reasons, wrap the inner part in grouping parens.
    589     SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
    590     printBefore(T->getResultType(), OS);
    591     if (!PrevPHIsEmpty.get())
    592       OS << '(';
    593   }
    594 }
    595 
    596 void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
    597                                           raw_ostream &OS) {
    598   // If needed for precedence reasons, wrap the inner part in grouping parens.
    599   if (!HasEmptyPlaceHolder)
    600     OS << ')';
    601   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    602 
    603   OS << '(';
    604   {
    605     ParamPolicyRAII ParamPolicy(Policy);
    606     for (unsigned i = 0, e = T->getNumArgs(); i != e; ++i) {
    607       if (i) OS << ", ";
    608       print(T->getArgType(i), OS, StringRef());
    609     }
    610   }
    611 
    612   if (T->isVariadic()) {
    613     if (T->getNumArgs())
    614       OS << ", ";
    615     OS << "...";
    616   } else if (T->getNumArgs() == 0 && !Policy.LangOpts.CPlusPlus) {
    617     // Do not emit int() if we have a proto, emit 'int(void)'.
    618     OS << "void";
    619   }
    620 
    621   OS << ')';
    622 
    623   FunctionType::ExtInfo Info = T->getExtInfo();
    624   switch(Info.getCC()) {
    625   case CC_Default: break;
    626   case CC_C:
    627     OS << " __attribute__((cdecl))";
    628     break;
    629   case CC_X86StdCall:
    630     OS << " __attribute__((stdcall))";
    631     break;
    632   case CC_X86FastCall:
    633     OS << " __attribute__((fastcall))";
    634     break;
    635   case CC_X86ThisCall:
    636     OS << " __attribute__((thiscall))";
    637     break;
    638   case CC_X86Pascal:
    639     OS << " __attribute__((pascal))";
    640     break;
    641   case CC_AAPCS:
    642     OS << " __attribute__((pcs(\"aapcs\")))";
    643     break;
    644   case CC_AAPCS_VFP:
    645     OS << " __attribute__((pcs(\"aapcs-vfp\")))";
    646     break;
    647   case CC_PnaclCall:
    648     OS << " __attribute__((pnaclcall))";
    649     break;
    650   case CC_IntelOclBicc:
    651     OS << " __attribute__((intel_ocl_bicc))";
    652     break;
    653   }
    654   if (Info.getNoReturn())
    655     OS << " __attribute__((noreturn))";
    656   if (Info.getRegParm())
    657     OS << " __attribute__((regparm ("
    658        << Info.getRegParm() << ")))";
    659 
    660   if (unsigned quals = T->getTypeQuals()) {
    661     OS << ' ';
    662     AppendTypeQualList(OS, quals);
    663   }
    664 
    665   switch (T->getRefQualifier()) {
    666   case RQ_None:
    667     break;
    668 
    669   case RQ_LValue:
    670     OS << " &";
    671     break;
    672 
    673   case RQ_RValue:
    674     OS << " &&";
    675     break;
    676   }
    677   T->printExceptionSpecification(OS, Policy);
    678 
    679   if (T->hasTrailingReturn()) {
    680     OS << " -> ";
    681     print(T->getResultType(), OS, StringRef());
    682   } else
    683     printAfter(T->getResultType(), OS);
    684 }
    685 
    686 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
    687                                              raw_ostream &OS) {
    688   // If needed for precedence reasons, wrap the inner part in grouping parens.
    689   SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
    690   printBefore(T->getResultType(), OS);
    691   if (!PrevPHIsEmpty.get())
    692     OS << '(';
    693 }
    694 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
    695                                             raw_ostream &OS) {
    696   // If needed for precedence reasons, wrap the inner part in grouping parens.
    697   if (!HasEmptyPlaceHolder)
    698     OS << ')';
    699   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
    700 
    701   OS << "()";
    702   if (T->getNoReturnAttr())
    703     OS << " __attribute__((noreturn))";
    704   printAfter(T->getResultType(), OS);
    705 }
    706 
    707 void TypePrinter::printTypeSpec(const NamedDecl *D, raw_ostream &OS) {
    708   IdentifierInfo *II = D->getIdentifier();
    709   OS << II->getName();
    710   spaceBeforePlaceHolder(OS);
    711 }
    712 
    713 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
    714                                              raw_ostream &OS) {
    715   printTypeSpec(T->getDecl(), OS);
    716 }
    717 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
    718                                              raw_ostream &OS) { }
    719 
    720 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
    721   printTypeSpec(T->getDecl(), OS);
    722 }
    723 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) { }
    724 
    725 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
    726                                         raw_ostream &OS) {
    727   OS << "typeof ";
    728   T->getUnderlyingExpr()->printPretty(OS, 0, Policy);
    729   spaceBeforePlaceHolder(OS);
    730 }
    731 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
    732                                        raw_ostream &OS) { }
    733 
    734 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
    735   OS << "typeof(";
    736   print(T->getUnderlyingType(), OS, StringRef());
    737   OS << ')';
    738   spaceBeforePlaceHolder(OS);
    739 }
    740 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) { }
    741 
    742 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
    743   OS << "decltype(";
    744   T->getUnderlyingExpr()->printPretty(OS, 0, Policy);
    745   OS << ')';
    746   spaceBeforePlaceHolder(OS);
    747 }
    748 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) { }
    749 
    750 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
    751                                             raw_ostream &OS) {
    752   IncludeStrongLifetimeRAII Strong(Policy);
    753 
    754   switch (T->getUTTKind()) {
    755     case UnaryTransformType::EnumUnderlyingType:
    756       OS << "__underlying_type(";
    757       print(T->getBaseType(), OS, StringRef());
    758       OS << ')';
    759       spaceBeforePlaceHolder(OS);
    760       return;
    761   }
    762 
    763   printBefore(T->getBaseType(), OS);
    764 }
    765 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
    766                                            raw_ostream &OS) {
    767   IncludeStrongLifetimeRAII Strong(Policy);
    768 
    769   switch (T->getUTTKind()) {
    770     case UnaryTransformType::EnumUnderlyingType:
    771       return;
    772   }
    773 
    774   printAfter(T->getBaseType(), OS);
    775 }
    776 
    777 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
    778   // If the type has been deduced, do not print 'auto'.
    779   if (T->isDeduced()) {
    780     printBefore(T->getDeducedType(), OS);
    781   } else {
    782     OS << "auto";
    783     spaceBeforePlaceHolder(OS);
    784   }
    785 }
    786 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
    787   // If the type has been deduced, do not print 'auto'.
    788   if (T->isDeduced())
    789     printAfter(T->getDeducedType(), OS);
    790 }
    791 
    792 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
    793   IncludeStrongLifetimeRAII Strong(Policy);
    794 
    795   OS << "_Atomic(";
    796   print(T->getValueType(), OS, StringRef());
    797   OS << ')';
    798   spaceBeforePlaceHolder(OS);
    799 }
    800 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) { }
    801 
    802 /// Appends the given scope to the end of a string.
    803 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
    804   if (DC->isTranslationUnit()) return;
    805   if (DC->isFunctionOrMethod()) return;
    806   AppendScope(DC->getParent(), OS);
    807 
    808   if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) {
    809     if (Policy.SuppressUnwrittenScope &&
    810         (NS->isAnonymousNamespace() || NS->isInline()))
    811       return;
    812     if (NS->getIdentifier())
    813       OS << NS->getName() << "::";
    814     else
    815       OS << "<anonymous>::";
    816   } else if (ClassTemplateSpecializationDecl *Spec
    817                = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
    818     IncludeStrongLifetimeRAII Strong(Policy);
    819     OS << Spec->getIdentifier()->getName();
    820     const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
    821     TemplateSpecializationType::PrintTemplateArgumentList(OS,
    822                                             TemplateArgs.data(),
    823                                             TemplateArgs.size(),
    824                                             Policy);
    825     OS << "::";
    826   } else if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) {
    827     if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
    828       OS << Typedef->getIdentifier()->getName() << "::";
    829     else if (Tag->getIdentifier())
    830       OS << Tag->getIdentifier()->getName() << "::";
    831     else
    832       return;
    833   }
    834 }
    835 
    836 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
    837   if (Policy.SuppressTag)
    838     return;
    839 
    840   bool HasKindDecoration = false;
    841 
    842   // bool SuppressTagKeyword
    843   //   = Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword;
    844 
    845   // We don't print tags unless this is an elaborated type.
    846   // In C, we just assume every RecordType is an elaborated type.
    847   if (!(Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword ||
    848         D->getTypedefNameForAnonDecl())) {
    849     HasKindDecoration = true;
    850     OS << D->getKindName();
    851     OS << ' ';
    852   }
    853 
    854   // Compute the full nested-name-specifier for this type.
    855   // In C, this will always be empty except when the type
    856   // being printed is anonymous within other Record.
    857   if (!Policy.SuppressScope)
    858     AppendScope(D->getDeclContext(), OS);
    859 
    860   if (const IdentifierInfo *II = D->getIdentifier())
    861     OS << II->getName();
    862   else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
    863     assert(Typedef->getIdentifier() && "Typedef without identifier?");
    864     OS << Typedef->getIdentifier()->getName();
    865   } else {
    866     // Make an unambiguous representation for anonymous types, e.g.
    867     //   <anonymous enum at /usr/include/string.h:120:9>
    868 
    869     if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
    870       OS << "<lambda";
    871       HasKindDecoration = true;
    872     } else {
    873       OS << "<anonymous";
    874     }
    875 
    876     if (Policy.AnonymousTagLocations) {
    877       // Suppress the redundant tag keyword if we just printed one.
    878       // We don't have to worry about ElaboratedTypes here because you can't
    879       // refer to an anonymous type with one.
    880       if (!HasKindDecoration)
    881         OS << " " << D->getKindName();
    882 
    883       PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
    884           D->getLocation());
    885       if (PLoc.isValid()) {
    886         OS << " at " << PLoc.getFilename()
    887            << ':' << PLoc.getLine()
    888            << ':' << PLoc.getColumn();
    889       }
    890     }
    891 
    892     OS << '>';
    893   }
    894 
    895   // If this is a class template specialization, print the template
    896   // arguments.
    897   if (ClassTemplateSpecializationDecl *Spec
    898         = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
    899     const TemplateArgument *Args;
    900     unsigned NumArgs;
    901     if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
    902       const TemplateSpecializationType *TST =
    903         cast<TemplateSpecializationType>(TAW->getType());
    904       Args = TST->getArgs();
    905       NumArgs = TST->getNumArgs();
    906     } else {
    907       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
    908       Args = TemplateArgs.data();
    909       NumArgs = TemplateArgs.size();
    910     }
    911     IncludeStrongLifetimeRAII Strong(Policy);
    912     TemplateSpecializationType::PrintTemplateArgumentList(OS,
    913                                                           Args, NumArgs,
    914                                                           Policy);
    915   }
    916 
    917   spaceBeforePlaceHolder(OS);
    918 }
    919 
    920 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
    921   printTag(T->getDecl(), OS);
    922 }
    923 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) { }
    924 
    925 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
    926   printTag(T->getDecl(), OS);
    927 }
    928 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) { }
    929 
    930 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
    931                                               raw_ostream &OS) {
    932   if (IdentifierInfo *Id = T->getIdentifier())
    933     OS << Id->getName();
    934   else
    935     OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
    936   spaceBeforePlaceHolder(OS);
    937 }
    938 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
    939                                              raw_ostream &OS) { }
    940 
    941 void TypePrinter::printSubstTemplateTypeParmBefore(
    942                                              const SubstTemplateTypeParmType *T,
    943                                              raw_ostream &OS) {
    944   IncludeStrongLifetimeRAII Strong(Policy);
    945   printBefore(T->getReplacementType(), OS);
    946 }
    947 void TypePrinter::printSubstTemplateTypeParmAfter(
    948                                              const SubstTemplateTypeParmType *T,
    949                                              raw_ostream &OS) {
    950   IncludeStrongLifetimeRAII Strong(Policy);
    951   printAfter(T->getReplacementType(), OS);
    952 }
    953 
    954 void TypePrinter::printSubstTemplateTypeParmPackBefore(
    955                                         const SubstTemplateTypeParmPackType *T,
    956                                         raw_ostream &OS) {
    957   IncludeStrongLifetimeRAII Strong(Policy);
    958   printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
    959 }
    960 void TypePrinter::printSubstTemplateTypeParmPackAfter(
    961                                         const SubstTemplateTypeParmPackType *T,
    962                                         raw_ostream &OS) {
    963   IncludeStrongLifetimeRAII Strong(Policy);
    964   printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
    965 }
    966 
    967 void TypePrinter::printTemplateSpecializationBefore(
    968                                             const TemplateSpecializationType *T,
    969                                             raw_ostream &OS) {
    970   IncludeStrongLifetimeRAII Strong(Policy);
    971   T->getTemplateName().print(OS, Policy);
    972 
    973   TemplateSpecializationType::PrintTemplateArgumentList(OS,
    974                                                         T->getArgs(),
    975                                                         T->getNumArgs(),
    976                                                         Policy);
    977   spaceBeforePlaceHolder(OS);
    978 }
    979 void TypePrinter::printTemplateSpecializationAfter(
    980                                             const TemplateSpecializationType *T,
    981                                             raw_ostream &OS) { }
    982 
    983 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
    984                                                raw_ostream &OS) {
    985   printTemplateSpecializationBefore(T->getInjectedTST(), OS);
    986 }
    987 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
    988                                                raw_ostream &OS) { }
    989 
    990 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
    991                                         raw_ostream &OS) {
    992   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
    993   if (T->getKeyword() != ETK_None)
    994     OS << " ";
    995   NestedNameSpecifier* Qualifier = T->getQualifier();
    996   if (Qualifier)
    997     Qualifier->print(OS, Policy);
    998 
    999   ElaboratedTypePolicyRAII PolicyRAII(Policy);
   1000   printBefore(T->getNamedType(), OS);
   1001 }
   1002 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
   1003                                         raw_ostream &OS) {
   1004   ElaboratedTypePolicyRAII PolicyRAII(Policy);
   1005   printAfter(T->getNamedType(), OS);
   1006 }
   1007 
   1008 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
   1009   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
   1010     printBefore(T->getInnerType(), OS);
   1011     OS << '(';
   1012   } else
   1013     printBefore(T->getInnerType(), OS);
   1014 }
   1015 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
   1016   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
   1017     OS << ')';
   1018     printAfter(T->getInnerType(), OS);
   1019   } else
   1020     printAfter(T->getInnerType(), OS);
   1021 }
   1022 
   1023 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
   1024                                            raw_ostream &OS) {
   1025   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
   1026   if (T->getKeyword() != ETK_None)
   1027     OS << " ";
   1028 
   1029   T->getQualifier()->print(OS, Policy);
   1030 
   1031   OS << T->getIdentifier()->getName();
   1032   spaceBeforePlaceHolder(OS);
   1033 }
   1034 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
   1035                                           raw_ostream &OS) { }
   1036 
   1037 void TypePrinter::printDependentTemplateSpecializationBefore(
   1038         const DependentTemplateSpecializationType *T, raw_ostream &OS) {
   1039   IncludeStrongLifetimeRAII Strong(Policy);
   1040 
   1041   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
   1042   if (T->getKeyword() != ETK_None)
   1043     OS << " ";
   1044 
   1045   if (T->getQualifier())
   1046     T->getQualifier()->print(OS, Policy);
   1047   OS << T->getIdentifier()->getName();
   1048   TemplateSpecializationType::PrintTemplateArgumentList(OS,
   1049                                                         T->getArgs(),
   1050                                                         T->getNumArgs(),
   1051                                                         Policy);
   1052   spaceBeforePlaceHolder(OS);
   1053 }
   1054 void TypePrinter::printDependentTemplateSpecializationAfter(
   1055         const DependentTemplateSpecializationType *T, raw_ostream &OS) { }
   1056 
   1057 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
   1058                                            raw_ostream &OS) {
   1059   printBefore(T->getPattern(), OS);
   1060 }
   1061 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
   1062                                           raw_ostream &OS) {
   1063   printAfter(T->getPattern(), OS);
   1064   OS << "...";
   1065 }
   1066 
   1067 void TypePrinter::printAttributedBefore(const AttributedType *T,
   1068                                         raw_ostream &OS) {
   1069   // Prefer the macro forms of the GC and ownership qualifiers.
   1070   if (T->getAttrKind() == AttributedType::attr_objc_gc ||
   1071       T->getAttrKind() == AttributedType::attr_objc_ownership)
   1072     return printBefore(T->getEquivalentType(), OS);
   1073 
   1074   printBefore(T->getModifiedType(), OS);
   1075 }
   1076 
   1077 void TypePrinter::printAttributedAfter(const AttributedType *T,
   1078                                        raw_ostream &OS) {
   1079   // Prefer the macro forms of the GC and ownership qualifiers.
   1080   if (T->getAttrKind() == AttributedType::attr_objc_gc ||
   1081       T->getAttrKind() == AttributedType::attr_objc_ownership)
   1082     return printAfter(T->getEquivalentType(), OS);
   1083 
   1084   // TODO: not all attributes are GCC-style attributes.
   1085   OS << " __attribute__((";
   1086   switch (T->getAttrKind()) {
   1087   case AttributedType::attr_address_space:
   1088     OS << "address_space(";
   1089     OS << T->getEquivalentType().getAddressSpace();
   1090     OS << ')';
   1091     break;
   1092 
   1093   case AttributedType::attr_vector_size: {
   1094     OS << "__vector_size__(";
   1095     if (const VectorType *vector =T->getEquivalentType()->getAs<VectorType>()) {
   1096       OS << vector->getNumElements();
   1097       OS << " * sizeof(";
   1098       print(vector->getElementType(), OS, StringRef());
   1099       OS << ')';
   1100     }
   1101     OS << ')';
   1102     break;
   1103   }
   1104 
   1105   case AttributedType::attr_neon_vector_type:
   1106   case AttributedType::attr_neon_polyvector_type: {
   1107     if (T->getAttrKind() == AttributedType::attr_neon_vector_type)
   1108       OS << "neon_vector_type(";
   1109     else
   1110       OS << "neon_polyvector_type(";
   1111     const VectorType *vector = T->getEquivalentType()->getAs<VectorType>();
   1112     OS << vector->getNumElements();
   1113     OS << ')';
   1114     break;
   1115   }
   1116 
   1117   case AttributedType::attr_regparm: {
   1118     OS << "regparm(";
   1119     QualType t = T->getEquivalentType();
   1120     while (!t->isFunctionType())
   1121       t = t->getPointeeType();
   1122     OS << t->getAs<FunctionType>()->getRegParmType();
   1123     OS << ')';
   1124     break;
   1125   }
   1126 
   1127   case AttributedType::attr_objc_gc: {
   1128     OS << "objc_gc(";
   1129 
   1130     QualType tmp = T->getEquivalentType();
   1131     while (tmp.getObjCGCAttr() == Qualifiers::GCNone) {
   1132       QualType next = tmp->getPointeeType();
   1133       if (next == tmp) break;
   1134       tmp = next;
   1135     }
   1136 
   1137     if (tmp.isObjCGCWeak())
   1138       OS << "weak";
   1139     else
   1140       OS << "strong";
   1141     OS << ')';
   1142     break;
   1143   }
   1144 
   1145   case AttributedType::attr_objc_ownership:
   1146     OS << "objc_ownership(";
   1147     switch (T->getEquivalentType().getObjCLifetime()) {
   1148     case Qualifiers::OCL_None: llvm_unreachable("no ownership!");
   1149     case Qualifiers::OCL_ExplicitNone: OS << "none"; break;
   1150     case Qualifiers::OCL_Strong: OS << "strong"; break;
   1151     case Qualifiers::OCL_Weak: OS << "weak"; break;
   1152     case Qualifiers::OCL_Autoreleasing: OS << "autoreleasing"; break;
   1153     }
   1154     OS << ')';
   1155     break;
   1156 
   1157   case AttributedType::attr_noreturn: OS << "noreturn"; break;
   1158   case AttributedType::attr_cdecl: OS << "cdecl"; break;
   1159   case AttributedType::attr_fastcall: OS << "fastcall"; break;
   1160   case AttributedType::attr_stdcall: OS << "stdcall"; break;
   1161   case AttributedType::attr_thiscall: OS << "thiscall"; break;
   1162   case AttributedType::attr_pascal: OS << "pascal"; break;
   1163   case AttributedType::attr_pcs: {
   1164     OS << "pcs(";
   1165    QualType t = T->getEquivalentType();
   1166    while (!t->isFunctionType())
   1167      t = t->getPointeeType();
   1168    OS << (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ?
   1169          "\"aapcs\"" : "\"aapcs-vfp\"");
   1170    OS << ')';
   1171    break;
   1172   }
   1173   case AttributedType::attr_pnaclcall: OS << "pnaclcall"; break;
   1174   case AttributedType::attr_inteloclbicc: OS << "inteloclbicc"; break;
   1175   }
   1176   OS << "))";
   1177 }
   1178 
   1179 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
   1180                                            raw_ostream &OS) {
   1181   OS << T->getDecl()->getName();
   1182   spaceBeforePlaceHolder(OS);
   1183 }
   1184 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
   1185                                           raw_ostream &OS) { }
   1186 
   1187 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
   1188                                         raw_ostream &OS) {
   1189   if (T->qual_empty())
   1190     return printBefore(T->getBaseType(), OS);
   1191 
   1192   print(T->getBaseType(), OS, StringRef());
   1193   OS << '<';
   1194   bool isFirst = true;
   1195   for (ObjCObjectType::qual_iterator
   1196          I = T->qual_begin(), E = T->qual_end(); I != E; ++I) {
   1197     if (isFirst)
   1198       isFirst = false;
   1199     else
   1200       OS << ',';
   1201     OS << (*I)->getName();
   1202   }
   1203   OS << '>';
   1204   spaceBeforePlaceHolder(OS);
   1205 }
   1206 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
   1207                                         raw_ostream &OS) {
   1208   if (T->qual_empty())
   1209     return printAfter(T->getBaseType(), OS);
   1210 }
   1211 
   1212 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
   1213                                                raw_ostream &OS) {
   1214   T->getPointeeType().getLocalQualifiers().print(OS, Policy,
   1215                                                 /*appendSpaceIfNonEmpty=*/true);
   1216 
   1217   if (T->isObjCIdType() || T->isObjCQualifiedIdType())
   1218     OS << "id";
   1219   else if (T->isObjCClassType() || T->isObjCQualifiedClassType())
   1220     OS << "Class";
   1221   else if (T->isObjCSelType())
   1222     OS << "SEL";
   1223   else
   1224     OS << T->getInterfaceDecl()->getName();
   1225 
   1226   if (!T->qual_empty()) {
   1227     OS << '<';
   1228     for (ObjCObjectPointerType::qual_iterator I = T->qual_begin(),
   1229                                               E = T->qual_end();
   1230          I != E; ++I) {
   1231       OS << (*I)->getName();
   1232       if (I+1 != E)
   1233         OS << ',';
   1234     }
   1235     OS << '>';
   1236   }
   1237 
   1238   if (!T->isObjCIdType() && !T->isObjCQualifiedIdType()) {
   1239     OS << " *"; // Don't forget the implicit pointer.
   1240   } else {
   1241     spaceBeforePlaceHolder(OS);
   1242   }
   1243 }
   1244 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
   1245                                               raw_ostream &OS) { }
   1246 
   1247 void TemplateSpecializationType::
   1248   PrintTemplateArgumentList(raw_ostream &OS,
   1249                             const TemplateArgumentListInfo &Args,
   1250                             const PrintingPolicy &Policy) {
   1251   return PrintTemplateArgumentList(OS,
   1252                                    Args.getArgumentArray(),
   1253                                    Args.size(),
   1254                                    Policy);
   1255 }
   1256 
   1257 void
   1258 TemplateSpecializationType::PrintTemplateArgumentList(
   1259                                                 raw_ostream &OS,
   1260                                                 const TemplateArgument *Args,
   1261                                                 unsigned NumArgs,
   1262                                                   const PrintingPolicy &Policy,
   1263                                                       bool SkipBrackets) {
   1264   if (!SkipBrackets)
   1265     OS << '<';
   1266 
   1267   bool needSpace = false;
   1268   for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
   1269     if (Arg > 0)
   1270       OS << ", ";
   1271 
   1272     // Print the argument into a string.
   1273     SmallString<128> Buf;
   1274     llvm::raw_svector_ostream ArgOS(Buf);
   1275     if (Args[Arg].getKind() == TemplateArgument::Pack) {
   1276       PrintTemplateArgumentList(ArgOS,
   1277                                 Args[Arg].pack_begin(),
   1278                                 Args[Arg].pack_size(),
   1279                                 Policy, true);
   1280     } else {
   1281       Args[Arg].print(Policy, ArgOS);
   1282     }
   1283     StringRef ArgString = ArgOS.str();
   1284 
   1285     // If this is the first argument and its string representation
   1286     // begins with the global scope specifier ('::foo'), add a space
   1287     // to avoid printing the diagraph '<:'.
   1288     if (!Arg && !ArgString.empty() && ArgString[0] == ':')
   1289       OS << ' ';
   1290 
   1291     OS << ArgString;
   1292 
   1293     needSpace = (!ArgString.empty() && ArgString.back() == '>');
   1294   }
   1295 
   1296   // If the last character of our string is '>', add another space to
   1297   // keep the two '>''s separate tokens. We don't *have* to do this in
   1298   // C++0x, but it's still good hygiene.
   1299   if (needSpace)
   1300     OS << ' ';
   1301 
   1302   if (!SkipBrackets)
   1303     OS << '>';
   1304 }
   1305 
   1306 // Sadly, repeat all that with TemplateArgLoc.
   1307 void TemplateSpecializationType::
   1308 PrintTemplateArgumentList(raw_ostream &OS,
   1309                           const TemplateArgumentLoc *Args, unsigned NumArgs,
   1310                           const PrintingPolicy &Policy) {
   1311   OS << '<';
   1312 
   1313   bool needSpace = false;
   1314   for (unsigned Arg = 0; Arg < NumArgs; ++Arg) {
   1315     if (Arg > 0)
   1316       OS << ", ";
   1317 
   1318     // Print the argument into a string.
   1319     SmallString<128> Buf;
   1320     llvm::raw_svector_ostream ArgOS(Buf);
   1321     if (Args[Arg].getArgument().getKind() == TemplateArgument::Pack) {
   1322       PrintTemplateArgumentList(ArgOS,
   1323                                 Args[Arg].getArgument().pack_begin(),
   1324                                 Args[Arg].getArgument().pack_size(),
   1325                                 Policy, true);
   1326     } else {
   1327       Args[Arg].getArgument().print(Policy, ArgOS);
   1328     }
   1329     StringRef ArgString = ArgOS.str();
   1330 
   1331     // If this is the first argument and its string representation
   1332     // begins with the global scope specifier ('::foo'), add a space
   1333     // to avoid printing the diagraph '<:'.
   1334     if (!Arg && !ArgString.empty() && ArgString[0] == ':')
   1335       OS << ' ';
   1336 
   1337     OS << ArgString;
   1338 
   1339     needSpace = (!ArgString.empty() && ArgString.back() == '>');
   1340   }
   1341 
   1342   // If the last character of our string is '>', add another space to
   1343   // keep the two '>''s separate tokens. We don't *have* to do this in
   1344   // C++0x, but it's still good hygiene.
   1345   if (needSpace)
   1346     OS << ' ';
   1347 
   1348   OS << '>';
   1349 }
   1350 
   1351 void QualType::dump(const char *msg) const {
   1352   if (msg)
   1353     llvm::errs() << msg << ": ";
   1354   LangOptions LO;
   1355   print(llvm::errs(), PrintingPolicy(LO), "identifier");
   1356   llvm::errs() << '\n';
   1357 }
   1358 void QualType::dump() const {
   1359   dump(0);
   1360 }
   1361 
   1362 void Type::dump() const {
   1363   QualType(this, 0).dump();
   1364 }
   1365 
   1366 std::string Qualifiers::getAsString() const {
   1367   LangOptions LO;
   1368   return getAsString(PrintingPolicy(LO));
   1369 }
   1370 
   1371 // Appends qualifiers to the given string, separated by spaces.  Will
   1372 // prefix a space if the string is non-empty.  Will not append a final
   1373 // space.
   1374 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
   1375   SmallString<64> Buf;
   1376   llvm::raw_svector_ostream StrOS(Buf);
   1377   print(StrOS, Policy);
   1378   return StrOS.str();
   1379 }
   1380 
   1381 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
   1382   if (getCVRQualifiers())
   1383     return false;
   1384 
   1385   if (getAddressSpace())
   1386     return false;
   1387 
   1388   if (getObjCGCAttr())
   1389     return false;
   1390 
   1391   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
   1392     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
   1393       return false;
   1394 
   1395   return true;
   1396 }
   1397 
   1398 // Appends qualifiers to the given string, separated by spaces.  Will
   1399 // prefix a space if the string is non-empty.  Will not append a final
   1400 // space.
   1401 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
   1402                        bool appendSpaceIfNonEmpty) const {
   1403   bool addSpace = false;
   1404 
   1405   unsigned quals = getCVRQualifiers();
   1406   if (quals) {
   1407     AppendTypeQualList(OS, quals);
   1408     addSpace = true;
   1409   }
   1410   if (unsigned addrspace = getAddressSpace()) {
   1411     if (addSpace)
   1412       OS << ' ';
   1413     addSpace = true;
   1414     switch (addrspace) {
   1415       case LangAS::opencl_global:
   1416         OS << "__global";
   1417         break;
   1418       case LangAS::opencl_local:
   1419         OS << "__local";
   1420         break;
   1421       case LangAS::opencl_constant:
   1422         OS << "__constant";
   1423         break;
   1424       default:
   1425         OS << "__attribute__((address_space(";
   1426         OS << addrspace;
   1427         OS << ")))";
   1428     }
   1429   }
   1430   if (Qualifiers::GC gc = getObjCGCAttr()) {
   1431     if (addSpace)
   1432       OS << ' ';
   1433     addSpace = true;
   1434     if (gc == Qualifiers::Weak)
   1435       OS << "__weak";
   1436     else
   1437       OS << "__strong";
   1438   }
   1439   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
   1440     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
   1441       if (addSpace)
   1442         OS << ' ';
   1443       addSpace = true;
   1444     }
   1445 
   1446     switch (lifetime) {
   1447     case Qualifiers::OCL_None: llvm_unreachable("none but true");
   1448     case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
   1449     case Qualifiers::OCL_Strong:
   1450       if (!Policy.SuppressStrongLifetime)
   1451         OS << "__strong";
   1452       break;
   1453 
   1454     case Qualifiers::OCL_Weak: OS << "__weak"; break;
   1455     case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
   1456     }
   1457   }
   1458 
   1459   if (appendSpaceIfNonEmpty && addSpace)
   1460     OS << ' ';
   1461 }
   1462 
   1463 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
   1464   std::string S;
   1465   getAsStringInternal(S, Policy);
   1466   return S;
   1467 }
   1468 
   1469 std::string QualType::getAsString(const Type *ty, Qualifiers qs) {
   1470   std::string buffer;
   1471   LangOptions options;
   1472   getAsStringInternal(ty, qs, buffer, PrintingPolicy(options));
   1473   return buffer;
   1474 }
   1475 
   1476 void QualType::print(const Type *ty, Qualifiers qs,
   1477                      raw_ostream &OS, const PrintingPolicy &policy,
   1478                      const Twine &PlaceHolder) {
   1479   SmallString<128> PHBuf;
   1480   StringRef PH = PlaceHolder.toStringRef(PHBuf);
   1481 
   1482   TypePrinter(policy).print(ty, qs, OS, PH);
   1483 }
   1484 
   1485 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
   1486                                    std::string &buffer,
   1487                                    const PrintingPolicy &policy) {
   1488   SmallString<256> Buf;
   1489   llvm::raw_svector_ostream StrOS(Buf);
   1490   TypePrinter(policy).print(ty, qs, StrOS, buffer);
   1491   std::string str = StrOS.str();
   1492   buffer.swap(str);
   1493 }
   1494