lib/AST/TypePrinter.cpp

   1 //===- TypePrinter.cpp - Pretty-Print Clang Types -------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This contains code to print types from Clang's type system.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/AST/PrettyPrinter.h"
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/Decl.h"
  16 #include "clang/AST/DeclBase.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclObjC.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/AST/Expr.h"
  21 #include "clang/AST/NestedNameSpecifier.h"
  22 #include "clang/AST/TemplateBase.h"
  23 #include "clang/AST/TemplateName.h"
  24 #include "clang/AST/Type.h"
  25 #include "clang/Basic/AddressSpaces.h"
  26 #include "clang/Basic/ExceptionSpecificationType.h"
  27 #include "clang/Basic/IdentifierTable.h"
  28 #include "clang/Basic/LLVM.h"
  29 #include "clang/Basic/LangOptions.h"
  30 #include "clang/Basic/SourceLocation.h"
  31 #include "clang/Basic/SourceManager.h"
  32 #include "clang/Basic/Specifiers.h"
  33 #include "llvm/ADT/ArrayRef.h"
  34 #include "llvm/ADT/SmallString.h"
  35 #include "llvm/ADT/StringRef.h"
  36 #include "llvm/ADT/Twine.h"
  37 #include "llvm/Support/Casting.h"
  38 #include "llvm/Support/Compiler.h"
  39 #include "llvm/Support/ErrorHandling.h"
  40 #include "llvm/Support/SaveAndRestore.h"
  41 #include "llvm/Support/raw_ostream.h"
  42 #include <cassert>
  43 #include <string>
  44
  45 using namespace clang;
  46
  47 namespace {
  48
  49   /// RAII object that enables printing of the ARC __strong lifetime
  50   /// qualifier.
  51   class IncludeStrongLifetimeRAII {
  52     PrintingPolicy &Policy;
  53     bool Old;
  54
  55   public:
  56     explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
  57         : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
  58         if (!Policy.SuppressLifetimeQualifiers)
  59           Policy.SuppressStrongLifetime = false;
  60     }
  61
  62     ~IncludeStrongLifetimeRAII() {
  63       Policy.SuppressStrongLifetime = Old;
  64     }
  65   };
  66
  67   class ParamPolicyRAII {
  68     PrintingPolicy &Policy;
  69     bool Old;
  70
  71   public:
  72     explicit ParamPolicyRAII(PrintingPolicy &Policy)
  73         : Policy(Policy), Old(Policy.SuppressSpecifiers) {
  74       Policy.SuppressSpecifiers = false;
  75     }
  76
  77     ~ParamPolicyRAII() {
  78       Policy.SuppressSpecifiers = Old;
  79     }
  80   };
  81
  82   class ElaboratedTypePolicyRAII {
  83     PrintingPolicy &Policy;
  84     bool SuppressTagKeyword;
  85     bool SuppressScope;
  86
  87   public:
  88     explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
  89       SuppressTagKeyword = Policy.SuppressTagKeyword;
  90       SuppressScope = Policy.SuppressScope;
  91       Policy.SuppressTagKeyword = true;
  92       Policy.SuppressScope = true;
  93     }
  94
  95     ~ElaboratedTypePolicyRAII() {
  96       Policy.SuppressTagKeyword = SuppressTagKeyword;
  97       Policy.SuppressScope = SuppressScope;
  98     }
  99   };
 100
 101   class TypePrinter {
 102     PrintingPolicy Policy;
 103     unsigned Indentation;
 104     bool HasEmptyPlaceHolder = false;
 105     bool InsideCCAttribute = false;
 106
 107   public:
 108     explicit TypePrinter(const PrintingPolicy &Policy, unsigned Indentation = 0)
 109         : Policy(Policy), Indentation(Indentation) {}
 110
 111     void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
 112                StringRef PlaceHolder);
 113     void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);
 114
 115     static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
 116     void spaceBeforePlaceHolder(raw_ostream &OS);
 117     void printTypeSpec(NamedDecl *D, raw_ostream &OS);
 118
 119     void printBefore(QualType T, raw_ostream &OS);
 120     void printAfter(QualType T, raw_ostream &OS);
 121     void AppendScope(DeclContext *DC, raw_ostream &OS);
 122     void printTag(TagDecl *T, raw_ostream &OS);
 123     void printFunctionAfter(const FunctionType::ExtInfo &Info, raw_ostream &OS);
 124 #define ABSTRACT_TYPE(CLASS, PARENT)
 125 #define TYPE(CLASS, PARENT) \
 126     void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \
 127     void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS);
 128 #include "clang/AST/TypeNodes.inc"
 129
 130   private:
 131     void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
 132     void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
 133   };
 134
 135 } // namespace
 136
 137 static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals,
 138                                bool HasRestrictKeyword) {
 139   bool appendSpace = false;
 140   if (TypeQuals & Qualifiers::Const) {
 141     OS << "const";
 142     appendSpace = true;
 143   }
 144   if (TypeQuals & Qualifiers::Volatile) {
 145     if (appendSpace) OS << ' ';
 146     OS << "volatile";
 147     appendSpace = true;
 148   }
 149   if (TypeQuals & Qualifiers::Restrict) {
 150     if (appendSpace) OS << ' ';
 151     if (HasRestrictKeyword) {
 152       OS << "restrict";
 153     } else {
 154       OS << "__restrict";
 155     }
 156   }
 157 }
 158
 159 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) {
 160   if (!HasEmptyPlaceHolder)
 161     OS << ' ';
 162 }
 163
 164 static SplitQualType splitAccordingToPolicy(QualType QT,
 165                                             const PrintingPolicy &Policy) {
 166   if (Policy.PrintCanonicalTypes)
 167     QT = QT.getCanonicalType();
 168   return QT.split();
 169 }
 170
 171 void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) {
 172   SplitQualType split = splitAccordingToPolicy(t, Policy);
 173   print(split.Ty, split.Quals, OS, PlaceHolder);
 174 }
 175
 176 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
 177                         StringRef PlaceHolder) {
 178   if (!T) {
 179     OS << "NULL TYPE";
 180     return;
 181   }
 182
 183   SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty());
 184
 185   printBefore(T, Quals, OS);
 186   OS << PlaceHolder;
 187   printAfter(T, Quals, OS);
 188 }
 189
 190 bool TypePrinter::canPrefixQualifiers(const Type *T,
 191                                       bool &NeedARCStrongQualifier) {
 192   // CanPrefixQualifiers - We prefer to print type qualifiers before the type,
 193   // so that we get "const int" instead of "int const", but we can't do this if
 194   // the type is complex.  For example if the type is "int*", we *must* print
 195   // "int * const", printing "const int *" is different.  Only do this when the
 196   // type expands to a simple string.
 197   bool CanPrefixQualifiers = false;
 198   NeedARCStrongQualifier = false;
 199   Type::TypeClass TC = T->getTypeClass();
 200   if (const auto *AT = dyn_cast<AutoType>(T))
 201     TC = AT->desugar()->getTypeClass();
 202   if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(T))
 203     TC = Subst->getReplacementType()->getTypeClass();
 204
 205   switch (TC) {
 206     case Type::Auto:
 207     case Type::Builtin:
 208     case Type::Complex:
 209     case Type::UnresolvedUsing:
 210     case Type::Typedef:
 211     case Type::TypeOfExpr:
 212     case Type::TypeOf:
 213     case Type::Decltype:
 214     case Type::UnaryTransform:
 215     case Type::Record:
 216     case Type::Enum:
 217     case Type::Elaborated:
 218     case Type::TemplateTypeParm:
 219     case Type::SubstTemplateTypeParmPack:
 220     case Type::DeducedTemplateSpecialization:
 221     case Type::TemplateSpecialization:
 222     case Type::InjectedClassName:
 223     case Type::DependentName:
 224     case Type::DependentTemplateSpecialization:
 225     case Type::ObjCObject:
 226     case Type::ObjCTypeParam:
 227     case Type::ObjCInterface:
 228     case Type::Atomic:
 229     case Type::Pipe:
 230       CanPrefixQualifiers = true;
 231       break;
 232
 233     case Type::ObjCObjectPointer:
 234       CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
 235         T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType();
 236       break;
 237
 238     case Type::ConstantArray:
 239     case Type::IncompleteArray:
 240     case Type::VariableArray:
 241     case Type::DependentSizedArray:
 242       NeedARCStrongQualifier = true;
 243       LLVM_FALLTHROUGH;
 244
 245     case Type::Adjusted:
 246     case Type::Decayed:
 247     case Type::Pointer:
 248     case Type::BlockPointer:
 249     case Type::LValueReference:
 250     case Type::RValueReference:
 251     case Type::MemberPointer:
 252     case Type::DependentAddressSpace:
 253     case Type::DependentVector:
 254     case Type::DependentSizedExtVector:
 255     case Type::Vector:
 256     case Type::ExtVector:
 257     case Type::FunctionProto:
 258     case Type::FunctionNoProto:
 259     case Type::Paren:
 260     case Type::PackExpansion:
 261     case Type::SubstTemplateTypeParm:
 262     case Type::MacroQualified:
 263       CanPrefixQualifiers = false;
 264       break;
 265
 266     case Type::Attributed: {
 267       // We still want to print the address_space before the type if it is an
 268       // address_space attribute.
 269       const auto *AttrTy = cast<AttributedType>(T);
 270       CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace;
 271     }
 272   }
 273
 274   return CanPrefixQualifiers;
 275 }
 276
 277 void TypePrinter::printBefore(QualType T, raw_ostream &OS) {
 278   SplitQualType Split = splitAccordingToPolicy(T, Policy);
 279
 280   // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2
 281   // at this level.
 282   Qualifiers Quals = Split.Quals;
 283   if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
 284     Quals -= QualType(Subst, 0).getQualifiers();
 285
 286   printBefore(Split.Ty, Quals, OS);
 287 }
 288
 289 /// Prints the part of the type string before an identifier, e.g. for
 290 /// "int foo[10]" it prints "int ".
 291 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
 292   if (Policy.SuppressSpecifiers && T->isSpecifierType())
 293     return;
 294
 295   SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder);
 296
 297   // Print qualifiers as appropriate.
 298
 299   bool CanPrefixQualifiers = false;
 300   bool NeedARCStrongQualifier = false;
 301   CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier);
 302
 303   if (CanPrefixQualifiers && !Quals.empty()) {
 304     if (NeedARCStrongQualifier) {
 305       IncludeStrongLifetimeRAII Strong(Policy);
 306       Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
 307     } else {
 308       Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true);
 309     }
 310   }
 311
 312   bool hasAfterQuals = false;
 313   if (!CanPrefixQualifiers && !Quals.empty()) {
 314     hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy);
 315     if (hasAfterQuals)
 316       HasEmptyPlaceHolder = false;
 317   }
 318
 319   switch (T->getTypeClass()) {
 320 #define ABSTRACT_TYPE(CLASS, PARENT)
 321 #define TYPE(CLASS, PARENT) case Type::CLASS: \
 322     print##CLASS##Before(cast<CLASS##Type>(T), OS); \
 323     break;
 324 #include "clang/AST/TypeNodes.inc"
 325   }
 326
 327   if (hasAfterQuals) {
 328     if (NeedARCStrongQualifier) {
 329       IncludeStrongLifetimeRAII Strong(Policy);
 330       Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
 331     } else {
 332       Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get());
 333     }
 334   }
 335 }
 336
 337 void TypePrinter::printAfter(QualType t, raw_ostream &OS) {
 338   SplitQualType split = splitAccordingToPolicy(t, Policy);
 339   printAfter(split.Ty, split.Quals, OS);
 340 }
 341
 342 /// Prints the part of the type string after an identifier, e.g. for
 343 /// "int foo[10]" it prints "[10]".
 344 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
 345   switch (T->getTypeClass()) {
 346 #define ABSTRACT_TYPE(CLASS, PARENT)
 347 #define TYPE(CLASS, PARENT) case Type::CLASS: \
 348     print##CLASS##After(cast<CLASS##Type>(T), OS); \
 349     break;
 350 #include "clang/AST/TypeNodes.inc"
 351   }
 352 }
 353
 354 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
 355   OS << T->getName(Policy);
 356   spaceBeforePlaceHolder(OS);
 357 }
 358
 359 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {}
 360
 361 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
 362   OS << "_Complex ";
 363   printBefore(T->getElementType(), OS);
 364 }
 365
 366 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
 367   printAfter(T->getElementType(), OS);
 368 }
 369
 370 void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) {
 371   IncludeStrongLifetimeRAII Strong(Policy);
 372   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 373   printBefore(T->getPointeeType(), OS);
 374   // Handle things like 'int (*A)[4];' correctly.
 375   // FIXME: this should include vectors, but vectors use attributes I guess.
 376   if (isa<ArrayType>(T->getPointeeType()))
 377     OS << '(';
 378   OS << '*';
 379 }
 380
 381 void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) {
 382   IncludeStrongLifetimeRAII Strong(Policy);
 383   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 384   // Handle things like 'int (*A)[4];' correctly.
 385   // FIXME: this should include vectors, but vectors use attributes I guess.
 386   if (isa<ArrayType>(T->getPointeeType()))
 387     OS << ')';
 388   printAfter(T->getPointeeType(), OS);
 389 }
 390
 391 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
 392                                           raw_ostream &OS) {
 393   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 394   printBefore(T->getPointeeType(), OS);
 395   OS << '^';
 396 }
 397
 398 void TypePrinter::printBlockPointerAfter(const BlockPointerType *T,
 399                                           raw_ostream &OS) {
 400   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 401   printAfter(T->getPointeeType(), OS);
 402 }
 403
 404 // When printing a reference, the referenced type might also be a reference.
 405 // If so, we want to skip that before printing the inner type.
 406 static QualType skipTopLevelReferences(QualType T) {
 407   if (auto *Ref = T->getAs<ReferenceType>())
 408     return skipTopLevelReferences(Ref->getPointeeTypeAsWritten());
 409   return T;
 410 }
 411
 412 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
 413                                              raw_ostream &OS) {
 414   IncludeStrongLifetimeRAII Strong(Policy);
 415   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 416   QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
 417   printBefore(Inner, OS);
 418   // Handle things like 'int (&A)[4];' correctly.
 419   // FIXME: this should include vectors, but vectors use attributes I guess.
 420   if (isa<ArrayType>(Inner))
 421     OS << '(';
 422   OS << '&';
 423 }
 424
 425 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
 426                                             raw_ostream &OS) {
 427   IncludeStrongLifetimeRAII Strong(Policy);
 428   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 429   QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
 430   // Handle things like 'int (&A)[4];' correctly.
 431   // FIXME: this should include vectors, but vectors use attributes I guess.
 432   if (isa<ArrayType>(Inner))
 433     OS << ')';
 434   printAfter(Inner, OS);
 435 }
 436
 437 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
 438                                              raw_ostream &OS) {
 439   IncludeStrongLifetimeRAII Strong(Policy);
 440   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 441   QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
 442   printBefore(Inner, OS);
 443   // Handle things like 'int (&&A)[4];' correctly.
 444   // FIXME: this should include vectors, but vectors use attributes I guess.
 445   if (isa<ArrayType>(Inner))
 446     OS << '(';
 447   OS << "&&";
 448 }
 449
 450 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
 451                                             raw_ostream &OS) {
 452   IncludeStrongLifetimeRAII Strong(Policy);
 453   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 454   QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten());
 455   // Handle things like 'int (&&A)[4];' correctly.
 456   // FIXME: this should include vectors, but vectors use attributes I guess.
 457   if (isa<ArrayType>(Inner))
 458     OS << ')';
 459   printAfter(Inner, OS);
 460 }
 461
 462 void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
 463                                            raw_ostream &OS) {
 464   IncludeStrongLifetimeRAII Strong(Policy);
 465   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 466   printBefore(T->getPointeeType(), OS);
 467   // Handle things like 'int (Cls::*A)[4];' correctly.
 468   // FIXME: this should include vectors, but vectors use attributes I guess.
 469   if (isa<ArrayType>(T->getPointeeType()))
 470     OS << '(';
 471
 472   PrintingPolicy InnerPolicy(Policy);
 473   InnerPolicy.IncludeTagDefinition = false;
 474   TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef());
 475
 476   OS << "::*";
 477 }
 478
 479 void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
 480                                           raw_ostream &OS) {
 481   IncludeStrongLifetimeRAII Strong(Policy);
 482   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 483   // Handle things like 'int (Cls::*A)[4];' correctly.
 484   // FIXME: this should include vectors, but vectors use attributes I guess.
 485   if (isa<ArrayType>(T->getPointeeType()))
 486     OS << ')';
 487   printAfter(T->getPointeeType(), OS);
 488 }
 489
 490 void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T,
 491                                            raw_ostream &OS) {
 492   IncludeStrongLifetimeRAII Strong(Policy);
 493   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 494   printBefore(T->getElementType(), OS);
 495 }
 496
 497 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
 498                                           raw_ostream &OS) {
 499   OS << '[';
 500   if (T->getIndexTypeQualifiers().hasQualifiers()) {
 501     AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(),
 502                        Policy.Restrict);
 503     OS << ' ';
 504   }
 505
 506   if (T->getSizeModifier() == ArrayType::Static)
 507     OS << "static ";
 508
 509   OS << T->getSize().getZExtValue() << ']';
 510   printAfter(T->getElementType(), OS);
 511 }
 512
 513 void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T,
 514                                              raw_ostream &OS) {
 515   IncludeStrongLifetimeRAII Strong(Policy);
 516   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 517   printBefore(T->getElementType(), OS);
 518 }
 519
 520 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
 521                                             raw_ostream &OS) {
 522   OS << "[]";
 523   printAfter(T->getElementType(), OS);
 524 }
 525
 526 void TypePrinter::printVariableArrayBefore(const VariableArrayType *T,
 527                                            raw_ostream &OS) {
 528   IncludeStrongLifetimeRAII Strong(Policy);
 529   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 530   printBefore(T->getElementType(), OS);
 531 }
 532
 533 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
 534                                           raw_ostream &OS) {
 535   OS << '[';
 536   if (T->getIndexTypeQualifiers().hasQualifiers()) {
 537     AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict);
 538     OS << ' ';
 539   }
 540
 541   if (T->getSizeModifier() == VariableArrayType::Static)
 542     OS << "static ";
 543   else if (T->getSizeModifier() == VariableArrayType::Star)
 544     OS << '*';
 545
 546   if (T->getSizeExpr())
 547     T->getSizeExpr()->printPretty(OS, nullptr, Policy);
 548   OS << ']';
 549
 550   printAfter(T->getElementType(), OS);
 551 }
 552
 553 void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) {
 554   // Print the adjusted representation, otherwise the adjustment will be
 555   // invisible.
 556   printBefore(T->getAdjustedType(), OS);
 557 }
 558
 559 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) {
 560   printAfter(T->getAdjustedType(), OS);
 561 }
 562
 563 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) {
 564   // Print as though it's a pointer.
 565   printAdjustedBefore(T, OS);
 566 }
 567
 568 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) {
 569   printAdjustedAfter(T, OS);
 570 }
 571
 572 void TypePrinter::printDependentSizedArrayBefore(
 573                                                const DependentSizedArrayType *T,
 574                                                raw_ostream &OS) {
 575   IncludeStrongLifetimeRAII Strong(Policy);
 576   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 577   printBefore(T->getElementType(), OS);
 578 }
 579
 580 void TypePrinter::printDependentSizedArrayAfter(
 581                                                const DependentSizedArrayType *T,
 582                                                raw_ostream &OS) {
 583   OS << '[';
 584   if (T->getSizeExpr())
 585     T->getSizeExpr()->printPretty(OS, nullptr, Policy);
 586   OS << ']';
 587   printAfter(T->getElementType(), OS);
 588 }
 589
 590 void TypePrinter::printDependentAddressSpaceBefore(
 591     const DependentAddressSpaceType *T, raw_ostream &OS) {
 592   printBefore(T->getPointeeType(), OS);
 593 }
 594
 595 void TypePrinter::printDependentAddressSpaceAfter(
 596     const DependentAddressSpaceType *T, raw_ostream &OS) {
 597   OS << " __attribute__((address_space(";
 598   if (T->getAddrSpaceExpr())
 599     T->getAddrSpaceExpr()->printPretty(OS, nullptr, Policy);
 600   OS << ")))";
 601   printAfter(T->getPointeeType(), OS);
 602 }
 603
 604 void TypePrinter::printDependentSizedExtVectorBefore(
 605                                           const DependentSizedExtVectorType *T,
 606                                           raw_ostream &OS) {
 607   printBefore(T->getElementType(), OS);
 608 }
 609
 610 void TypePrinter::printDependentSizedExtVectorAfter(
 611                                           const DependentSizedExtVectorType *T,
 612                                           raw_ostream &OS) {
 613   OS << " __attribute__((ext_vector_type(";
 614   if (T->getSizeExpr())
 615     T->getSizeExpr()->printPretty(OS, nullptr, Policy);
 616   OS << ")))";
 617   printAfter(T->getElementType(), OS);
 618 }
 619
 620 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
 621   switch (T->getVectorKind()) {
 622   case VectorType::AltiVecPixel:
 623     OS << "__vector __pixel ";
 624     break;
 625   case VectorType::AltiVecBool:
 626     OS << "__vector __bool ";
 627     printBefore(T->getElementType(), OS);
 628     break;
 629   case VectorType::AltiVecVector:
 630     OS << "__vector ";
 631     printBefore(T->getElementType(), OS);
 632     break;
 633   case VectorType::NeonVector:
 634     OS << "__attribute__((neon_vector_type("
 635        << T->getNumElements() << "))) ";
 636     printBefore(T->getElementType(), OS);
 637     break;
 638   case VectorType::NeonPolyVector:
 639     OS << "__attribute__((neon_polyvector_type(" <<
 640           T->getNumElements() << "))) ";
 641     printBefore(T->getElementType(), OS);
 642     break;
 643   case VectorType::GenericVector: {
 644     // FIXME: We prefer to print the size directly here, but have no way
 645     // to get the size of the type.
 646     OS << "__attribute__((__vector_size__("
 647        << T->getNumElements()
 648        << " * sizeof(";
 649     print(T->getElementType(), OS, StringRef());
 650     OS << ")))) ";
 651     printBefore(T->getElementType(), OS);
 652     break;
 653   }
 654   }
 655 }
 656
 657 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
 658   printAfter(T->getElementType(), OS);
 659 }
 660
 661 void TypePrinter::printDependentVectorBefore(
 662     const DependentVectorType *T, raw_ostream &OS) {
 663   switch (T->getVectorKind()) {
 664   case VectorType::AltiVecPixel:
 665     OS << "__vector __pixel ";
 666     break;
 667   case VectorType::AltiVecBool:
 668     OS << "__vector __bool ";
 669     printBefore(T->getElementType(), OS);
 670     break;
 671   case VectorType::AltiVecVector:
 672     OS << "__vector ";
 673     printBefore(T->getElementType(), OS);
 674     break;
 675   case VectorType::NeonVector:
 676     OS << "__attribute__((neon_vector_type(";
 677     if (T->getSizeExpr())
 678       T->getSizeExpr()->printPretty(OS, nullptr, Policy);
 679     OS << "))) ";
 680     printBefore(T->getElementType(), OS);
 681     break;
 682   case VectorType::NeonPolyVector:
 683     OS << "__attribute__((neon_polyvector_type(";
 684     if (T->getSizeExpr())
 685       T->getSizeExpr()->printPretty(OS, nullptr, Policy);
 686     OS << "))) ";
 687     printBefore(T->getElementType(), OS);
 688     break;
 689   case VectorType::GenericVector: {
 690     // FIXME: We prefer to print the size directly here, but have no way
 691     // to get the size of the type.
 692     OS << "__attribute__((__vector_size__(";
 693     if (T->getSizeExpr())
 694       T->getSizeExpr()->printPretty(OS, nullptr, Policy);
 695     OS << " * sizeof(";
 696     print(T->getElementType(), OS, StringRef());
 697     OS << ")))) ";
 698     printBefore(T->getElementType(), OS);
 699     break;
 700   }
 701   }
 702 }
 703
 704 void TypePrinter::printDependentVectorAfter(
 705     const DependentVectorType *T, raw_ostream &OS) {
 706   printAfter(T->getElementType(), OS);
 707 }
 708
 709 void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
 710                                        raw_ostream &OS) {
 711   printBefore(T->getElementType(), OS);
 712 }
 713
 714 void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) {
 715   printAfter(T->getElementType(), OS);
 716   OS << " __attribute__((ext_vector_type(";
 717   OS << T->getNumElements();
 718   OS << ")))";
 719 }
 720
 721 void
 722 FunctionProtoType::printExceptionSpecification(raw_ostream &OS,
 723                                                const PrintingPolicy &Policy)
 724                                                                          const {
 725   if (hasDynamicExceptionSpec()) {
 726     OS << " throw(";
 727     if (getExceptionSpecType() == EST_MSAny)
 728       OS << "...";
 729     else
 730       for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) {
 731         if (I)
 732           OS << ", ";
 733
 734         OS << getExceptionType(I).stream(Policy);
 735       }
 736     OS << ')';
 737   } else if (EST_NoThrow == getExceptionSpecType()) {
 738     OS << " __attribute__((nothrow))";
 739   } else if (isNoexceptExceptionSpec(getExceptionSpecType())) {
 740     OS << " noexcept";
 741     // FIXME:Is it useful to print out the expression for a non-dependent
 742     // noexcept specification?
 743     if (isComputedNoexcept(getExceptionSpecType())) {
 744       OS << '(';
 745       if (getNoexceptExpr())
 746         getNoexceptExpr()->printPretty(OS, nullptr, Policy);
 747       OS << ')';
 748     }
 749   }
 750 }
 751
 752 void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T,
 753                                            raw_ostream &OS) {
 754   if (T->hasTrailingReturn()) {
 755     OS << "auto ";
 756     if (!HasEmptyPlaceHolder)
 757       OS << '(';
 758   } else {
 759     // If needed for precedence reasons, wrap the inner part in grouping parens.
 760     SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
 761     printBefore(T->getReturnType(), OS);
 762     if (!PrevPHIsEmpty.get())
 763       OS << '(';
 764   }
 765 }
 766
 767 StringRef clang::getParameterABISpelling(ParameterABI ABI) {
 768   switch (ABI) {
 769   case ParameterABI::Ordinary:
 770     llvm_unreachable("asking for spelling of ordinary parameter ABI");
 771   case ParameterABI::SwiftContext:
 772     return "swift_context";
 773   case ParameterABI::SwiftErrorResult:
 774     return "swift_error_result";
 775   case ParameterABI::SwiftIndirectResult:
 776     return "swift_indirect_result";
 777   }
 778   llvm_unreachable("bad parameter ABI kind");
 779 }
 780
 781 void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
 782                                           raw_ostream &OS) {
 783   // If needed for precedence reasons, wrap the inner part in grouping parens.
 784   if (!HasEmptyPlaceHolder)
 785     OS << ')';
 786   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 787
 788   OS << '(';
 789   {
 790     ParamPolicyRAII ParamPolicy(Policy);
 791     for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) {
 792       if (i) OS << ", ";
 793
 794       auto EPI = T->getExtParameterInfo(i);
 795       if (EPI.isConsumed()) OS << "__attribute__((ns_consumed)) ";
 796       if (EPI.isNoEscape())
 797         OS << "__attribute__((noescape)) ";
 798       auto ABI = EPI.getABI();
 799       if (ABI != ParameterABI::Ordinary)
 800         OS << "__attribute__((" << getParameterABISpelling(ABI) << ")) ";
 801
 802       print(T->getParamType(i), OS, StringRef());
 803     }
 804   }
 805
 806   if (T->isVariadic()) {
 807     if (T->getNumParams())
 808       OS << ", ";
 809     OS << "...";
 810   } else if (T->getNumParams() == 0 && Policy.UseVoidForZeroParams) {
 811     // Do not emit int() if we have a proto, emit 'int(void)'.
 812     OS << "void";
 813   }
 814
 815   OS << ')';
 816
 817   FunctionType::ExtInfo Info = T->getExtInfo();
 818
 819   printFunctionAfter(Info, OS);
 820
 821   if (!T->getMethodQuals().empty())
 822     OS << " " << T->getMethodQuals().getAsString();
 823
 824   switch (T->getRefQualifier()) {
 825   case RQ_None:
 826     break;
 827
 828   case RQ_LValue:
 829     OS << " &";
 830     break;
 831
 832   case RQ_RValue:
 833     OS << " &&";
 834     break;
 835   }
 836   T->printExceptionSpecification(OS, Policy);
 837
 838   if (T->hasTrailingReturn()) {
 839     OS << " -> ";
 840     print(T->getReturnType(), OS, StringRef());
 841   } else
 842     printAfter(T->getReturnType(), OS);
 843 }
 844
 845 void TypePrinter::printFunctionAfter(const FunctionType::ExtInfo &Info,
 846                                      raw_ostream &OS) {
 847   if (!InsideCCAttribute) {
 848     switch (Info.getCC()) {
 849     case CC_C:
 850       // The C calling convention is the default on the vast majority of platforms
 851       // we support.  If the user wrote it explicitly, it will usually be printed
 852       // while traversing the AttributedType.  If the type has been desugared, let
 853       // the canonical spelling be the implicit calling convention.
 854       // FIXME: It would be better to be explicit in certain contexts, such as a
 855       // cdecl function typedef used to declare a member function with the
 856       // Microsoft C++ ABI.
 857       break;
 858     case CC_X86StdCall:
 859       OS << " __attribute__((stdcall))";
 860       break;
 861     case CC_X86FastCall:
 862       OS << " __attribute__((fastcall))";
 863       break;
 864     case CC_X86ThisCall:
 865       OS << " __attribute__((thiscall))";
 866       break;
 867     case CC_X86VectorCall:
 868       OS << " __attribute__((vectorcall))";
 869       break;
 870     case CC_X86Pascal:
 871       OS << " __attribute__((pascal))";
 872       break;
 873     case CC_AAPCS:
 874       OS << " __attribute__((pcs(\"aapcs\")))";
 875       break;
 876     case CC_AAPCS_VFP:
 877       OS << " __attribute__((pcs(\"aapcs-vfp\")))";
 878       break;
 879     case CC_AArch64VectorCall:
 880       OS << "__attribute__((aarch64_vector_pcs))";
 881       break;
 882     case CC_IntelOclBicc:
 883       OS << " __attribute__((intel_ocl_bicc))";
 884       break;
 885     case CC_Win64:
 886       OS << " __attribute__((ms_abi))";
 887       break;
 888     case CC_X86_64SysV:
 889       OS << " __attribute__((sysv_abi))";
 890       break;
 891     case CC_X86RegCall:
 892       OS << " __attribute__((regcall))";
 893       break;
 894     case CC_SpirFunction:
 895     case CC_OpenCLKernel:
 896       // Do nothing. These CCs are not available as attributes.
 897       break;
 898     case CC_Swift:
 899       OS << " __attribute__((swiftcall))";
 900       break;
 901     case CC_PreserveMost:
 902       OS << " __attribute__((preserve_most))";
 903       break;
 904     case CC_PreserveAll:
 905       OS << " __attribute__((preserve_all))";
 906       break;
 907     }
 908   }
 909
 910   if (Info.getNoReturn())
 911     OS << " __attribute__((noreturn))";
 912   if (Info.getProducesResult())
 913     OS << " __attribute__((ns_returns_retained))";
 914   if (Info.getRegParm())
 915     OS << " __attribute__((regparm ("
 916        << Info.getRegParm() << ")))";
 917   if (Info.getNoCallerSavedRegs())
 918     OS << " __attribute__((no_caller_saved_registers))";
 919   if (Info.getNoCfCheck())
 920     OS << " __attribute__((nocf_check))";
 921 }
 922
 923 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
 924                                              raw_ostream &OS) {
 925   // If needed for precedence reasons, wrap the inner part in grouping parens.
 926   SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
 927   printBefore(T->getReturnType(), OS);
 928   if (!PrevPHIsEmpty.get())
 929     OS << '(';
 930 }
 931
 932 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
 933                                             raw_ostream &OS) {
 934   // If needed for precedence reasons, wrap the inner part in grouping parens.
 935   if (!HasEmptyPlaceHolder)
 936     OS << ')';
 937   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
 938
 939   OS << "()";
 940   printFunctionAfter(T->getExtInfo(), OS);
 941   printAfter(T->getReturnType(), OS);
 942 }
 943
 944 void TypePrinter::printTypeSpec(NamedDecl *D, raw_ostream &OS) {
 945
 946   // Compute the full nested-name-specifier for this type.
 947   // In C, this will always be empty except when the type
 948   // being printed is anonymous within other Record.
 949   if (!Policy.SuppressScope)
 950     AppendScope(D->getDeclContext(), OS);
 951
 952   IdentifierInfo *II = D->getIdentifier();
 953   OS << II->getName();
 954   spaceBeforePlaceHolder(OS);
 955 }
 956
 957 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
 958                                              raw_ostream &OS) {
 959   printTypeSpec(T->getDecl(), OS);
 960 }
 961
 962 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
 963                                             raw_ostream &OS) {}
 964
 965 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
 966   printTypeSpec(T->getDecl(), OS);
 967 }
 968
 969 void TypePrinter::printMacroQualifiedBefore(const MacroQualifiedType *T,
 970                                             raw_ostream &OS) {
 971   StringRef MacroName = T->getMacroIdentifier()->getName();
 972   OS << MacroName << " ";
 973
 974   // Since this type is meant to print the macro instead of the whole attribute,
 975   // we trim any attributes and go directly to the original modified type.
 976   printBefore(T->getModifiedType(), OS);
 977 }
 978
 979 void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T,
 980                                            raw_ostream &OS) {
 981   printAfter(T->getModifiedType(), OS);
 982 }
 983
 984 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {}
 985
 986 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
 987                                         raw_ostream &OS) {
 988   OS << "typeof ";
 989   if (T->getUnderlyingExpr())
 990     T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
 991   spaceBeforePlaceHolder(OS);
 992 }
 993
 994 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
 995                                        raw_ostream &OS) {}
 996
 997 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
 998   OS << "typeof(";
 999   print(T->getUnderlyingType(), OS, StringRef());
