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.def"
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.def"
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.def"
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     if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
1208       const TemplateSpecializationType *TST =
1209         cast<TemplateSpecializationType>(TAW->getType());
1210       Args = TST->template_arguments();
1211     } else {
1212       const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1213       Args = TemplateArgs.asArray();
1214     }
1215     IncludeStrongLifetimeRAII Strong(Policy);
1216     printTemplateArgumentList(OS, Args, Policy);
1217   }
1218 
1219   spaceBeforePlaceHolder(OS);
1220 }
1221 
1222 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
1223   printTag(T->getDecl(), OS);
1224 }
1225 
1226 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}
1227 
1228 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
1229   printTag(T->getDecl(), OS);
1230 }
1231 
1232 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}
1233 
1234 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
1235                                               raw_ostream &OS) {
1236   if (IdentifierInfo *Id = T->getIdentifier())
1237     OS << Id->getName();
1238   else {
1239     bool IsLambdaAutoParam = false;
1240     if (auto D = T->getDecl()) {
1241       if (auto M = dyn_cast_or_null<CXXMethodDecl>(D->getDeclContext()))
1242         IsLambdaAutoParam = D->isImplicit() && M->getParent()->isLambda();
1243     }
1244 
1245     if (IsLambdaAutoParam)
1246       OS << "auto";
1247     else
1248       OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
1249   }
1250   spaceBeforePlaceHolder(OS);
1251 }
1252 
1253 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
1254                                              raw_ostream &OS) {}
1255 
1256 void TypePrinter::printSubstTemplateTypeParmBefore(
1257                                              const SubstTemplateTypeParmType *T,
1258                                              raw_ostream &OS) {
1259   IncludeStrongLifetimeRAII Strong(Policy);
1260   printBefore(T->getReplacementType(), OS);
1261 }
1262 
1263 void TypePrinter::printSubstTemplateTypeParmAfter(
1264                                              const SubstTemplateTypeParmType *T,
1265                                              raw_ostream &OS) {
1266   IncludeStrongLifetimeRAII Strong(Policy);
1267   printAfter(T->getReplacementType(), OS);
1268 }
1269 
1270 void TypePrinter::printSubstTemplateTypeParmPackBefore(
1271                                         const SubstTemplateTypeParmPackType *T,
1272                                         raw_ostream &OS) {
1273   IncludeStrongLifetimeRAII Strong(Policy);
1274   printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
1275 }
1276 
1277 void TypePrinter::printSubstTemplateTypeParmPackAfter(
1278                                         const SubstTemplateTypeParmPackType *T,
1279                                         raw_ostream &OS) {
1280   IncludeStrongLifetimeRAII Strong(Policy);
1281   printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
1282 }
1283 
1284 void TypePrinter::printTemplateSpecializationBefore(
1285                                             const TemplateSpecializationType *T,
1286                                             raw_ostream &OS) {
1287   IncludeStrongLifetimeRAII Strong(Policy);
1288   T->getTemplateName().print(OS, Policy);
1289 
1290   printTemplateArgumentList(OS, T->template_arguments(), Policy);
1291   spaceBeforePlaceHolder(OS);
1292 }
1293 
1294 void TypePrinter::printTemplateSpecializationAfter(
1295                                             const TemplateSpecializationType *T,
1296                                             raw_ostream &OS) {}
1297 
1298 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
1299                                                raw_ostream &OS) {
1300   printTemplateSpecializationBefore(T->getInjectedTST(), OS);
1301 }
1302 
1303 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
1304                                                raw_ostream &OS) {}
1305 
1306 void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
1307                                         raw_ostream &OS) {
1308   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
1309     TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
1310     assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() &&
1311            "OwnedTagDecl expected to be a declaration for the type");
1312     PrintingPolicy SubPolicy = Policy;
1313     SubPolicy.IncludeTagDefinition = false;
1314     OwnedTagDecl->print(OS, SubPolicy, Indentation);
1315     spaceBeforePlaceHolder(OS);
1316     return;
1317   }
1318 
1319   // The tag definition will take care of these.
1320   if (!Policy.IncludeTagDefinition)
1321   {
1322     OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1323     if (T->getKeyword() != ETK_None)
1324       OS << " ";
1325     NestedNameSpecifier *Qualifier = T->getQualifier();
1326     if (Qualifier)
1327       Qualifier->print(OS, Policy);
1328   }
1329 
1330   ElaboratedTypePolicyRAII PolicyRAII(Policy);
1331   printBefore(T->getNamedType(), OS);
1332 }
1333 
1334 void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
1335                                         raw_ostream &OS) {
1336   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
1337     return;
1338   ElaboratedTypePolicyRAII PolicyRAII(Policy);
1339   printAfter(T->getNamedType(), OS);
1340 }
1341 
1342 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
1343   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1344     printBefore(T->getInnerType(), OS);
1345     OS << '(';
1346   } else
1347     printBefore(T->getInnerType(), OS);
1348 }
1349 
1350 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
1351   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
1352     OS << ')';
1353     printAfter(T->getInnerType(), OS);
1354   } else
1355     printAfter(T->getInnerType(), OS);
1356 }
1357 
1358 void TypePrinter::printDependentNameBefore(const DependentNameType *T,
1359                                            raw_ostream &OS) {
1360   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1361   if (T->getKeyword() != ETK_None)
1362     OS << " ";
1363 
1364   T->getQualifier()->print(OS, Policy);
1365 
1366   OS << T->getIdentifier()->getName();
1367   spaceBeforePlaceHolder(OS);
1368 }
1369 
1370 void TypePrinter::printDependentNameAfter(const DependentNameType *T,
1371                                           raw_ostream &OS) {}
1372 
1373 void TypePrinter::printDependentTemplateSpecializationBefore(
1374         const DependentTemplateSpecializationType *T, raw_ostream &OS) {
1375   IncludeStrongLifetimeRAII Strong(Policy);
1376 
1377   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
1378   if (T->getKeyword() != ETK_None)
1379     OS << " ";
1380 
1381   if (T->getQualifier())
1382     T->getQualifier()->print(OS, Policy);
1383   OS << T->getIdentifier()->getName();
1384   printTemplateArgumentList(OS, T->template_arguments(), Policy);
1385   spaceBeforePlaceHolder(OS);
1386 }
1387 
1388 void TypePrinter::printDependentTemplateSpecializationAfter(
1389         const DependentTemplateSpecializationType *T, raw_ostream &OS) {}
1390 
1391 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
1392                                            raw_ostream &OS) {
1393   printBefore(T->getPattern(), OS);
1394 }
1395 
1396 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
1397                                           raw_ostream &OS) {
1398   printAfter(T->getPattern(), OS);
1399   OS << "...";
1400 }
1401 
1402 void TypePrinter::printAttributedBefore(const AttributedType *T,
1403                                         raw_ostream &OS) {
1404   // FIXME: Generate this with TableGen.
1405 
1406   // Prefer the macro forms of the GC and ownership qualifiers.
1407   if (T->getAttrKind() == attr::ObjCGC ||
1408       T->getAttrKind() == attr::ObjCOwnership)
1409     return printBefore(T->getEquivalentType(), OS);
1410 
1411   if (T->getAttrKind() == attr::ObjCKindOf)
1412     OS << "__kindof ";
1413 
1414   if (T->getAttrKind() == attr::AddressSpace)
1415     printBefore(T->getEquivalentType(), OS);
1416   else
1417     printBefore(T->getModifiedType(), OS);
1418 
1419   if (T->isMSTypeSpec()) {
1420     switch (T->getAttrKind()) {
1421     default: return;
1422     case attr::Ptr32: OS << " __ptr32"; break;
1423     case attr::Ptr64: OS << " __ptr64"; break;
1424     case attr::SPtr: OS << " __sptr"; break;
1425     case attr::UPtr: OS << " __uptr"; break;
1426     }
1427     spaceBeforePlaceHolder(OS);
1428   }
1429 
1430   // Print nullability type specifiers.
1431   if (T->getImmediateNullability()) {
1432     if (T->getAttrKind() == attr::TypeNonNull)
1433       OS << " _Nonnull";
1434     else if (T->getAttrKind() == attr::TypeNullable)
1435       OS << " _Nullable";
1436     else if (T->getAttrKind() == attr::TypeNullUnspecified)
1437       OS << " _Null_unspecified";
1438     else
1439       llvm_unreachable("unhandled nullability");
1440     spaceBeforePlaceHolder(OS);
1441   }
1442 }
1443 
1444 void TypePrinter::printAttributedAfter(const AttributedType *T,
1445                                        raw_ostream &OS) {
1446   // FIXME: Generate this with TableGen.
1447 
1448   // Prefer the macro forms of the GC and ownership qualifiers.
1449   if (T->getAttrKind() == attr::ObjCGC ||
1450       T->getAttrKind() == attr::ObjCOwnership)
1451     return printAfter(T->getEquivalentType(), OS);
1452 
1453   // If this is a calling convention attribute, don't print the implicit CC from
1454   // the modified type.
1455   SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv());
1456 
1457   printAfter(T->getModifiedType(), OS);
1458 
1459   // Some attributes are printed as qualifiers before the type, so we have
1460   // nothing left to do.
1461   if (T->getAttrKind() == attr::ObjCKindOf ||
1462       T->isMSTypeSpec() || T->getImmediateNullability())
1463     return;
1464 
1465   // Don't print the inert __unsafe_unretained attribute at all.
1466   if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained)
1467     return;
1468 
1469   // Don't print ns_returns_retained unless it had an effect.
1470   if (T->getAttrKind() == attr::NSReturnsRetained &&
1471       !T->getEquivalentType()->castAs<FunctionType>()
1472                              ->getExtInfo().getProducesResult())
1473     return;
1474 
1475   if (T->getAttrKind() == attr::LifetimeBound) {
1476     OS << " [[clang::lifetimebound]]";
1477     return;
1478   }
1479 
1480   // The printing of the address_space attribute is handled by the qualifier
1481   // since it is still stored in the qualifier. Return early to prevent printing
1482   // this twice.
1483   if (T->getAttrKind() == attr::AddressSpace)
1484     return;
1485 
1486   OS << " __attribute__((";
1487   switch (T->getAttrKind()) {
1488 #define TYPE_ATTR(NAME)
1489 #define DECL_OR_TYPE_ATTR(NAME)
1490 #define ATTR(NAME) case attr::NAME:
1491 #include "clang/Basic/AttrList.inc"
1492     llvm_unreachable("non-type attribute attached to type");
1493 
1494   case attr::OpenCLPrivateAddressSpace:
1495   case attr::OpenCLGlobalAddressSpace:
1496   case attr::OpenCLLocalAddressSpace:
1497   case attr::OpenCLConstantAddressSpace:
1498   case attr::OpenCLGenericAddressSpace:
1499     // FIXME: Update printAttributedBefore to print these once we generate
1500     // AttributedType nodes for them.
1501     break;
1502 
1503   case attr::LifetimeBound:
1504   case attr::TypeNonNull:
1505   case attr::TypeNullable:
1506   case attr::TypeNullUnspecified:
1507   case attr::ObjCGC:
1508   case attr::ObjCInertUnsafeUnretained:
1509   case attr::ObjCKindOf:
1510   case attr::ObjCOwnership:
1511   case attr::Ptr32:
1512   case attr::Ptr64:
1513   case attr::SPtr:
1514   case attr::UPtr:
1515   case attr::AddressSpace:
1516     llvm_unreachable("This attribute should have been handled already");
1517 
1518   case attr::NSReturnsRetained:
1519     OS << "ns_returns_retained";
1520     break;
1521 
1522   // FIXME: When Sema learns to form this AttributedType, avoid printing the
1523   // attribute again in printFunctionProtoAfter.
1524   case attr::AnyX86NoCfCheck: OS << "nocf_check"; break;
1525   case attr::CDecl: OS << "cdecl"; break;
1526   case attr::FastCall: OS << "fastcall"; break;
1527   case attr::StdCall: OS << "stdcall"; break;
1528   case attr::ThisCall: OS << "thiscall"; break;
1529   case attr::SwiftCall: OS << "swiftcall"; break;
1530   case attr::VectorCall: OS << "vectorcall"; break;
1531   case attr::Pascal: OS << "pascal"; break;
1532   case attr::MSABI: OS << "ms_abi"; break;
1533   case attr::SysVABI: OS << "sysv_abi"; break;
1534   case attr::RegCall: OS << "regcall"; break;
1535   case attr::Pcs: {
1536     OS << "pcs(";
1537    QualType t = T->getEquivalentType();
1538    while (!t->isFunctionType())
1539      t = t->getPointeeType();
1540    OS << (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ?
1541          "\"aapcs\"" : "\"aapcs-vfp\"");
1542    OS << ')';
1543    break;
1544   }
1545   case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break;
1546   case attr::IntelOclBicc: OS << "inteloclbicc"; break;
1547   case attr::PreserveMost:
1548     OS << "preserve_most";
1549     break;
1550 
1551   case attr::PreserveAll:
1552     OS << "preserve_all";
1553     break;
1554   case attr::NoDeref:
1555     OS << "noderef";
1556     break;
1557   }
1558   OS << "))";
1559 }
1560 
1561 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
1562                                            raw_ostream &OS) {
1563   OS << T->getDecl()->getName();
1564   spaceBeforePlaceHolder(OS);
1565 }
1566 
1567 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
1568                                           raw_ostream &OS) {}
1569 
1570 void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T,
1571                                           raw_ostream &OS) {
1572   OS << T->getDecl()->getName();
1573   if (!T->qual_empty()) {
1574     bool isFirst = true;
1575     OS << '<';
1576     for (const auto *I : T->quals()) {
1577       if (isFirst)
1578         isFirst = false;
1579       else
1580         OS << ',';
1581       OS << I->getName();
1582     }
1583     OS << '>';
1584   }
1585 
1586   spaceBeforePlaceHolder(OS);
1587 }
1588 
1589 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
1590                                           raw_ostream &OS) {}
1591 
1592 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
1593                                         raw_ostream &OS) {
1594   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1595       !T->isKindOfTypeAsWritten())
1596     return printBefore(T->getBaseType(), OS);
1597 
1598   if (T->isKindOfTypeAsWritten())
1599     OS << "__kindof ";
1600 
1601   print(T->getBaseType(), OS, StringRef());
1602 
1603   if (T->isSpecializedAsWritten()) {
1604     bool isFirst = true;
1605     OS << '<';
1606     for (auto typeArg : T->getTypeArgsAsWritten()) {
1607       if (isFirst)
1608         isFirst = false;
1609       else
1610         OS << ",";
1611 
1612       print(typeArg, OS, StringRef());
1613     }
1614     OS << '>';
1615   }
1616 
1617   if (!T->qual_empty()) {
1618     bool isFirst = true;
1619     OS << '<';
1620     for (const auto *I : T->quals()) {
1621       if (isFirst)
1622         isFirst = false;
1623       else
1624         OS << ',';
1625       OS << I->getName();
1626     }
1627     OS << '>';
1628   }
1629 
1630   spaceBeforePlaceHolder(OS);
1631 }
1632 
1633 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
1634                                         raw_ostream &OS) {
1635   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
1636       !T->isKindOfTypeAsWritten())
1637     return printAfter(T->getBaseType(), OS);
1638 }
1639 
1640 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
1641                                                raw_ostream &OS) {
1642   printBefore(T->getPointeeType(), OS);
1643 
1644   // If we need to print the pointer, print it now.
1645   if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() &&
1646       !T->isObjCClassType() && !T->isObjCQualifiedClassType()) {
1647     if (HasEmptyPlaceHolder)
1648       OS << ' ';
1649     OS << '*';
1650   }
1651 }
1652 
1653 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
1654                                               raw_ostream &OS) {}
1655 
1656 static
1657 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
1658 
1659 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
1660   return A.getArgument();
1661 }
1662 
1663 static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP,
1664                           llvm::raw_ostream &OS) {
1665   A.print(PP, OS);
1666 }
1667 
1668 static void printArgument(const TemplateArgumentLoc &A,
1669                           const PrintingPolicy &PP, llvm::raw_ostream &OS) {
1670   const TemplateArgument::ArgKind &Kind = A.getArgument().getKind();
1671   if (Kind == TemplateArgument::ArgKind::Type)
1672     return A.getTypeSourceInfo()->getType().print(OS, PP);
1673   return A.getArgument().print(PP, OS);
1674 }
1675 
1676 template<typename TA>
1677 static void printTo(raw_ostream &OS, ArrayRef<TA> Args,
1678                     const PrintingPolicy &Policy, bool SkipBrackets) {
1679   const char *Comma = Policy.MSVCFormatting ? "," : ", ";
1680   if (!SkipBrackets)
1681     OS << '<';
1682 
1683   bool NeedSpace = false;
1684   bool FirstArg = true;
1685   for (const auto &Arg : Args) {
1686     // Print the argument into a string.
1687     SmallString<128> Buf;
1688     llvm::raw_svector_ostream ArgOS(Buf);
1689     const TemplateArgument &Argument = getArgument(Arg);
1690     if (Argument.getKind() == TemplateArgument::Pack) {
1691       if (Argument.pack_size() && !FirstArg)
1692         OS << Comma;
1693       printTo(ArgOS, Argument.getPackAsArray(), Policy, true);
1694     } else {
1695       if (!FirstArg)
1696         OS << Comma;
1697       // Tries to print the argument with location info if exists.
1698       printArgument(Arg, Policy, ArgOS);
1699     }
1700     StringRef ArgString = ArgOS.str();
1701 
1702     // If this is the first argument and its string representation
1703     // begins with the global scope specifier ('::foo'), add a space
1704     // to avoid printing the diagraph '<:'.
1705     if (FirstArg && !ArgString.empty() && ArgString[0] == ':')
1706       OS << ' ';
1707 
1708     OS << ArgString;
1709 
1710     NeedSpace = (!ArgString.empty() && ArgString.back() == '>');
1711     FirstArg = false;
1712   }
1713 
1714   // If the last character of our string is '>', add another space to
1715   // keep the two '>''s separate tokens. We don't *have* to do this in
1716   // C++0x, but it's still good hygiene.
1717   if (NeedSpace)
1718     OS << ' ';
1719 
1720   if (!SkipBrackets)
1721     OS << '>';
1722 }
1723 
1724 void clang::printTemplateArgumentList(raw_ostream &OS,
1725                                       const TemplateArgumentListInfo &Args,
1726                                       const PrintingPolicy &Policy) {
1727   return printTo(OS, Args.arguments(), Policy, false);
1728 }
1729 
1730 void clang::printTemplateArgumentList(raw_ostream &OS,
1731                                       ArrayRef<TemplateArgument> Args,
1732                                       const PrintingPolicy &Policy) {
1733   printTo(OS, Args, Policy, false);
1734 }
1735 
1736 void clang::printTemplateArgumentList(raw_ostream &OS,
1737                                       ArrayRef<TemplateArgumentLoc> Args,
1738                                       const PrintingPolicy &Policy) {
1739   printTo(OS, Args, Policy, false);
1740 }
1741 
1742 std::string Qualifiers::getAsString() const {
1743   LangOptions LO;
1744   return getAsString(PrintingPolicy(LO));
1745 }
1746 
1747 // Appends qualifiers to the given string, separated by spaces.  Will
1748 // prefix a space if the string is non-empty.  Will not append a final
1749 // space.
1750 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
1751   SmallString<64> Buf;
1752   llvm::raw_svector_ostream StrOS(Buf);
1753   print(StrOS, Policy);
1754   return StrOS.str();
1755 }
1756 
1757 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
1758   if (getCVRQualifiers())
1759     return false;
1760 
1761   if (getAddressSpace() != LangAS::Default)
1762     return false;
1763 
1764   if (getObjCGCAttr())
1765     return false;
1766 
1767   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime())
1768     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime))
1769       return false;
1770 
1771   return true;
1772 }
1773 
1774 // Appends qualifiers to the given string, separated by spaces.  Will
1775 // prefix a space if the string is non-empty.  Will not append a final
1776 // space.
1777 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
1778                        bool appendSpaceIfNonEmpty) const {
1779   bool addSpace = false;
1780 
1781   unsigned quals = getCVRQualifiers();
1782   if (quals) {
1783     AppendTypeQualList(OS, quals, Policy.Restrict);
1784     addSpace = true;
1785   }
1786   if (hasUnaligned()) {
1787     if (addSpace)
1788       OS << ' ';
1789     OS << "__unaligned";
1790     addSpace = true;
1791   }
1792   LangAS addrspace = getAddressSpace();
1793   if (addrspace != LangAS::Default) {
1794     if (addrspace != LangAS::opencl_private) {
1795       if (addSpace)
1796         OS << ' ';
1797       addSpace = true;
1798       switch (addrspace) {
1799       case LangAS::opencl_global:
1800         OS << "__global";
1801         break;
1802       case LangAS::opencl_local:
1803         OS << "__local";
1804         break;
1805       case LangAS::opencl_private:
1806         break;
1807       case LangAS::opencl_constant:
1808         OS << "__constant";
1809         break;
1810       case LangAS::opencl_generic:
1811         OS << "__generic";
1812         break;
1813       case LangAS::cuda_device:
1814         OS << "__device__";
1815         break;
1816       case LangAS::cuda_constant:
1817         OS << "__constant__";
1818         break;
1819       case LangAS::cuda_shared:
1820         OS << "__shared__";
1821         break;
1822       default:
1823         OS << "__attribute__((address_space(";
1824         OS << toTargetAddressSpace(addrspace);
1825         OS << ")))";
1826       }
1827     }
1828   }
1829   if (Qualifiers::GC gc = getObjCGCAttr()) {
1830     if (addSpace)
1831       OS << ' ';
1832     addSpace = true;
1833     if (gc == Qualifiers::Weak)
1834       OS << "__weak";
1835     else
1836       OS << "__strong";
1837   }
1838   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
1839     if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
1840       if (addSpace)
1841         OS << ' ';
1842       addSpace = true;
1843     }
1844 
1845     switch (lifetime) {
1846     case Qualifiers::OCL_None: llvm_unreachable("none but true");
1847     case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
1848     case Qualifiers::OCL_Strong:
1849       if (!Policy.SuppressStrongLifetime)
1850         OS << "__strong";
1851       break;
1852 
1853     case Qualifiers::OCL_Weak: OS << "__weak"; break;
1854     case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
1855     }
1856   }
1857 
1858   if (appendSpaceIfNonEmpty && addSpace)
1859     OS << ' ';
1860 }
1861 
1862 std::string QualType::getAsString() const {
1863   return getAsString(split(), LangOptions());
1864 }
1865 
1866 std::string QualType::getAsString(const PrintingPolicy &Policy) const {
1867   std::string S;
1868   getAsStringInternal(S, Policy);
1869   return S;
1870 }
1871 
1872 std::string QualType::getAsString(const Type *ty, Qualifiers qs,
1873                                   const PrintingPolicy &Policy) {
1874   std::string buffer;
1875   getAsStringInternal(ty, qs, buffer, Policy);
1876   return buffer;
1877 }
1878 
1879 void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy,
1880                      const Twine &PlaceHolder, unsigned Indentation) const {
1881   print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder,
1882         Indentation);
1883 }
1884 
1885 void QualType::print(const Type *ty, Qualifiers qs,
1886                      raw_ostream &OS, const PrintingPolicy &policy,
1887                      const Twine &PlaceHolder, unsigned Indentation) {
1888   SmallString<128> PHBuf;
1889   StringRef PH = PlaceHolder.toStringRef(PHBuf);
1890 
1891   TypePrinter(policy, Indentation).print(ty, qs, OS, PH);
1892 }
1893 
1894 void QualType::getAsStringInternal(std::string &Str,
1895                                    const PrintingPolicy &Policy) const {
1896   return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
1897                              Policy);
1898 }
1899 
1900 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
1901                                    std::string &buffer,
1902                                    const PrintingPolicy &policy) {
1903   SmallString<256> Buf;
1904   llvm::raw_svector_ostream StrOS(Buf);
1905   TypePrinter(policy).print(ty, qs, StrOS, buffer);
1906   std::string str = StrOS.str();
1907   buffer.swap(str);
1908 }
1909