contrib/llvm/tools/clang/lib/AST/TypePrinter.cpp

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