1000   OS << ')';
1001   spaceBeforePlaceHolder(OS);
1002 }
1003
1004 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {}
1005
1006 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
1007   OS << "decltype(";
1008   if (T->getUnderlyingExpr())
1009     T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
1010   OS << ')';
1011   spaceBeforePlaceHolder(OS);
1012 }
1013
1014 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
1015
1016 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
1017                                             raw_ostream &OS) {
1018   IncludeStrongLifetimeRAII Strong(Policy);
1019
1020   switch (T->getUTTKind()) {
1021     case UnaryTransformType::EnumUnderlyingType:
1022       OS << "__underlying_type(";
1023       print(T->getBaseType(), OS, StringRef());
1024       OS << ')';
1025       spaceBeforePlaceHolder(OS);
1026       return;
1027   }
1028
1029   printBefore(T->getBaseType(), OS);
1030 }
1031
1032 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
1033                                            raw_ostream &OS) {
1034   IncludeStrongLifetimeRAII Strong(Policy);
1035
1036   switch (T->getUTTKind()) {
1037     case UnaryTransformType::EnumUnderlyingType:
1038       return;
1039   }
1040
1041   printAfter(T->getBaseType(), OS);
1042 }
1043
1044 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
1045   // If the type has been deduced, do not print 'auto'.
1046   if (!T->getDeducedType().isNull()) {
1047     printBefore(T->getDeducedType(), OS);
1048   } else {
1049     switch (T->getKeyword()) {
1050     case AutoTypeKeyword::Auto: OS << "auto"; break;
1051     case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break;
1052     case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break;
1053     }
1054     spaceBeforePlaceHolder(OS);
1055   }
1056 }
1057
1058 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
1059   // If the type has been deduced, do not print 'auto'.
1060   if (!T->getDeducedType().isNull())
1061     printAfter(T->getDeducedType(), OS);
1062 }
1063
1064 void TypePrinter::printDeducedTemplateSpecializationBefore(
1065     const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
1066   // If the type has been deduced, print the deduced type.
1067   if (!T->getDeducedType().isNull()) {
1068     printBefore(T->getDeducedType(), OS);
1069   } else {
1070     IncludeStrongLifetimeRAII Strong(Policy);
1071     T->getTemplateName().print(OS, Policy);
1072     spaceBeforePlaceHolder(OS);
1073   }
1074 }
1075
1076 void TypePrinter::printDeducedTemplateSpecializationAfter(
1077     const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
1078   // If the type has been deduced, print the deduced type.
1079   if (!T->getDeducedType().isNull())
1080     printAfter(T->getDeducedType(), OS);
1081 }
1082
1083 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
1084   IncludeStrongLifetimeRAII Strong(Policy);
1085
1086   OS << "_Atomic(";
1087   print(T->getValueType(), OS, StringRef());
1088   OS << ')';
1089   spaceBeforePlaceHolder(OS);
1090 }
1091
1092 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {}
1093
1094 void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) {
1095   IncludeStrongLifetimeRAII Strong(Policy);
1096
1097   if (T->isReadOnly())
1098     OS << "read_only ";
1099   else
1100     OS << "write_only ";
1101   OS << "pipe ";
1102   print(T->getElementType(), OS, StringRef());
1103   spaceBeforePlaceHolder(OS);
1104 }
1105
1106 void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {}
1107
1108 /// Appends the given scope to the end of a string.
1109 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) {
1110   if (DC->isTranslationUnit()) return;
1111   if (DC->isFunctionOrMethod()) return;
1112   AppendScope(DC->getParent(), OS);
1113
1114   if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
1115     if (Policy.SuppressUnwrittenScope &&
1116         (NS->isAnonymousNamespace() || NS->isInline()))
1117       return;
1118     if (NS->getIdentifier())
1119       OS << NS->getName() << "::";
1120     else
1121       OS << "(anonymous namespace)::";
1122   } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1123     IncludeStrongLifetimeRAII Strong(Policy);
1124     OS << Spec->getIdentifier()->getName();
1125     const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1126     printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy);
1127     OS << "::";
1128   } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) {
1129     if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
1130       OS << Typedef->getIdentifier()->getName() << "::";
1131     else if (Tag->getIdentifier())
1132       OS << Tag->getIdentifier()->getName() << "::";
1133     else
1134       return;
1135   }
1136 }
1137
1138 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) {
1139   if (Policy.IncludeTagDefinition) {
1140     PrintingPolicy SubPolicy = Policy;
1141     SubPolicy.IncludeTagDefinition = false;
1142     D->print(OS, SubPolicy, Indentation);
1143     spaceBeforePlaceHolder(OS);
1144     return;
1145   }
1146
1147   bool HasKindDecoration = false;
1148
1149   // We don't print tags unless this is an elaborated type.
1150   // In C, we just assume every RecordType is an elaborated type.
1151   if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) {
1152     HasKindDecoration = true;
1153     OS << D->getKindName();
1154     OS << ' ';
1155   }
1156
1157   // Compute the full nested-name-specifier for this type.
1158   // In C, this will always be empty except when the type
1159   // being printed is anonymous within other Record.
1160   if (!Policy.SuppressScope)
1161     AppendScope(D->getDeclContext(), OS);
1162
1163   if (const IdentifierInfo *II = D->getIdentifier())
1164     OS << II->getName();
1165   else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
1166     assert(Typedef->getIdentifier() && "Typedef without identifier?");
1167     OS << Typedef->getIdentifier()->getName();
1168   } else {
1169     // Make an unambiguous representation for anonymous types, e.g.
1170     //   (anonymous enum at /usr/include/string.h:120:9)
1171     OS << (Policy.MSVCFormatting ? '`' : '(');
1172
1173     if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
1174       OS << "lambda";
1175       HasKindDecoration = true;
1176     } else {
1177       OS << "anonymous";
1178     }
1179
1180     if (Policy.AnonymousTagLocations) {
1181       // Suppress the redundant tag keyword if we just printed one.
1182       // We don't have to worry about ElaboratedTypes here because you can't
1183       // refer to an anonymous type with one.
1184       if (!HasKindDecoration)
1185         OS << " " << D->getKindName();
1186
1187       PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc(
1188           D->getLocation());
1189       if (PLoc.isValid()) {
1190         OS << " at ";
1191         StringRef File = PLoc.getFilename();
1192         if (Policy.RemapFilePaths)
1193           OS << Policy.remapPath(File);
1194         else
1195           OS << File;
1196         OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
1197       }
1198     }
1199
1200     OS << (Policy.MSVCFormatting ? '\'' : ')');
1201   }
1202
1203   // If this is a class template specialization, print the template
1204   // arguments.
1205   if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
1206     ArrayRef<TemplateArgument> Args;
1207     TypeSourceInfo *TAW = Spec->getTypeAsWritten();
1208     if (!Policy.PrintCanonicalTypes && TAW) {
1209       const TemplateSpecializationType *TST =
1210         cast<TemplateSpecializationType>(TAW->getType());
1211       Args = TST->template_arguments();
1212     } else {
1213       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1214       Args = TemplateArgs.asArray();
1215     }
1216     IncludeStrongLifetimeRAII Strong(Policy);
1217     printTemplateArgumentList(OS, Args, Policy);
1218   }
1219
1220   spaceBeforePlaceHolder(OS);
1221 }
1222
1223 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
1224   printTag(T->getDecl(), OS);
1225 }
1226
1227 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}
1228
1229 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
1230   printTag(T->getDecl(), OS);
1231 }
1232
1233 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}
1234
1235 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
1236                                               raw_ostream &OS) {
1237   if (IdentifierInfo *Id = T->getIdentifier())
1238     OS << Id->getName();
1239   else {
1240     bool IsLambdaAutoParam = false;
1241     if (auto D = T->getDecl()) {
1242       if (auto M = dyn_cast_or_null<CXXMethodDecl>(D->getDeclContext()))
1243         IsLambdaAutoParam = D->isImplicit() && M->getParent()->isLambda();
1244     }
1245
1246     if (IsLambdaAutoParam)
1247       OS << "auto";
1248     else
1249       OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
1250   }
1251   spaceBeforePlaceHolder(OS);
1252 }
1253
1254 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
1255                                              raw_ostream &OS) {}
1256
1257 void TypePrinter::printSubstTemplateTypeParmBefore(
1258                                              const SubstTemplateTypeParmType *T,
1259                                              raw_ostream &OS) {
1260   IncludeStrongLifetimeRAII Strong(Policy);
1261   printBefore(T->getReplacementType(), OS);
1262 }
1263
1264 void TypePrinter::printSubstTemplateTypeParmAfter(
1265                                              const SubstTemplateTypeParmType *T,
1266                                              raw_ostream &OS) {
1267   IncludeStrongLifetimeRAII Strong(Policy);
1268   printAfter(T->getReplacementType(), OS);
1269 }
1270
1271 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1272                                         const SubstTemplateTypeParmPackType *T,
1273                                         raw_ostream &OS) {
1274   IncludeStrongLifetimeRAII Strong(Policy);
1275   printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1276 }
1277
1278 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1279                                         const SubstTemplateTypeParmPackType *T,
1280                                         raw_ostream &OS) {
1281   IncludeStrongLifetimeRAII Strong(Policy);
1282   printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1283 }
1284
1285 void TypePrinter::printTemplateSpecializationBefore(
1286                                             const TemplateSpecializationType *T,
1287                                             raw_ostream &OS) {
1288   IncludeStrongLifetimeRAII Strong(Policy);
1289   T->getTemplateName().print(OS, Policy);
1290
1291   printTemplateArgumentList(OS, T->template_arguments(), Policy);
1292   spaceBeforePlaceHolder(OS);
1293 }
1294
1295 void TypePrinter::printTemplateSpecializationAfter(
1296                                             const TemplateSpecializationType *T,
1297                                             raw_ostream &OS) {}
1298
1299 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1300                                                raw_ostream &OS) {
1301   printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1302 }
1303
1304 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1305                                                raw_ostream &OS) {}
1306
1307 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
1308                                         raw_ostream &OS) {
1309   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
1310     TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
1311     assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() &&
1312            "OwnedTagDecl expected to be a declaration for the type");
1313     PrintingPolicy SubPolicy = Policy;
1314     SubPolicy.IncludeTagDefinition = false;
1315     OwnedTagDecl->print(OS, SubPolicy, Indentation);
1316     spaceBeforePlaceHolder(OS);
1317     return;
1318   }
1319
1320   // The tag definition will take care of these.
1321   if (!Policy.IncludeTagDefinition)
1322   {
1323     OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1324     if (T->getKeyword() != ETK_None)
1325       OS << " ";
1326     NestedNameSpecifier *Qualifier = T->getQualifier();
1327     if (Qualifier)
1328       Qualifier->print(OS, Policy);
1329   }
1330
1331   ElaboratedTypePolicyRAII PolicyRAII(Policy);
1332   printBefore(T->getNamedType(), OS);
1333 }
1334
1335 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
1336                                         raw_ostream &OS) {
1337   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
1338     return;
1339   ElaboratedTypePolicyRAII PolicyRAII(Policy);
1340   printAfter(T->getNamedType(), OS);
1341 }
1342
1343 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
1344   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1345     printBefore(T->getInnerType(), OS);
1346     OS << '(';
1347   } else
1348     printBefore(T->getInnerType(), OS);
1349 }
1350
1351 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
1352   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1353     OS << ')';
1354     printAfter(T->getInnerType(), OS);
1355   } else
1356     printAfter(T->getInnerType(), OS);
1357 }
1358
1359 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1360                                            raw_ostream &OS) {
1361   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1362   if (T->getKeyword() != ETK_None)
1363     OS << " ";
1364
1365   T->getQualifier()->print(OS, Policy);
1366
1367   OS << T->getIdentifier()->getName();
1368   spaceBeforePlaceHolder(OS);
1369 }
1370
1371 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1372                                           raw_ostream &OS) {}
1373
1374 void TypePrinter::printDependentTemplateSpecializationBefore(
1375         const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1376   IncludeStrongLifetimeRAII Strong(Policy);
1377
1378   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1379   if (T->getKeyword() != ETK_None)
1380     OS << " ";
1381
1382   if (T->getQualifier())
1383     T->getQualifier()->print(OS, Policy);
1384   OS << T->getIdentifier()->getName();
1385   printTemplateArgumentList(OS, T->template_arguments(), Policy);
1386   spaceBeforePlaceHolder(OS);
1387 }
1388
1389 void TypePrinter::printDependentTemplateSpecializationAfter(
1390         const DependentTemplateSpecializationType *T, raw_ostream &OS) {}
1391
1392 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1393                                            raw_ostream &OS) {
1394   printBefore(T->getPattern(), OS);
1395 }
1396
1397 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1398                                           raw_ostream &OS) {
1399   printAfter(T->getPattern(), OS);
1400   OS << "...";
1401 }
1402
1403 void TypePrinter::printAttributedBefore(const AttributedType *T,
1404                                         raw_ostream &OS) {
1405   // FIXME: Generate this with TableGen.
1406
1407   // Prefer the macro forms of the GC and ownership qualifiers.
1408   if (T->getAttrKind() == attr::ObjCGC ||
1409       T->getAttrKind() == attr::ObjCOwnership)
1410     return printBefore(T->getEquivalentType(), OS);
1411
1412   if (T->getAttrKind() == attr::ObjCKindOf)
1413     OS << "__kindof ";
1414
1415   if (T->getAttrKind() == attr::AddressSpace)
1416     printBefore(T->getEquivalentType(), OS);
1417   else
1418     printBefore(T->getModifiedType(), OS);
1419
1420   if (T->isMSTypeSpec()) {
1421     switch (T->getAttrKind()) {
1422     default: return;
1423     case attr::Ptr32: OS << " __ptr32"; break;
1424     case attr::Ptr64: OS << " __ptr64"; break;
1425     case attr::SPtr: OS << " __sptr"; break;
1426     case attr::UPtr: OS << " __uptr"; break;
1427     }
1428     spaceBeforePlaceHolder(OS);
1429   }
1430
1431   // Print nullability type specifiers.
1432   if (T->getImmediateNullability()) {
1433     if (T->getAttrKind() == attr::TypeNonNull)
1434       OS << " _Nonnull";
1435     else if (T->getAttrKind() == attr::TypeNullable)
1436       OS << " _Nullable";
1437     else if (T->getAttrKind() == attr::TypeNullUnspecified)
1438       OS << " _Null_unspecified";
1439     else
1440       llvm_unreachable("unhandled nullability");
1441     spaceBeforePlaceHolder(OS);
1442   }
1443 }
1444
1445 void TypePrinter::printAttributedAfter(const AttributedType *T,
1446                                        raw_ostream &OS) {
1447   // FIXME: Generate this with TableGen.
1448
1449   // Prefer the macro forms of the GC and ownership qualifiers.
1450   if (T->getAttrKind() == attr::ObjCGC ||
1451       T->getAttrKind() == attr::ObjCOwnership)
1452     return printAfter(T->getEquivalentType(), OS);
1453
1454   // If this is a calling convention attribute, don't print the implicit CC from
1455   // the modified type.
1456   SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());
1457
1458   printAfter(T->getModifiedType(), OS);
1459
1460   // Some attributes are printed as qualifiers before the type, so we have
1461   // nothing left to do.
1462   if (T->getAttrKind() == attr::ObjCKindOf ||
1463       T->isMSTypeSpec() || T->getImmediateNullability())
1464     return;
1465
1466   // Don't print the inert __unsafe_unretained attribute at all.
1467   if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained)
1468     return;
1469
1470   // Don't print ns_returns_retained unless it had an effect.
1471   if (T->getAttrKind() == attr::NSReturnsRetained &&
1472       !T->getEquivalentType()->castAs<FunctionType>()
1473                              ->getExtInfo().getProducesResult())
1474     return;
1475
1476   if (T->getAttrKind() == attr::LifetimeBound) {
1477     OS << " [[clang::lifetimebound]]";
1478     return;
1479   }
1480
1481   // The printing of the address_space attribute is handled by the qualifier
1482   // since it is still stored in the qualifier. Return early to prevent printing
1483   // this twice.
1484   if (T->getAttrKind() == attr::AddressSpace)
1485     return;
1486
1487   OS << " __attribute__((";
1488   switch (T->getAttrKind()) {
1489 #define TYPE_ATTR(NAME)
1490 #define DECL_OR_TYPE_ATTR(NAME)
1491 #define ATTR(NAME) case attr::NAME:
1492 #include "clang/Basic/AttrList.inc"
1493     llvm_unreachable("non-type attribute attached to type");
1494
1495   case attr::OpenCLPrivateAddressSpace:
1496   case attr::OpenCLGlobalAddressSpace:
1497   case attr::OpenCLLocalAddressSpace:
1498   case attr::OpenCLConstantAddressSpace:
1499   case attr::OpenCLGenericAddressSpace:
1500     // FIXME: Update printAttributedBefore to print these once we generate
1501     // AttributedType nodes for them.
1502     break;
1503
1504   case attr::LifetimeBound:
1505   case attr::TypeNonNull:
1506   case attr::TypeNullable:
1507   case attr::TypeNullUnspecified:
1508   case attr::ObjCGC:
1509   case attr::ObjCInertUnsafeUnretained:
1510   case attr::ObjCKindOf:
1511   case attr::ObjCOwnership:
1512   case attr::Ptr32:
1513   case attr::Ptr64:
1514   case attr::SPtr:
1515   case attr::UPtr:
1516   case attr::AddressSpace:
1517     llvm_unreachable("This attribute should have been handled already");
1518
1519   case attr::NSReturnsRetained:
1520     OS << "ns_returns_retained";
1521     break;
1522
1523   // FIXME: When Sema learns to form this AttributedType, avoid printing the
1524   // attribute again in printFunctionProtoAfter.
1525   case attr::AnyX86NoCfCheck: OS << "nocf_check"; break;
1526   case attr::CDecl: OS << "cdecl"; break;
1527   case attr::FastCall: OS << "fastcall"; break;
1528   case attr::StdCall: OS << "stdcall"; break;
1529   case attr::ThisCall: OS << "thiscall"; break;
1530   case attr::SwiftCall: OS << "swiftcall"; break;
1531   case attr::VectorCall: OS << "vectorcall"; break;
1532   case attr::Pascal: OS << "pascal"; break;
1533   case attr::MSABI: OS << "ms_abi"; break;
1534   case attr::SysVABI: OS << "sysv_abi"; break;
1535   case attr::RegCall: OS << "regcall"; break;
1536   case attr::Pcs: {
1537     OS << "pcs(";
1538    QualType t = T->getEquivalentType();
1539    while (!t->isFunctionType())
1540      t = t->getPointeeType();
1541    OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS ?
1542          "\"aapcs\"" : "\"aapcs-vfp\"");
1543    OS << ')';
1544    break;
1545   }
1546   case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break;
1547   case attr::IntelOclBicc: OS << "inteloclbicc"; break;
1548   case attr::PreserveMost:
1549     OS << "preserve_most";
1550     break;
1551
1552   case attr::PreserveAll:
1553     OS << "preserve_all";
1554     break;
1555   case attr::NoDeref:
1556     OS << "noderef";
1557     break;
1558   }
1559   OS << "))";
1560 }
1561
1562 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1563                                            raw_ostream &OS) {
1564   OS << T->getDecl()->getName();
1565   spaceBeforePlaceHolder(OS);
1566 }
1567
1568 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1569                                           raw_ostream &OS) {}
1570
1571 void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T,
1572                                           raw_ostream &OS) {
1573   OS << T->getDecl()->getName();
1574   if (!T->qual_empty()) {
1575     bool isFirst = true;
1576     OS << '<';
1577     for (const auto *I : T->quals()) {
1578       if (isFirst)
1579         isFirst = false;
1580       else
1581         OS << ',';
1582       OS << I->getName();
1583     }
1584     OS << '>';
1585   }
1586
1587   spaceBeforePlaceHolder(OS);
1588 }
1589
1590 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
1591                                           raw_ostream &OS) {}
1592
1593 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
1594                                         raw_ostream &OS) {
1595   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1596       !T->isKindOfTypeAsWritten())
1597     return printBefore(T->getBaseType(), OS);
1598
1599   if (T->isKindOfTypeAsWritten())
1600     OS << "__kindof ";
1601
1602   print(T->getBaseType(), OS, StringRef());
1603
1604   if (T->isSpecializedAsWritten()) {
1605     bool isFirst = true;
1606     OS << '<';
1607     for (auto typeArg : T->getTypeArgsAsWritten()) {
1608       if (isFirst)
1609         isFirst = false;
1610       else
1611         OS << ",";
1612
1613       print(typeArg, OS, StringRef());
1614     }
1615     OS << '>';
1616   }
1617
1618   if (!T->qual_empty()) {
1619     bool isFirst = true;
1620     OS << '<';
1621     for (const auto *I : T->quals()) {
1622       if (isFirst)
1623         isFirst = false;
1624       else
1625         OS << ',';
1626       OS << I->getName();
1627     }
1628     OS << '>';
1629   }
1630
1631   spaceBeforePlaceHolder(OS);
1632 }
1633
1634 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
1635                                         raw_ostream &OS) {
1636   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1637       !T->isKindOfTypeAsWritten())
1638     return printAfter(T->getBaseType(), OS);
1639 }
1640
1641 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
1642                                                raw_ostream &OS) {
1643   printBefore(T->getPointeeType(), OS);
1644
1645   // If we need to print the pointer, print it now.
1646   if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
1647       !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
1648     if (HasEmptyPlaceHolder)
1649       OS << ' ';
1650     OS << '*';
1651   }
1652 }
1653
1654 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1655                                               raw_ostream &OS) {}
1656
1657 static
1658 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1659
1660 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
1661   return A.getArgument();
1662 }
1663
1664 static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP,
1665                           llvm::raw_ostream &OS) {
1666   A.print(PP, OS);
1667 }
1668
1669 static void printArgument(const TemplateArgumentLoc &A,
1670                           const PrintingPolicy &PP, llvm::raw_ostream &OS) {
1671   const TemplateArgument::ArgKind &Kind = A.getArgument().getKind();
1672   if (Kind == TemplateArgument::ArgKind::Type)
1673     return A.getTypeSourceInfo()->getType().print(OS, PP);
1674   return A.getArgument().print(PP, OS);
1675 }
1676
1677 template<typename TA>
1678 static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
1679                     const PrintingPolicy &Policy, bool SkipBrackets) {
1680   const char *Comma = Policy.MSVCFormatting ? "," : ", ";
1681   if (!SkipBrackets)
1682     OS << '<';
1683
1684   bool NeedSpace = false;
1685   bool FirstArg = true;
1686   for (const auto &Arg : Args) {
1687     // Print the argument into a string.
1688     SmallString<128> Buf;
1689     llvm::raw_svector_ostream ArgOS(Buf);
1690     const TemplateArgument &Argument = getArgument(Arg);
1691     if (Argument.getKind() == TemplateArgument::Pack) {
1692       if (Argument.pack_size() && !FirstArg)
1693         OS << Comma;
1694       printTo(ArgOS, Argument.getPackAsArray(), Policy, true);
1695     } else {
1696       if (!FirstArg)
1697         OS << Comma;
1698       // Tries to print the argument with location info if exists.
1699       printArgument(Arg, Policy, ArgOS);
1700     }
1701     StringRef ArgString = ArgOS.str();
1702
1703     // If this is the first argument and its string representation
1704     // begins with the global scope specifier ('::foo'), add a space
1705     // to avoid printing the diagraph '<:'.
1706     if (FirstArg && !ArgString.empty() && ArgString[0] == ':')
1707       OS << ' ';
1708
1709     OS << ArgString;
1710
1711     NeedSpace = (!ArgString.empty() && ArgString.back() == '>');
1712     FirstArg = false;
1713   }
1714
1715   // If the last character of our string is '>', add another space to
1716   // keep the two '>''s separate tokens. We don't *have* to do this in
1717   // C++0x, but it's still good hygiene.
1718   if (NeedSpace)
1719     OS << ' ';
1720
1721   if (!SkipBrackets)
1722     OS << '>';
1723 }
1724
1725 void clang::printTemplateArgumentList(raw_ostream &OS,
1726                                       const TemplateArgumentListInfo &Args,
1727                                       const PrintingPolicy &Policy) {
1728   return printTo(OS, Args.arguments(), Policy, false);
1729 }
1730
1731 void clang::printTemplateArgumentList(raw_ostream &OS,
1732                                       ArrayRef<TemplateArgument> Args,
1733                                       const PrintingPolicy &Policy) {
1734   printTo(OS, Args, Policy, false);
1735 }
1736
1737 void clang::printTemplateArgumentList(raw_ostream &OS,
1738                                       ArrayRef<TemplateArgumentLoc> Args,
1739                                       const PrintingPolicy &Policy) {
1740   printTo(OS, Args, Policy, false);
1741 }
1742
1743 std::string Qualifiers::getAsString() const {
1744   LangOptions LO;
1745   return getAsString(PrintingPolicy(LO));
1746 }
1747
1748 // Appends qualifiers to the given string, separated by spaces.  Will
1749 // prefix a space if the string is non-empty.  Will not append a final
1750 // space.
1751 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
1752   SmallString<64> Buf;
1753   llvm::raw_svector_ostream StrOS(Buf);
1754   print(StrOS, Policy);
1755   return StrOS.str();
1756 }
1757
1758 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
1759   if (getCVRQualifiers())
1760     return false;
1761
1762   if (getAddressSpace() != LangAS::Default)
1763     return false;
1764
1765   if (getObjCGCAttr())
1766     return false;
1767
1768   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
1769     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
1770       return false;
1771
1772   return true;
1773 }
1774
1775 // Appends qualifiers to the given string, separated by spaces.  Will
1776 // prefix a space if the string is non-empty.  Will not append a final
1777 // space.
1778 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
1779                        bool appendSpaceIfNonEmpty) const {
1780   bool addSpace = false;
1781
1782   unsigned quals = getCVRQualifiers();
1783   if (quals) {
1784     AppendTypeQualList(OS, quals, Policy.Restrict);
1785     addSpace = true;
1786   }
1787   if (hasUnaligned()) {
1788     if (addSpace)
1789       OS << ' ';
1790     OS << "__unaligned";
1791     addSpace = true;
1792   }
1793   LangAS addrspace = getAddressSpace();
1794   if (addrspace != LangAS::Default) {
1795     if (addrspace != LangAS::opencl_private) {
1796       if (addSpace)
1797         OS << ' ';
1798       addSpace = true;
1799       switch (addrspace) {
1800       case LangAS::opencl_global:
1801         OS << "__global";
1802         break;
1803       case LangAS::opencl_local:
1804         OS << "__local";
1805         break;
1806       case LangAS::opencl_private:
1807         break;
1808       case LangAS::opencl_constant:
1809         OS << "__constant";
1810         break;
1811       case LangAS::opencl_generic:
1812         OS << "__generic";
1813         break;
1814       case LangAS::cuda_device:
1815         OS << "__device__";
1816         break;
1817       case LangAS::cuda_constant:
1818         OS << "__constant__";
1819         break;
1820       case LangAS::cuda_shared:
1821         OS << "__shared__";
1822         break;
1823       default:
1824         OS << "__attribute__((address_space(";
1825         OS << toTargetAddressSpace(addrspace);
1826         OS << ")))";
1827       }
1828     }
1829   }
1830   if (Qualifiers::GC gc = getObjCGCAttr()) {
1831     if (addSpace)
1832       OS << ' ';
1833     addSpace = true;
1834     if (gc == Qualifiers::Weak)
1835       OS << "__weak";
1836     else
1837       OS << "__strong";
1838   }
1839   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
1840     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
1841       if (addSpace)
1842         OS << ' ';
1843       addSpace = true;
1844     }
1845
1846     switch (lifetime) {
1847     case Qualifiers::OCL_None: llvm_unreachable("none but true");
1848     case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
1849     case Qualifiers::OCL_Strong:
1850       if (!Policy.SuppressStrongLifetime)
1851         OS << "__strong";
1852       break;
1853
1854     case Qualifiers::OCL_Weak: OS << "__weak"; break;
1855     case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
1856     }
1857   }
1858
1859   if (appendSpaceIfNonEmpty && addSpace)
1860     OS << ' ';
1861 }
1862
1863 std::string QualType::getAsString() const {
1864   return getAsString(split(), LangOptions());
1865 }
1866
1867 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1868   std::string S;
1869   getAsStringInternal(S, Policy);
1870   return S;
1871 }
1872
1873 std::string QualType::getAsString(const Type *ty, Qualifiers qs,
1874                                   const PrintingPolicy &Policy) {
1875   std::string buffer;
1876   getAsStringInternal(ty, qs, buffer, Policy);
1877   return buffer;
1878 }
1879
1880 void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy,
1881                      const Twine &PlaceHolder, unsigned Indentation) const {
1882   print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder,
1883         Indentation);
1884 }
1885
1886 void QualType::print(const Type *ty, Qualifiers qs,
1887                      raw_ostream &OS, const PrintingPolicy &policy,
1888                      const Twine &PlaceHolder, unsigned Indentation) {
1889   SmallString<128> PHBuf;
1890   StringRef PH = PlaceHolder.toStringRef(PHBuf);
1891
1892   TypePrinter(policy, Indentation).print(ty, qs, OS, PH);
1893 }
1894
1895 void QualType::getAsStringInternal(std::string &Str,
1896                                    const PrintingPolicy &Policy) const {
1897   return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
1898                              Policy);
1899 }
1900
1901 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
1902                                    std::string &buffer,
1903                                    const PrintingPolicy &policy) {
1904   SmallString<256> Buf;
1905   llvm::raw_svector_ostream StrOS(Buf);
1906   TypePrinter(policy).print(ty, qs, StrOS, buffer);
1907   std::string str = StrOS.str();
1908   buffer.swap(str);
1909 }