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